@smythos/sre 1.7.18 → 1.7.20

package/src/subsystems/LLMManager/LLM.inference.ts

@@ -13,14 +13,30 @@ import { TLLMChatResponse, TLLMMessageRole, TLLMModel, TLLMParams } from '@sre/t
 import { LLMConnector } from './LLM.service/LLMConnector';
 import { IModelsProviderRequest, ModelsProviderConnector } from './ModelsProvider.service/ModelsProviderConnector';
 
-const console = Logger('LLMInference');
+const logger = Logger('LLMInference');
 
 type TPromptParams = { query?: string; contextWindow?: any[]; files?: any[]; params: TLLMParams; onFallback?: (data: any) => void };
 
 export class LLMInference {
-    private model: string | TLLMModel;
-    private llmConnector: LLMConnector;
-    private modelProviderReq: IModelsProviderRequest;
+    private _model: string | TLLMModel;
+    public get model() {
+        return this._model;
+    }
+    public get modelId() {
+        return typeof this._model === 'string' ? this._model : this._model?.modelId;
+    }
+    private _llmConnector: LLMConnector;
+    public get llmConnector() {
+        return this._llmConnector;
+    }
+    private _modelProviderReq: IModelsProviderRequest;
+    public get modelProviderReq() {
+        return this._modelProviderReq;
+    }
+    private _llmProviderName: string;
+    public get llmProviderName() {
+        return this._llmProviderName;
+    }
     public teamId?: string;
 
     public static async getInstance(model: string | TLLMModel, candidate: AccessCandidate) {
@@ -34,18 +50,18 @@ export class LLMInference {
         const llmInference = new LLMInference();
         llmInference.teamId = teamId;
 
-        llmInference.modelProviderReq = modelsProvider.requester(candidate);
+        llmInference._modelProviderReq = modelsProvider.requester(candidate);
 
-        const llmProvider = await llmInference.modelProviderReq.getProvider(model);
-        if (llmProvider) {
-            llmInference.llmConnector = ConnectorService.getLLMConnector(llmProvider);
+        llmInference._llmProviderName = await llmInference._modelProviderReq.getProvider(model);
+        if (llmInference._llmProviderName) {
+            llmInference._llmConnector = ConnectorService.getLLMConnector(llmInference._llmProviderName);
         }
 
-        if (!llmInference.llmConnector) {
-            console.error(`Model ${model} unavailable for team ${teamId}`);
+        if (!llmInference._llmConnector) {
+            logger.warn(`Model ${model} unavailable for team ${teamId}`);
         }
 
-        llmInference.model = model;
+        llmInference._model = model;
 
         return llmInference;
     }
@@ -53,32 +69,32 @@ export class LLMInference {
     public static user(candidate: AccessCandidate): any {}
 
     public get connector(): LLMConnector {
-        return this.llmConnector;
+        return this._llmConnector;
     }
 
     public async prompt({ query, contextWindow, files, params, onFallback = () => {} }: TPromptParams, isInFallback: boolean = false) {
         let messages = contextWindow || [];
 
         if (query) {
-            const content = this.llmConnector.enhancePrompt(query, params);
+            const content = this._llmConnector.enhancePrompt(query, params);
             messages.push({ role: TLLMMessageRole.User, content });
         }
 
         // Reset the model, since the fallback model may change — especially when using user custom models.
-        params.model = this.model;
+        params.model = this._model;
 
         params.messages = messages;
         params.files = files;
 
         // If a fallback model is used, trigger the onFallback callback to notify the caller.
         if (isInFallback && typeof onFallback === 'function') {
-            onFallback({ model: this.model });
+            onFallback({ model: this._model });
         }
 
         try {
-            let response: TLLMChatResponse = await this.llmConnector.requester(AccessCandidate.agent(params.agentId)).request(params);
+            let response: TLLMChatResponse = await this._llmConnector.requester(AccessCandidate.agent(params.agentId)).request(params);
 
-            const result = this.llmConnector.postProcess(response?.content);
+            const result = this._llmConnector.postProcess(response?.content);
             if (result.error) {
                 // If the model stopped before completing the response, this is usually due to output token limit reached.
                 if (response.finishReason !== 'stop') {
@@ -102,12 +118,12 @@ export class LLMInference {
                     }
                 } catch (fallbackError) {
                     // If fallback also failed, log it but continue to throw original error
-                    console.warn('Fallback also failed:', fallbackError);
+                    logger.warn('Fallback also failed:', fallbackError);
                 }
             }
 
             // If fallback was not attempted or failed, throw the original error
-            console.error('Error in chatRequest: ', error);
+            logger.error('Error in chatRequest: ', error);
             throw error;
         }
     }
@@ -116,23 +132,23 @@ export class LLMInference {
         let messages = contextWindow || [];
 
         if (query) {
-            const content = this.llmConnector.enhancePrompt(query, params);
+            const content = this._llmConnector.enhancePrompt(query, params);
             messages.push({ role: TLLMMessageRole.User, content });
         }
 
         // Reset the model, since the fallback model may change — especially when using user custom models.
-        params.model = this.model;
+        params.model = this._model;
 
         params.messages = messages;
         params.files = files;
 
         // If a fallback model is used, trigger the onFallback callback to notify the caller.
         if (isInFallback && typeof onFallback === 'function') {
-            onFallback({ model: this.model });
+            onFallback({ model: this._model });
         }
 
         try {
-            return await this.llmConnector.user(AccessCandidate.agent(params.agentId)).streamRequest(params);
+            return await this._llmConnector.user(AccessCandidate.agent(params.agentId)).streamRequest(params);
         } catch (error) {
             // Attempt fallback for custom models (only if not already in fallback)
             if (!isInFallback) {
@@ -152,12 +168,12 @@ export class LLMInference {
                     }
                 } catch (fallbackError) {
                     // If fallback also failed, log it but continue to return error emitter
-                    console.warn('Fallback also failed:', fallbackError);
+                    logger.warn('Fallback also failed:', fallbackError);
                 }
             }
 
             // If fallback was not attempted or failed, return error emitter
-            console.error('Error in streamRequest:', error);
+            logger.error('Error in streamRequest:', error);
 
             const dummyEmitter = new EventEmitter();
             process.nextTick(() => {
@@ -224,22 +240,22 @@ export class LLMInference {
      * @returns The result from the fallback execution, or null if fallback should not be attempted
      */
     private async executeFallback(methodName: 'prompt' | 'promptStream', args: TPromptParams): Promise<any> {
-        const isCustomModel = await this.modelProviderReq.isUserCustomLLM(this.model);
-        const fallbackModel = await this.modelProviderReq.getFallbackLLM(this.model);
+        const isCustomModel = await this._modelProviderReq.isUserCustomLLM(this._model);
+        const fallbackModel = await this._modelProviderReq.getFallbackLLM(this._model);
 
         // Only execute fallback if it's a custom model with a configured fallback
         if (!isCustomModel || !fallbackModel) {
             return null;
         }
 
-        console.info(`Attempting fallback from ${this.model} to ${fallbackModel}`);
+        logger.info(`Attempting fallback from ${this._model} to ${fallbackModel}`);
 
         // Mutate the model and connector to use fallback
-        this.model = fallbackModel;
+        this._model = fallbackModel;
 
-        const llmProvider = await this.modelProviderReq.getProvider(fallbackModel);
+        const llmProvider = await this._modelProviderReq.getProvider(fallbackModel);
         if (llmProvider) {
-            this.llmConnector = ConnectorService.getLLMConnector(llmProvider);
+            this._llmConnector = ConnectorService.getLLMConnector(llmProvider);
         }
 
         // Call the appropriate method with isInFallback=true to prevent further fallbacks
@@ -252,13 +268,13 @@ export class LLMInference {
 
     public async imageGenRequest({ query, files, params }: TPromptParams) {
         params.prompt = query;
-        return this.llmConnector.user(AccessCandidate.agent(params.agentId)).imageGenRequest(params);
+        return this._llmConnector.user(AccessCandidate.agent(params.agentId)).imageGenRequest(params);
     }
 
     public async imageEditRequest({ query, files, params }: TPromptParams) {
         params.prompt = query;
         params.files = files;
-        return this.llmConnector.user(AccessCandidate.agent(params.agentId)).imageEditRequest(params);
+        return this._llmConnector.user(AccessCandidate.agent(params.agentId)).imageEditRequest(params);
     }
 
     //@deprecated
@@ -269,11 +285,11 @@ export class LLMInference {
                 throw new Error('Input messages are required.');
             }
 
-            const model = params.model || this.model;
+            const model = params.model || this._model;
 
-            return await this.llmConnector.user(AccessCandidate.agent(agentId)).streamRequest({ ...params, model });
+            return await this._llmConnector.user(AccessCandidate.agent(agentId)).streamRequest({ ...params, model });
         } catch (error) {
-            console.error('Error in streamRequest:', error);
+            logger.error('Error in streamRequest:', error);
 
             const dummyEmitter = new EventEmitter();
             process.nextTick(() => {
@@ -306,11 +322,11 @@ export class LLMInference {
             //FIXME we need to update the connector multimediaStreamRequest in order to ignore prompt param if not provided
             const userMessage = Array.isArray(params.messages) ? params.messages.pop() : {};
             const prompt = userMessage?.content || '';
-            const model = params.model || this.model;
+            const model = params.model || this._model;
 
-            return await this.llmConnector.user(AccessCandidate.agent(agentId)).multimodalStreamRequest(prompt, { ...params, model });
+            return await this._llmConnector.user(AccessCandidate.agent(agentId)).multimodalStreamRequest(prompt, { ...params, model });
         } catch (error: any) {
-            console.error('Error in multimodalRequest: ', error);
+            logger.error('Error in multimodalRequest: ', error);
 
             throw error;
         }
@@ -337,12 +353,12 @@ export class LLMInference {
         params.files = _files;
 
         try {
-            prompt = this.llmConnector.enhancePrompt(prompt, config);
-            const model = params.model || this.model;
+            prompt = this._llmConnector.enhancePrompt(prompt, config);
+            const model = params.model || this._model;
 
-            return await this.llmConnector.user(AccessCandidate.agent(agentId)).multimodalStreamRequest(prompt, { ...params, model });
+            return await this._llmConnector.user(AccessCandidate.agent(agentId)).multimodalStreamRequest(prompt, { ...params, model });
         } catch (error: any) {
-            console.error('Error in multimodalRequest: ', error);
+            logger.error('Error in multimodalRequest: ', error);
 
             throw error;
         }
@@ -376,7 +392,7 @@ export class LLMInference {
 
         //#region get max model context
 
-        const modelInfo = await this.modelProviderReq.getModelInfo(this.model, true);
+        const modelInfo = await this._modelProviderReq.getModelInfo(this._model, true);
         let maxModelContext = modelInfo?.tokens;
         let maxModelOutputTokens = modelInfo?.completionTokens || modelInfo?.tokens;
         // const isStandardLLM = LLMRegistry.isStandardLLM(this.model);
@@ -399,10 +415,10 @@ export class LLMInference {
         }
 
         if (maxInputContext <= 0) {
-            console.warn('Max input context is 0, returning empty context window, This usually indicates a wrong model configuration');
+            logger.warn('Max input context is 0, returning empty context window, This usually indicates a wrong model configuration');
         }
 
-        console.debug(
+        logger.debug(
             `Context Window Configuration: Max Input Tokens: ${maxInputContext}, Max Output Tokens: ${maxOutputContext}, Max Model Tokens: ${maxModelContext}`
         );
         const systemMessage = { role: 'system', content: systemPrompt };
@@ -473,7 +489,7 @@ function countTokens(content: any, model: 'gpt-4o' | 'gpt-4o-mini' = 'gpt-4o') {
         const tokens = encodeChat([{ role: 'user', content: _stringifiedContent } as ChatMessage], model);
         return tokens.length;
     } catch (error) {
-        console.warn('Error in countTokens: ', error);
+        logger.warn('Error in countTokens: ', error);
         return 0;
     }
 }

package/src/subsystems/LLMManager/LLM.service/connectors/GoogleAI.class.ts

@@ -139,6 +139,7 @@ export class GoogleAIConnector extends LLMConnector {
                             ? toolCall.functionCall?.args
                             : JSON.stringify(toolCall.functionCall?.args ?? {}),
                     role: TLLMMessageRole.Assistant,
+                    thoughtSignature: (toolCall as any).thoughtSignature, // Preserve Google AI's reasoning context
                 }));
                 useTool = true;
             }
@@ -202,6 +203,7 @@ export class GoogleAIConnector extends LLMConnector {
                                         ? toolCall.functionCall?.args
                                         : JSON.stringify(toolCall.functionCall?.args ?? {}),
                                 role: TLLMMessageRole.Assistant,
+                                thoughtSignature: (toolCall as any).thoughtSignature, // Preserve Google AI's reasoning context
                             }));
                             emitter.emit(TLLMEvent.ToolInfo, toolsData);
                         }
@@ -426,6 +428,13 @@ export class GoogleAIConnector extends LLMConnector {
         if (params.stopSequences?.length) config.stopSequences = params.stopSequences;
         if (responseMimeType) config.responseMimeType = responseMimeType;
 
+        // #region Gemini 3 specific fields
+        const isGemini3Model = params.modelEntryName?.includes('gemini-3');
+
+        if (isGemini3Model) {
+            if (params?.reasoningEffort) config.thinkingConfig = { thinkingLevel: params.reasoningEffort };
+        }
+
         if (systemInstruction) body.systemInstruction = systemInstruction;
         if (Object.keys(config).length > 0) {
             body.generationConfig = config;
@@ -505,36 +514,76 @@ export class GoogleAIConnector extends LLMConnector {
     ) {
         // SmythOS (built-in) models have a prefix, so we need to remove it to get the model name
         const modelName = metadata.modelEntryName.replace(BUILT_IN_MODEL_PREFIX, '');
-        let tier = '';
+
+        // Initially, all input tokens – such as text, audio, image, video, document, etc. – were included in promptTokenCount.
+        let inputTokens = usage?.promptTokenCount || 0;
+
+        // The pricing is the same for output and thinking tokens, so we can add them together.
+        const outputTokens = (usage?.candidatesTokenCount || 0) + (usage?.thoughtsTokenCount || 0);
+
+        // If cached input tokens are available, we need to subtract them from the input tokens.
+        let cachedInputTokens = usage?.cachedContentTokenCount || 0;
+
+        if (cachedInputTokens) {
+            inputTokens = inputTokens - cachedInputTokens;
+        }
+
+        // #region Find matching model and set tier based on threshold
         const tierThresholds = {
             'gemini-1.5-pro': 128_000,
             'gemini-2.5-pro': 200_000,
+            'gemini-3-pro': 200_000,
         };
 
-        const textInputTokens =
-            usage?.['promptTokensDetails']?.find((detail) => detail.modality === 'TEXT')?.tokenCount || usage?.promptTokenCount || 0;
-        const audioInputTokens = usage?.['promptTokensDetails']?.find((detail) => detail.modality === 'AUDIO')?.tokenCount || 0;
+        let inTier = '';
+        let outTier = '';
+        let crTier = '';
 
-        // Find matching model and set tier based on threshold
         const modelWithTier = Object.keys(tierThresholds).find((model) => modelName.includes(model));
         if (modelWithTier) {
-            tier = textInputTokens < tierThresholds[modelWithTier] ? 'tier1' : 'tier2';
+            inTier = inputTokens <= tierThresholds[modelWithTier] ? 'tier1' : 'tier2';
+            outTier = outputTokens <= tierThresholds[modelWithTier] ? 'tier1' : 'tier2';
+            crTier = cachedInputTokens <= tierThresholds[modelWithTier] ? 'tier1' : 'tier2';
         }
+        // #endregion
 
+        // #region Calculate audio input tokens
+        // Since Gemini 2.5 Flash has a different pricing model for audio input tokens, we need to report audio input tokens separately.
+        let audioInputTokens = 0;
+        let cachedAudioInputTokens = 0;
+        const isFlashModel = ['gemini-2.5-flash'].includes(modelName);
+
+        if (isFlashModel) {
+            // There is no concept of different pricing for Flash models based on token tiers (e.g., less than or greater than 200k),
+            // so we don't need to provide tier information for audio input tokens.
+            audioInputTokens = usage?.promptTokensDetails?.find((detail) => detail.modality === 'AUDIO')?.tokenCount || 0;
+
+            // subtract the audio cached input tokens from the audio input tokens and total cached input tokens.
+            cachedAudioInputTokens = usage?.cacheTokensDetails?.find((detail) => detail.modality === 'AUDIO')?.tokenCount || 0;
+            if (cachedAudioInputTokens) {
+                audioInputTokens = audioInputTokens - cachedAudioInputTokens;
+                cachedInputTokens = cachedInputTokens - cachedAudioInputTokens;
+            }
+
+            inputTokens = inputTokens - audioInputTokens;
+        }
         // #endregion
 
         const usageData = {
             sourceId: `llm:${modelName}`,
-            input_tokens: textInputTokens,
-            output_tokens: usage?.candidatesTokenCount || 0,
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
             input_tokens_audio: audioInputTokens,
-            input_tokens_cache_read: usage?.cachedContentTokenCount || 0,
+            input_tokens_cache_read: cachedInputTokens,
+            input_tokens_cache_read_audio: cachedAudioInputTokens,
             input_tokens_cache_write: 0,
-            reasoning_tokens: usage?.thoughtsTokenCount,
+            // reasoning_tokens: usage?.thoughtsTokenCount, // * reasoning tokens are included in the output tokens.
             keySource: metadata.keySource,
             agentId: metadata.agentId,
             teamId: metadata.teamId,
-            tier,
+            inTier,
+            outTier,
+            crTier,
         };
         SystemEvents.emit('USAGE:LLM', usageData);
 
@@ -665,12 +714,17 @@ export class GoogleAIConnector extends LLMConnector {
                     }
 
                     if (part.functionCall) {
-                        content.push({
+                        const functionCallPart: any = {
                             functionCall: {
                                 name: part.functionCall.name,
                                 args: parseFunctionArgs(part.functionCall.args),
                             },
-                        });
+                        };
+                        // Preserve thoughtSignature if present for Google AI reasoning context
+                        if ((part as any).thoughtSignature) {
+                            functionCallPart.thoughtSignature = (part as any).thoughtSignature;
+                        }
+                        content.push(functionCallPart);
                         continue;
                     }
 
@@ -699,12 +753,17 @@ export class GoogleAIConnector extends LLMConnector {
             const hasFunctionCall = content.some((part) => part.functionCall);
             if (!hasFunctionCall && toolsData.length > 0) {
                 toolsData.forEach((toolCall) => {
-                    content.push({
+                    const functionCallPart: any = {
                         functionCall: {
                             name: toolCall.name,
                             args: parseFunctionArgs(toolCall.arguments),
                         },
-                    });
+                    };
+                    // Preserve thoughtSignature if present for Google AI reasoning context
+                    if (toolCall.thoughtSignature) {
+                        functionCallPart.thoughtSignature = toolCall.thoughtSignature;
+                    }
+                    content.push(functionCallPart);
                 });
             }
 
@@ -811,6 +870,10 @@ export class GoogleAIConnector extends LLMConnector {
                             name: part.functionCall.name,
                             args: parseFunctionArgs(part.functionCall.args),
                         };
+                        // Preserve thoughtSignature if present for Google AI reasoning context
+                        if ((part as any).thoughtSignature) {
+                            normalizedPart.thoughtSignature = (part as any).thoughtSignature;
+                        }
                     }
 
                     if (part.functionResponse) {
@@ -839,12 +902,17 @@ export class GoogleAIConnector extends LLMConnector {
                             pushTextPart(normalizedParts, contentPart.text);
                         } else if ('functionCall' in contentPart && (contentPart as any).functionCall) {
                             const functionCallPart = (contentPart as any).functionCall;
-                            normalizedParts.push({
+                            const normalizedFunctionCall: any = {
                                 functionCall: {
                                     name: functionCallPart.name,
                                     args: parseFunctionArgs(functionCallPart.args),
                                 },
-                            });
+                            };
+                            // Preserve thoughtSignature if present for Google AI reasoning context
+                            if ((contentPart as any).thoughtSignature) {
+                                normalizedFunctionCall.thoughtSignature = (contentPart as any).thoughtSignature;
+                            }
+                            normalizedParts.push(normalizedFunctionCall);
                         } else if ('functionResponse' in contentPart && (contentPart as any).functionResponse) {
                             const functionResponsePart = (contentPart as any).functionResponse;
                             normalizedParts.push({
@@ -882,12 +950,17 @@ export class GoogleAIConnector extends LLMConnector {
                 for (const toolCall of message.tool_calls) {
                     if (!toolCall?.function?.name) continue;
 
-                    normalizedParts.push({
+                    const normalizedFunctionCall: any = {
                         functionCall: {
                             name: toolCall.function.name,
                             args: parseFunctionArgs(toolCall.function.arguments),
                         },
-                    });
+                    };
+                    // Preserve thoughtSignature if present for Google AI reasoning context
+                    if ((toolCall as any).thoughtSignature) {
+                        normalizedFunctionCall.thoughtSignature = (toolCall as any).thoughtSignature;
+                    }
+                    normalizedParts.push(normalizedFunctionCall);
                 }
             }
 

package/src/subsystems/LLMManager/ModelsProvider.service/connectors/JSONModelsProvider.class.ts

@@ -16,7 +16,7 @@ import fsSync from 'fs';
 import path from 'path';
 import { findSmythPath } from '@sre/helpers/Sysconfig.helper';
 
-const console = Logger('SmythModelsProvider');
+const logger = Logger('SmythModelsProvider');
 
 type SmythModelsProviderConfig = {
     /**
@@ -58,7 +58,7 @@ export class JSONModelsProvider extends ModelsProviderConnector {
                 this._settings.mode = 'merge'; //Force merge mode if using models from .smyth folder
                 this.initDirWatcher(modelsFolder); //this.started will be set to true when the watcher is ready
             } else {
-                console.warn('No models folder found ... falling back to built-in models only');
+                logger.warn('No models folder found ... falling back to built-in models only');
                 this.started = true;
             }
         }
@@ -71,7 +71,7 @@ export class JSONModelsProvider extends ModelsProviderConnector {
         const _modelsFolder = findSmythPath('models');
 
         if (fsSync.existsSync(_modelsFolder)) {
-            console.warn('Using default models folder  : ', _modelsFolder);
+            logger.warn('Using default models folder  : ', _modelsFolder);
             return _modelsFolder;
         }
 
@@ -106,7 +106,7 @@ export class JSONModelsProvider extends ModelsProviderConnector {
 
     private async reindexModels(dir: string) {
         try {
-            console.debug(`Reindexing models from directory: ${dir}`);
+            logger.debug(`Reindexing models from directory: ${dir}`);
 
             // Scan directory for models and get them as an object
             const scannedModels = await this.scanDirectoryForModels(dir);
@@ -121,9 +121,9 @@ export class JSONModelsProvider extends ModelsProviderConnector {
 
             JSONModelsProvider.localCache.clear();
 
-            console.debug(`Successfully reindexed models. Total models: ${Object.keys(this.models).length}`);
+            logger.debug(`Successfully reindexed models. Total models: ${Object.keys(this.models).length}`);
         } catch (error) {
-            console.error(`Error reindexing models from directory "${dir}":`, error);
+            logger.error(`Error reindexing models from directory "${dir}":`, error);
         }
     }
 
@@ -141,15 +141,21 @@ export class JSONModelsProvider extends ModelsProviderConnector {
                     const subDirModels = await this.scanDirectoryForModels(fullPath);
                     Object.assign(scannedModels, subDirModels);
                 } else if (entry.isFile() && entry.name.endsWith('.json')) {
-                    // Process JSON files and merge results
-                    const fileContent = await fs.readFile(fullPath, 'utf-8');
-                    const modelData = JSON.parse(fileContent);
-                    const validModels = await this.getValidModels(modelData);
-                    Object.assign(scannedModels, validModels);
+                    try {
+                        // Process JSON files and merge results
+
+                        const fileContent = await fs.readFile(fullPath, 'utf-8');
+                        const modelData = JSON.parse(fileContent);
+                        const validModels = await this.getValidModels(modelData);
+                        Object.assign(scannedModels, validModels);
+                    } catch (error) {
+                        console.error(`Error parsing model data from file "${fullPath}"`);
+                        logger.warn(`Error parsing model data from file "${fullPath}":`, error.message);
+                    }
                 }
             }
         } catch (error) {
-            console.warn(`Error scanning directory "${dir}":`, error);
+            logger.warn(`Error scanning directory "${dir}":`, error);
         }
 
         return scannedModels;
@@ -164,9 +170,9 @@ export class JSONModelsProvider extends ModelsProviderConnector {
                 // Single model case
                 if (this.isValidSingleModel(modelData)) {
                     validModels[modelData.modelId] = modelData as TLLMModel;
-                    console.debug(`Loaded model: ${modelData.modelId}`);
+                    logger.debug(`Loaded model: ${modelData.modelId}`);
                 } else {
-                    console.warn(`Invalid model format`, modelData);
+                    logger.warn(`Invalid model format`, modelData);
                 }
             } else if (typeof modelData === 'object' && !Array.isArray(modelData)) {
                 // Object of models case
@@ -178,19 +184,19 @@ export class JSONModelsProvider extends ModelsProviderConnector {
                             //console.debug(`Loaded model: ${modelId}`);
                             models += `${modelId} `;
                         } else {
-                            console.warn(`Invalid model format for model "${modelId}"`);
+                            logger.warn(`Invalid model format for model "${modelId}"`);
                         }
                     } catch (error) {
-                        console.warn(`Error processing model "${modelId}":`, error);
+                        logger.warn(`Error processing model "${modelId}":`, error);
                         // Continue processing other models instead of failing the whole file
                     }
                 }
-                console.debug(`Loaded models: ${models}`);
+                logger.debug(`Loaded models: ${models}`);
             } else {
-                console.warn(`Invalid format (not a model or object of models)`);
+                logger.warn(`Invalid format (not a model or object of models)`);
             }
         } catch (error) {
-            console.warn(`Error loading model:`, error);
+            logger.warn(`Error loading model:`, error);
         }
 
         return validModels;
@@ -212,7 +218,7 @@ export class JSONModelsProvider extends ModelsProviderConnector {
         const stats = fsSync.statSync(dir);
 
         if (!stats.isDirectory() && !stats.isFile()) {
-            console.warn(`Path "${dir}" is neither a file nor a directory ... skipping models watcher and falling back to built-in models only`);
+            logger.warn(`Path "${dir}" is neither a file nor a directory ... skipping models watcher and falling back to built-in models only`);
             this.started = true;
             return;
         }
@@ -230,17 +236,18 @@ export class JSONModelsProvider extends ModelsProviderConnector {
                         if (this._settings?.mode === 'merge') this.models = { ...this.models, ...modelData };
                         else this.models = modelData;
                     } catch (error) {
-                        console.error(`Error parsing model data from file "${dir}":`, error);
+                        console.error(`Error parsing model data from file "${dir}":`);
+                        logger.warn(`Error parsing model data from file "${dir}":`, error.message);
                     }
                     this.started = true;
                     return;
                 }
 
-                console.warn(`Path "${dir}" is neither a file nor a directory`);
+                logger.warn(`Path "${dir}" is neither a file nor a directory`);
                 return;
             }
         } catch (error) {
-            console.warn(`Path "${dir}" does not exist or cannot be accessed:`, error.message);
+            logger.warn(`Path "${dir}" does not exist or cannot be accessed:`, error.message);
             return;
         }
 
@@ -262,19 +269,19 @@ export class JSONModelsProvider extends ModelsProviderConnector {
 
         watcher
             .on('add', (path) => {
-                console.debug(`File ${path} has been added`);
+                logger.debug(`File ${path} has been added`);
                 debouncedReindex();
             })
             .on('change', (path) => {
-                console.debug(`File ${path} has been changed`);
+                logger.debug(`File ${path} has been changed`);
                 debouncedReindex();
             })
             .on('unlink', (path) => {
-                console.debug(`File ${path} has been removed`);
+                logger.debug(`File ${path} has been removed`);
                 debouncedReindex();
             })
             .on('ready', async () => {
-                console.debug(`Watcher ready. Performing initial scan of ${dir}`);
+                logger.debug(`Watcher ready. Performing initial scan of ${dir}`);
                 // Do initial scan once when watcher is ready
                 await this.reindexModels(dir);
                 this.started = true;