Files
ANSCORE/modules/ANSLLM/ANSLLM.cpp
T
nghianguyenandClaude Opus 5 cb964907f0 feat(ANSLS): know ANSMIND as 1009, and stop filing unknown products under it
The gateway's product table already runs to 1009 ANSMIND and 1010 ANSGW.
The licensing library stopped at 1008, so a real ANSMIND licence could not
be named, deactivated or listed here, while every product name it did not
recognise quietly became product 1009. With 1009 now a real product, that
fallback would mint an ANSMIND trial for a typo.

ANSPRODUCTS gains ANSMIND = 1009 and ANSGW = 1010, and both are added
wherever the product table is spelled out: ActivateTrialLicense,
DeactivateLicense, ActivateLicense, ActivateLicenseWithCustomHWID and
ListLicenses, which now reports an ANSMIND and an ANSGW row like the
gateway does.

Unknown names no longer map to any id. ActivateTrialLicense returns 0, its
existing failure value, instead of generating a key. ListLicenses skips
the row. ActivateLicense and ActivateLicenseWithCustomHWID keep passing
the name through as the registration name: they never assigned an id, the
key's own validation data rejects a name it was not issued for, and the
gateway resolves an unknown product the same way.

The ANSVIS master-licence rule in LicenseVerification is untouched.

Separately, the fallback loops in ANSUtilities, ANSAWSS3 and ANSLLM asked
for product 1008 under the registration name "ANSSRT". The product is
ANSTS, so a genuine ANSTS licence could never satisfy them. Only that
string changes; the loops still stop at 1008.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-13 10:38:31 +10:00

667 lines
23 KiB
C++

#include "ANSLLM.h"
#include <CkGlobal.h>
#include <CkBinData.h>
#include <CkByteData.h>
#include <CkStringTable.h>
#include <CkStringBuilder.h>
#include <CkJsonObject.h>
static bool ansllmLicenceValid = false;
static std::once_flag ansllmLicenseOnceFlag;
namespace ANSCENTER
{
static void VerifyGlobalANSLMLicense(const std::string& licenseKey) {
try {
static const std::vector<std::pair<int, std::string>> licenseChecks = {
{1000, "ANNHUB-LV"},
{1001, "DLHUB-LV"},
{1002, "ODHUB-LV"},
{1003, "ANSVIS"},
{1004, "ANSFR"},
{1005, "ANSOCR"},
{1006, "ANSALPR"},
{1007, "ANSCV"},
{1008, "ANSTS"}
};
ansllmLicenceValid = false;
for (const auto& [productId, productName] : licenseChecks) {
if (ANSCENTER::ANSLicenseHelper::LicenseVerification(licenseKey, productId, productName)) {
ansllmLicenceValid = true;
break; // Stop at the first valid license
}
}
}
catch (const std::exception& e) {
ansllmLicenceValid = false;
}
}
ANSLLM::ANSLLM() {
_unlockCode = "ANSDRC.CB1122026_MEQCIFwO1IFQCG0BhZwsXFO68QUU6mDB5uge4duOsqOJanEyAiAB67ahqnXin4SRy0vIegISgbFlpldmbuS5gbU21GYVqA==";// "ANSDRC.CB1082025_Ax6P3M7F8B3d";//
}
ANSLLM::~ANSLLM() noexcept = default;
void ANSLLM::CheckLicense() {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
// Check once globally
std::call_once(ansllmLicenseOnceFlag, [this]() {
VerifyGlobalANSLMLicense(_licenseKey);
});
// Update this instance's local license flag
_isLicenseValid = ansllmLicenceValid;
}
catch (const std::exception& e) {
this->_logger.LogFatal("ANSLLM::CheckLicense. Error:", e.what(), __FILE__, __LINE__);
}
}
void ANSLLM::CheckUnlockCode() {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
CkGlobal glob;
_unlockCode = "ANSDRC.CB1122026_MEQCIFwO1IFQCG0BhZwsXFO68QUU6mDB5uge4duOsqOJanEyAiAB67ahqnXin4SRy0vIegISgbFlpldmbuS5gbU21GYVqA==";// "ANSDRC.CB1082025_Ax6P3M7F8B3d";
_isUnlockCodeValid = glob.UnlockBundle(_unlockCode.c_str());
if (!_isUnlockCodeValid) {
_logger.LogFatal("ANSLLM::CheckUnlockCode", glob.lastErrorText(), __FILE__, __LINE__);
return;
}
int status = glob.get_UnlockStatus();
if (status != 2) {
_logger.LogDebug("ANSLLM::CheckUnlockCode", "Unlocked in trial mode.", __FILE__, __LINE__);
}
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::CheckUnlockCode", e.what(), __FILE__, __LINE__);
}
}
bool ANSLLM::Initialize(const std::string& licenseKey, bool localLLM) {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
_licenseKey = licenseKey;
_localLLM = localLLM;
CheckLicense();
CheckUnlockCode();
if (_localLLM) {
// Auto-configure for local Ollama: use custom provider with ChatCompletions API spec
// Must use "custom" — setting "openai" resets BaseUrl to api.openai.com
ai.put_Provider("custom");
ai.put_ApiSpec("ChatCompletions");
ai.put_BaseUrl(_ollamaBaseUrl.c_str());
ai.put_ApiKey("ollama"); // Ollama doesn't require a real API key
_logger.LogDebug("ANSLLM::Initialize", "Configured for local Ollama at " + _ollamaBaseUrl, __FILE__, __LINE__);
}
return _isLicenseValid && _isUnlockCodeValid;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::Initialize", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::SetLLMProvider(const std::string& llmProvider) {
if (llmProvider.empty()) return false;
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
ai.put_Provider(llmProvider.c_str());
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::SetLLMProvider", e.what(), __FILE__, __LINE__);
return false;
}
}
std::string ANSLLM::GetLLMProvider() {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
CkString str;
ai.get_Provider(str);
const char* cstr = str.getString();
return (cstr != nullptr) ? std::string(cstr) : std::string();
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::GetLLMProvider", e.what(), __FILE__, __LINE__);
return "";
}
}
bool ANSLLM::SetApiKey(const std::string& apiKey) {
if (apiKey.empty()) return false;
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
ai.put_ApiKey(apiKey.c_str());
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::SetApiKey", e.what(), __FILE__, __LINE__);
return false;
}
}
std::vector<std::string> ANSLLM::GetModelList() {
std::lock_guard<std::recursive_mutex> lock(_mutex);
std::vector<std::string> modelList;
try {
CkStringTable st;
if (!ai.GetModels(st)) {
const char* errText = ai.lastErrorText();
const std::string errorMsg = (errText != nullptr) ? errText : "Unknown error";
_logger.LogError("ANSLLM::GetModelList",
"Failed to get models: " + errorMsg,
__FILE__, __LINE__);
return modelList;
}
const int count = st.get_Count();
if (count <= 0) {
return modelList;
}
modelList.reserve(static_cast<size_t>(count));
for (int i = 0; i < count; ++i) {
const char* modelName = st.stringAt(i);
if (modelName != nullptr && modelName[0] != '\0') {
modelList.emplace_back(modelName);
}
}
return modelList;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::GetModelList",
std::string("Exception: ") + e.what(),
__FILE__, __LINE__);
return modelList;
}
catch (...) {
_logger.LogFatal("ANSLLM::GetModelList",
"Unknown exception occurred",
__FILE__, __LINE__);
return modelList;
}
}
bool ANSLLM::SetModel(const std::string& modelName) {
if (modelName.empty()) return false;
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
ai.put_Model(modelName.c_str());
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::SetModel", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::SetTranscriptMode(bool transcriptMode) {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
ai.put_FullTranscript(transcriptMode);
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::SetTranscriptMode", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::InputAddText(const std::string& inputText) {
if (inputText.empty()) return false;
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
ai.InputAddText(inputText.c_str());
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::InputAddText", e.what(), __FILE__, __LINE__);
return false;
}
}
std::string ANSLLM::Ask(const std::string& prompt) {
if (prompt.empty()) return "";
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
// Ask the AI for text output.
bool success = ai.Ask(prompt.c_str());
if (success == false) {
const char* errText = ai.lastErrorText();
return (errText != nullptr) ? std::string(errText) : std::string("Unknown error");
}
// Get the text response.
CkStringBuilder sbResponse;
ai.GetOutputTextSb(sbResponse);
const char* cstr = sbResponse.getAsString();
return (cstr != nullptr) ? std::string(cstr) : std::string();
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::Ask", e.what(), __FILE__, __LINE__);
return "";
}
}
bool ANSLLM::CreateConversation(const std::string& systemMessage, const std::string& developerMessage, const std::string& conversationName) {
if (systemMessage.empty() || developerMessage.empty() || conversationName.empty()) {
return false;
}
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
return ai.NewConvo(conversationName.c_str(), systemMessage.c_str(), developerMessage.c_str());
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::CreateConversation", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::SetConversation(const std::string& conversationName) {
if (conversationName.empty()) return false;
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
ai.put_SelectedConvo(conversationName.c_str());
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::SetConversation", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::InputAddImageUrl(const std::string& imageURL, const std::string& summary) {
if (imageURL.empty()) return false;
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
return ai.InputAddImageUrl(imageURL.c_str(), summary.c_str());
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::InputAddImageUrl", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::InputAddImageFromPath(const std::string& filePath, const char* summary) {
if (filePath.empty()) return false;
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
CkBinData bd;
bool success = bd.LoadFile(filePath.c_str());
if (!success) {
const char* errText = bd.lastErrorText();
_logger.LogError("ANSLLM::InputAddImageFromPath",
(errText != nullptr) ? errText : "Failed to load file",
__FILE__, __LINE__);
return false;
}
return ai.InputAddImageData(bd, summary);
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::InputAddImageFromPath", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::InputAddImageFromBase64(const std::string& jpegBase64String, const char* summary) {
if (jpegBase64String.empty()) return false;
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
CkBinData bd;
// Load base64 encoded JPEG data into CkBinData
bool success = bd.AppendEncoded(jpegBase64String.c_str(), "base64");
if (!success) {
_logger.LogError("ANSLLM::InputAddImage",
bd.lastErrorText(),
__FILE__, __LINE__);
return false;
}
return ai.InputAddImageData(bd, summary);
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::InputAddImage", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::InputAddFileData(const std::string& filePath, const char* summary) {
if (filePath.empty()) return false;
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
CkBinData bd;
bool success = bd.LoadFile(filePath.c_str());
if (!success) {
const char* errText = bd.lastErrorText();
_logger.LogError("ANSLLM::InputAddFileData",
(errText != nullptr) ? errText : "Failed to load file",
__FILE__, __LINE__);
return false;
}
return ai.InputAddImageData(bd, summary);
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::InputAddFileData", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::InputAddFileURL(const std::string& fileURL, const char* summary) {
if (fileURL.empty()) return false;
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
return ai.InputAddFileUrl(fileURL.c_str(), summary);
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::InputAddFileURL", e.what(), __FILE__, __LINE__);
return false;
}
}
// Extra methods
bool ANSLLM::ClearInputs() {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
ai.InputClear();
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::ClearInputs", e.what(), __FILE__, __LINE__);
return false;
}
}
std::vector<std::string> ANSLLM::GetConversationList() {
std::lock_guard<std::recursive_mutex> lock(_mutex);
std::vector<std::string> convList;
try {
CkStringTable st;
if (!ai.ListConvos(st)) {
const char* errText = ai.lastErrorText();
const std::string errorMsg = (errText != nullptr) ? errText : "Unknown error";
_logger.LogError("ANSLLM::GetConversationList",
"Failed to get conversations: " + errorMsg,
__FILE__, __LINE__);
return convList;
}
const int count = st.get_Count();
if (count <= 0) {
return convList;
}
convList.reserve(static_cast<size_t>(count));
for (int i = 0; i < count; ++i) {
const char* convName = st.stringAt(i);
if (convName != nullptr && convName[0] != '\0') {
convList.emplace_back(convName);
}
}
return convList;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::GetConversationList", e.what(), __FILE__, __LINE__);
return {};
}
}
bool ANSLLM::DeleteConversation(const std::string& conversationName) {
if (conversationName.empty()) return false;
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
return ai.DeleteConvo(conversationName.c_str());
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::DeleteConversation", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::SetUTF8(bool b) {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
ai.put_Utf8(b);
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::SetUTF8", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::GetUTF8() {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
return ai.get_Utf8();
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::GetUTF8", e.what(), __FILE__, __LINE__);
return false;
}
}
int ANSLLM::PollAi(bool abort) {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
return ai.PollAi(abort);
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::PollAi", e.what(), __FILE__, __LINE__);
return -1;
}
}
bool ANSLLM::SetLocalLLM(bool localLLM) {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
_localLLM = localLLM;
if (_localLLM) {
ai.put_Provider("custom");
ai.put_ApiSpec("ChatCompletions");
ai.put_BaseUrl(_ollamaBaseUrl.c_str());
ai.put_ApiKey("ollama");
_logger.LogDebug("ANSLLM::SetLocalLLM", "Configured for local Ollama at " + _ollamaBaseUrl, __FILE__, __LINE__);
}
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::SetLocalLLM", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::SetOllamaBaseUrl(const std::string& baseUrl) {
if (baseUrl.empty()) return false;
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
_ollamaBaseUrl = baseUrl;
if (_localLLM) {
ai.put_BaseUrl(_ollamaBaseUrl.c_str());
}
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::SetOllamaBaseUrl", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::SetBaseURL(const std::string& baseURL) {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
ai.put_BaseUrl(baseURL.c_str());
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::SetBaseURL", e.what(), __FILE__, __LINE__);
return false;
}
}
int ANSLLM::GetHeartbeatMs() {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
return ai.get_HeartbeatMs();
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::GetHeartbeatMs", e.what(), __FILE__, __LINE__);
return -1;
}
}
bool ANSLLM::SetHeartbeatMs(int heartbeatMs) {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
ai.put_HeartbeatMs(heartbeatMs);
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::SetHeartbeatMs", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::GetHostedConversation() {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
return ai.get_HostedConvo();
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::GetHostedConversation", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::SetHostedConversation(bool hostedConversation) {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
ai.put_HostedConvo(hostedConversation);
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::SetHostedConversation", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::GetStreamingMode() {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
return ai.get_Streaming();
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::GetStreamingMode", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::SetStreamingMode(bool streamingMode) {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
ai.put_Streaming(streamingMode);
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::SetStreamingMode", e.what(), __FILE__, __LINE__);
return false;
}
}
int ANSLLM::GetIdleTimeoutMs() {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
return ai.get_IdleTimeoutMs();
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::GetIdleTimeoutMs", e.what(), __FILE__, __LINE__);
return -1;
}
}
bool ANSLLM::SetIdleTimeoutMs(int idleTimeoutMs) {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
ai.put_IdleTimeoutMs(idleTimeoutMs);
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::SetIdleTimeoutMs", e.what(), __FILE__, __LINE__);
return false;
}
}
std::string ANSLLM::GetLastErrorMessage() {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
const char* errorText = ai.lastErrorText();
return (errorText != nullptr) ? std::string(errorText) : std::string();
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::GetLastErrorMessage", e.what(), __FILE__, __LINE__);
return e.what();
}
}
std::string ANSLLM::GetOutputText() {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
CkString str;
ai.GetOutputText(str);
const char* cstr = str.getString();
return (cstr != nullptr) ? std::string(cstr) : std::string();
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::GetOutputText", e.what(), __FILE__, __LINE__);
return "";
}
}
std::string ANSLLM::GetOutputTextSb() {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
CkStringBuilder sb;
ai.GetOutputTextSb(sb);
const char* cstr = sb.getAsString();
return (cstr != nullptr) ? std::string(cstr) : std::string();
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::GetOutputTextSb", e.what(), __FILE__, __LINE__);
return "";
}
}
bool ANSLLM::SetSleepMs(int sleepMs) {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
ai.SleepMs(sleepMs);
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::SetSleepMs", e.what(), __FILE__, __LINE__);
return false;
}
}
bool ANSLLM::SetAskParams(double temperature) {
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
CkJsonObject obj;
std::string strTemp = std::to_string(temperature);
obj.UpdateString("temperature", strTemp.c_str());
ai.SetAskParams(obj);
return true;
}
catch (const std::exception& e) {
_logger.LogFatal("ANSLLM::SetAskParams", e.what(), __FILE__, __LINE__);
return false;
}
}
}