@smythos/sre 1.7.20 → 1.7.40

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

@@ -1,7 +1,7 @@
 import { JSONContent } from '@sre/helpers/JsonContent.helper';
 import { LLMConnector } from '../LLMConnector';
 import EventEmitter from 'events';
-import { APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMPreparedParams } from '@sre/types/LLM.types';
+import { APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMEvent, TLLMPreparedParams } from '@sre/types/LLM.types';
 import { Logger } from '@sre/helpers/Log.helper';
 import { delay } from '@sre/utils/index';
 import { hookAsync } from '@sre/Core/HookService';
@@ -54,13 +54,13 @@ export class EchoConnector extends LLMConnector {
                     const isLastChunk = i === chunks.length - 1;
                     // Add space between chunks except for the last one to avoid trailing space in file URLs
                     const delta = { content: chunks[i] + (isLastChunk ? '' : ' ') };
-                    emitter.emit('data', delta);
-                    emitter.emit('content', delta.content);
+                    emitter.emit(TLLMEvent.Data, delta);
+                    emitter.emit(TLLMEvent.Content, delta.content);
                 }
 
                 // Emit end event after all chunks are processed
                 setTimeout(() => {
-                    emitter.emit('end', [], []); // Empty arrays for toolsData and usage_data
+                    emitter.emit(TLLMEvent.End, [], [], 'stop'); // Empty arrays for toolsData and usage_data, with finishReason
                 }, 100);
             })();
 

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

@@ -186,9 +186,11 @@ export class GoogleAIConnector extends LLMConnector {
             (async () => {
                 try {
                     for await (const chunk of stream) {
+                        emitter.emit(TLLMEvent.Data, chunk);
+
                         const chunkText = chunk.text ?? '';
                         if (chunkText) {
-                            emitter.emit('content', chunkText);
+                            emitter.emit(TLLMEvent.Content, chunkText);
                         }
 
                         const toolCalls = chunk.candidates?.[0]?.content?.parts?.filter((part) => part.functionCall);
@@ -213,21 +215,28 @@ export class GoogleAIConnector extends LLMConnector {
                         }
                     }
 
+                    const finishReason = 'stop'; // GoogleAI doesn't provide finishReason in streaming
+                    const reportedUsage: any[] = [];
+
                     if (usage) {
-                        this.reportUsage(usage, {
+                        const reported = this.reportUsage(usage, {
                             modelEntryName: context.modelEntryName,
                             keySource: context.isUserKey ? APIKeySource.User : APIKeySource.Smyth,
                             agentId: context.agentId,
                             teamId: context.teamId,
                         });
+                        reportedUsage.push(reported);
                     }
 
+                    // Note: GoogleAI stream doesn't provide explicit finish reasons
+                    // If we had a non-stop finish reason, we would emit Interrupted here
+
                     setTimeout(() => {
-                        emitter.emit('end', toolsData);
+                        emitter.emit(TLLMEvent.End, toolsData, reportedUsage, finishReason);
                     }, 100);
                 } catch (error) {
                     logger.error(`streamRequest ${this.name}`, error, acRequest.candidate);
-                    emitter.emit('error', error);
+                    emitter.emit(TLLMEvent.Error, error);
                 }
             })();
 

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

@@ -108,6 +108,7 @@ export class GroqConnector extends LLMConnector {
             const stream = await groq.chat.completions.create({ ...body, stream: true, stream_options: { include_usage: true } });
 
             let toolsData: ToolData[] = [];
+            let finishReason = 'stop';
 
             (async () => {
                 for await (const chunk of stream as any) {
@@ -117,10 +118,10 @@ export class GroqConnector extends LLMConnector {
                     if (usage) {
                         usage_data.push(usage);
                     }
-                    emitter.emit('data', delta);
+                    emitter.emit(TLLMEvent.Data, delta);
 
                     if (delta?.content) {
-                        emitter.emit('content', delta.content);
+                        emitter.emit(TLLMEvent.Content, delta.content);
                     }
 
                     if (delta?.tool_calls) {
@@ -139,24 +140,35 @@ export class GroqConnector extends LLMConnector {
                             }
                         });
                     }
+
+                    // Capture finish reason
+                    if (chunk.choices[0]?.finish_reason) {
+                        finishReason = chunk.choices[0].finish_reason;
+                    }
                 }
 
                 if (toolsData.length > 0) {
                     emitter.emit(TLLMEvent.ToolInfo, toolsData);
                 }
 
+                const reportedUsage: any[] = [];
                 usage_data.forEach((usage) => {
-                    // probably we can acc them and send them as one event
-                    this.reportUsage(usage, {
+                    const reported = this.reportUsage(usage, {
                         modelEntryName: context.modelEntryName,
                         keySource: context.isUserKey ? APIKeySource.User : APIKeySource.Smyth,
                         agentId: context.agentId,
                         teamId: context.teamId,
                     });
+                    reportedUsage.push(reported);
                 });
 
+                // Emit interrupted event if finishReason is not 'stop'
+                if (finishReason !== 'stop') {
+                    emitter.emit(TLLMEvent.Interrupted, finishReason);
+                }
+
                 setTimeout(() => {
-                    emitter.emit('end', toolsData);
+                    emitter.emit(TLLMEvent.End, toolsData, reportedUsage, finishReason);
                 }, 100);
             })();
 

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

@@ -138,14 +138,17 @@ export class OllamaConnector extends LLMConnector {
 
             let toolsData: ToolData[] = [];
             let fullContent = '';
+            let finishReason = 'stop';
 
             (async () => {
                 for await (const chunk of stream) {
+                    emitter.emit(TLLMEvent.Data, chunk);
+
                     // Emit content deltas
                     if (chunk.message?.content) {
                         const content = chunk.message.content;
                         fullContent += content;
-                        emitter.emit('content', content);
+                        emitter.emit(TLLMEvent.Content, content);
                     }
 
                     // Handle tool calls accumulation
@@ -181,6 +184,11 @@ export class OllamaConnector extends LLMConnector {
                         };
                         usage_data.push(usage);
                     }
+
+                    // Capture finish reason from Ollama's done_reason
+                    if (chunk.done_reason) {
+                        finishReason = chunk.done_reason;
+                    }
                 }
 
                 // Emit tool info if tools were requested
@@ -189,18 +197,25 @@ export class OllamaConnector extends LLMConnector {
                 }
 
                 // Report usage
+                const reportedUsage: any[] = [];
                 usage_data.forEach((usage) => {
-                    this.reportUsage(usage, {
+                    const reported = this.reportUsage(usage, {
                         modelEntryName: context.modelEntryName,
                         keySource: context.isUserKey ? APIKeySource.User : APIKeySource.Smyth,
                         agentId: context.agentId,
                         teamId: context.teamId,
                     });
+                    reportedUsage.push(reported);
                 });
 
+                // Emit interrupted event if finishReason is not 'stop'
+                if (finishReason !== 'stop') {
+                    emitter.emit(TLLMEvent.Interrupted, finishReason);
+                }
+
                 // Final end event
                 setTimeout(() => {
-                    emitter.emit('end', toolsData);
+                    emitter.emit(TLLMEvent.End, toolsData, reportedUsage, finishReason);
                 }, 100);
             })();
 

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

@@ -14,6 +14,7 @@ import {
     TLLMChatResponse,
     ILLMRequestContext,
     TLLMPreparedParams,
+    TLLMEvent,
 } from '@sre/types/LLM.types';
 import { LLMHelper } from '@sre/LLMManager/LLM.helper';
 
@@ -97,6 +98,8 @@ export class PerplexityConnector extends LLMConnector {
         //fallback to chatRequest
         const emitter = new EventEmitter();
 
+        // TODO: need to implement proper streaming for Perplexity
+
         setTimeout(() => {
             try {
                 logger.debug(`streamRequest ${this.name}`, acRequest.candidate);
@@ -105,17 +108,23 @@ export class PerplexityConnector extends LLMConnector {
                         const finishReason = respose.finishReason;
                         const usage = respose.usage;
 
-                        emitter.emit('interrupted', finishReason);
-                        emitter.emit('content', respose.content);
-                        emitter.emit('end', undefined, usage, finishReason);
+                        emitter.emit(TLLMEvent.Data, respose);
+                        emitter.emit(TLLMEvent.Content, respose.content);
+
+                        // Only emit Interrupted if finishReason is not 'stop'
+                        if (finishReason !== 'stop') {
+                            emitter.emit(TLLMEvent.Interrupted, finishReason);
+                        }
+
+                        emitter.emit(TLLMEvent.End, [], [usage], finishReason);
                     })
                     .catch((error) => {
-                        emitter.emit('error', error.message || error.toString());
+                        emitter.emit(TLLMEvent.Error, error.message || error.toString());
                     });
                 //emitter.emit('finishReason', respose.finishReason);
             } catch (error) {
                 logger.error(`streamRequest ${this.name}`, error, acRequest.candidate);
-                emitter.emit('error', error.message || error.toString());
+                emitter.emit(TLLMEvent.Error, error.message || error.toString());
             }
         }, 100);
 

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

@@ -138,12 +138,14 @@ export class VertexAIConnector extends LLMConnector {
                 for await (const chunk of streamResult.stream) {
                     const chunkText = chunk.candidates?.[0]?.content?.parts?.[0]?.text || '';
                     if (chunkText) {
-                        emitter.emit('content', chunkText);
+                        emitter.emit(TLLMEvent.Content, chunkText);
                     }
                 }
 
                 const aggregatedResponse = await streamResult.response;
 
+                emitter.emit(TLLMEvent.Data, aggregatedResponse);
+
                 // Check for function calls in the final response (like Anthropic does)
                 const functionCalls = aggregatedResponse.candidates?.[0]?.content?.parts?.filter((part) => part.functionCall);
                 if (functionCalls && functionCalls.length > 0) {
@@ -176,15 +178,15 @@ export class VertexAIConnector extends LLMConnector {
                 const finishReason = (aggregatedResponse.candidates?.[0]?.finishReason || 'stop').toLowerCase();
 
                 if (finishReason !== 'stop') {
-                    emitter.emit('interrupted', finishReason);
+                    emitter.emit(TLLMEvent.Interrupted, finishReason);
                 }
 
                 setTimeout(() => {
-                    emitter.emit('end', toolsData, usageData, finishReason);
+                    emitter.emit(TLLMEvent.End, toolsData, usageData, finishReason);
                 }, 100);
             } catch (error) {
                 logger.error(`streamRequest ${this.name}`, error, acRequest.candidate);
-                emitter.emit('error', error);
+                emitter.emit(TLLMEvent.Error, error);
             }
         }, 100);
 

package/src/subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/ChatCompletionsApiInterface.ts

@@ -73,7 +73,7 @@ export class ChatCompletionsApiInterface extends OpenAIApiInterface {
                 // Step 3: Emit final events
                 this.emitFinalEvents(emitter, finalToolsData, reportedUsage, finishReason);
             } catch (error) {
-                emitter.emit('error', error);
+                emitter.emit(TLLMEvent.Error, error);
             }
         })();
 
@@ -267,11 +267,11 @@ export class ChatCompletionsApiInterface extends OpenAIApiInterface {
             }
 
             // Emit data event for delta
-            emitter.emit('data', delta);
+            emitter.emit(TLLMEvent.Data, delta);
 
             // Handle content deltas
             if (!delta?.tool_calls && delta?.content) {
-                emitter.emit('content', delta?.content, delta?.role);
+                emitter.emit(TLLMEvent.Content, delta?.content, delta?.role);
             }
 
             // Handle tool calls
@@ -350,12 +350,12 @@ export class ChatCompletionsApiInterface extends OpenAIApiInterface {
 
         // Emit interrupted event if finishReason is not 'stop'
         if (finishReason !== 'stop') {
-            emitter.emit('interrupted', finishReason);
+            emitter.emit(TLLMEvent.Interrupted, finishReason);
         }
 
         // Emit end event with setImmediate to ensure proper event ordering
         setImmediate(() => {
-            emitter.emit('end', toolsData, reportedUsage, finishReason);
+            emitter.emit(TLLMEvent.End, toolsData, reportedUsage, finishReason);
         });
     }
 

package/src/subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/ResponsesApiInterface.ts

@@ -119,7 +119,7 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
                 // Step 3: Emit final events
                 this.emitFinalEvents(emitter, finalToolsData, reportedUsage, finishReason);
             } catch (error) {
-                emitter.emit('error', error);
+                emitter.emit(TLLMEvent.Error, error);
             }
         })();
 
@@ -362,8 +362,10 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
                     role: 'assistant',
                     content: part.delta,
                 };
-                emitter.emit('data', deltaMsg);
-                emitter.emit('content', part.delta, 'assistant');
+
+                // TODO: we have inconsistency for data event with chat completions API, we need to check and fix it
+                emitter.emit(TLLMEvent.Data, deltaMsg);
+                emitter.emit(TLLMEvent.Content, part.delta, 'assistant');
             }
         } catch (error) {
             console.warn('Error handling output text delta:', error);
@@ -412,6 +414,7 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
                     }
 
                     if (addingNew) {
+                        // TODO: Check whether this event is being used.
                         emitter.emit('tool_call_started', {
                             id: callId,
                             name: functionName || '',
@@ -458,6 +461,7 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
                 }
 
                 const entry = existingIndex === -1 ? updated[finalIndex] : updated[finalIndex];
+                // TODO: Check whether this event is being used.
                 emitter.emit('tool_call_progress', {
                     id: entry.callId || itemId,
                     name: entry.name,
@@ -489,6 +493,7 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
                     const updated = toolsData.map((t, idx) => (idx === toolIndex ? { ...t, arguments: finalArguments } : t));
 
                     const updatedEntry = updated[toolIndex];
+                    // TODO: Check whether this event is being used.
                     emitter.emit('tool_call_completed', {
                         id: updatedEntry.callId || itemId,
                         name: updatedEntry.name,

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

@@ -14,6 +14,7 @@ import {
     ILLMRequestFuncParams,
     TLLMChatResponse,
     ILLMRequestContext,
+    TLLMEvent,
 } from '@sre/types/LLM.types';
 import { LLMHelper } from '@sre/LLMManager/LLM.helper';
 
@@ -202,10 +203,10 @@ export class xAIConnector extends LLMConnector {
                             }
 
                             if (delta) {
-                                emitter.emit('data', delta);
+                                emitter.emit(TLLMEvent.Data, delta);
 
                                 if (delta.content) {
-                                    emitter.emit('content', delta.content, delta.role);
+                                    emitter.emit(TLLMEvent.Content, delta.content, delta.role);
                                 }
 
                                 if (delta.tool_calls) {
@@ -238,11 +239,11 @@ export class xAIConnector extends LLMConnector {
                 if (citations && citations.length > 0) {
                     const citationsText = '\n\n**Sources:**\n' + citations.map((url, index) => `${index + 1}. ${url}`).join('\n');
 
-                    emitter.emit('content', citationsText, 'assistant');
+                    emitter.emit(TLLMEvent.Content, citationsText, 'assistant');
                 }
 
                 if (toolsData.length > 0) {
-                    emitter.emit('toolInfo', toolsData);
+                    emitter.emit(TLLMEvent.ToolInfo, toolsData);
                 }
 
                 // Report usage if available
@@ -257,20 +258,20 @@ export class xAIConnector extends LLMConnector {
                 }
 
                 if (finishReason !== 'stop') {
-                    emitter.emit('interrupted', finishReason);
+                    emitter.emit(TLLMEvent.Interrupted, finishReason);
                 }
 
                 setTimeout(() => {
-                    emitter.emit('end', toolsData, reportedUsage, finishReason);
+                    emitter.emit(TLLMEvent.End, toolsData, reportedUsage, finishReason);
                 }, 100);
             });
 
             response.data.on('error', (error) => {
-                emitter.emit('error', error);
+                emitter.emit(TLLMEvent.Error, error);
             });
         } catch (error) {
             logger.error(`streamRequest ${this.name}`, error, acRequest.candidate);
-            emitter.emit('error', error);
+            emitter.emit(TLLMEvent.Error, error);
         }
 
         return emitter;

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

@@ -214,6 +214,93 @@ export class JSONModelsProvider extends ModelsProviderConnector {
         return this.isValidSingleModel(data);
     }
 
+    /**
+     * Determines whether a file path should be ignored by the directory watcher.
+     *
+     * This method implements a sophisticated filtering strategy for dot-segment paths
+     * (paths containing directories that start with a dot, like .git, .env, .cache).
+     *
+     * **Filtering Strategy:**
+     * 1. Paths WITHOUT dot segments: Never ignored
+     * 2. Paths WITH dot segments:
+     *    - If SMYTH_PATH is not configured: All ignored
+     *    - If SMYTH_PATH is configured:
+     *      - Allow the watched directory even if SMYTH_PATH contains dot-segments
+     *        (e.g., /home/user/.smyth/models/OpenAI/default.json is allowed)
+     *      - Ignore dot-segments INSIDE the models directory
+     *        (e.g., /home/user/.smyth/models/.hidden/model.json is ignored)
+     *      - Paths outside watched directory: Ignored
+     *
+     * @param filePath - The file path to check
+     * @param watchedDir - The absolute path of the directory being watched (models folder)
+     * @param smythPath - The resolved SMYTH_PATH, or null if not configured
+     * @returns true if the path should be ignored, false if it should be watched
+     *
+     * @example
+     * ```typescript
+     * // Path without dot-segment (allowed)
+     * shouldIgnorePath('/models/OpenAI/default.json', '/models', '/home/.smyth') // => false
+     *
+     * // Dot-segment inside models directory (ignored)
+     * shouldIgnorePath('/models/.git/config', '/models', '/home/.smyth') // => true
+     *
+     * // Dot-segment in parent path only (allowed)
+     * shouldIgnorePath('/home/.smyth/models/OpenAI/default.json', '/home/.smyth/models', '/home/.smyth') // => false
+     * ```
+     */
+    private shouldIgnorePath(filePath: string, watchedDir: string, smythPath: string | null): boolean {
+        // Check if the file path contains a dot-segment (e.g., /.git/, /.env/, /.cache/)
+        // Regex explanation: [\\/]\. matches a path separator (/ or \) followed by a dot
+        const hasDotSegment = /[\\/]\./.test(filePath);
+
+        // CASE 1: If there is NO dot-segment at all, we never ignore this path
+        // Examples: /models/OpenAI/default.json, /models/Anthropic/claude.json
+        if (!hasDotSegment) {
+            return false;
+        }
+
+        // CASE 2: If there IS a dot-segment and SMYTH_PATH is not configured,
+        // we ignore all such paths to prevent watching system/hidden files
+        // Examples: /.git/config, /node_modules/.cache/file.json
+        if (hasDotSegment && !smythPath) {
+            return true;
+        }
+
+        // Resolve the file path to an absolute path for accurate comparison
+        // This ensures we can reliably compare against the watched directory path
+        const resolvedPath = path.resolve(filePath);
+
+        // Check if the resolved path is inside the watched directory (models folder)
+        // This handles two cases:
+        // 1. The path exactly matches the watched directory
+        // 2. The path is a child of the watched directory (starts with watchedDir + separator)
+        const isInsideWatchedDir = resolvedPath === watchedDir || resolvedPath.startsWith(watchedDir + path.sep);
+
+        // CASE 3: If the path is outside the watched directory, ignore it
+        // This prevents watching unrelated files that happen to have dot-segments
+        if (!isInsideWatchedDir) {
+            return true;
+        }
+
+        // CASE 4: Path is inside the watched directory
+        // Now we need to determine if the dot-segment is in the models directory itself
+        // or if it is part of the parent path (e.g., SMYTH_PATH containing .smyth)
+
+        // Get the relative path from the watched directory to determine where the dot-segment is
+        const relativePath = path.relative(watchedDir, resolvedPath);
+
+        // Check if the dot-segment appears in the relative portion (inside models directory)
+        // Regex explanation: (^|[\\/])\. matches a dot at the start OR after a path separator
+        // Examples that match: '.git/config', 'subdir/.hidden/file.json'
+        const hasDotSegmentInsideWatchedDir = /(^|[\\/])\./.test(relativePath);
+
+        // FINAL DECISION:
+        // - If dot-segment is INSIDE the models directory (e.g., models/.git/config), IGNORE it (return true)
+        // - If dot-segment is OUTSIDE the models directory (e.g., /home/user/.smyth/models/OpenAI/default.json), ALLOW it (return false)
+        // This allows SMYTH_PATH to contain dot-segments while preventing dot-segments within the models folder
+        return hasDotSegmentInsideWatchedDir;
+    }
+
     private initDirWatcher(dir) {
         const stats = fsSync.statSync(dir);
 
@@ -257,8 +344,12 @@ export class JSONModelsProvider extends ModelsProviderConnector {
             maxWait: 5000,
         });
 
+        const smythPath = process.env.SMYTH_PATH ? path.resolve(process.env.SMYTH_PATH) : null;
+        const watchedDir = path.resolve(dir);
+
         const watcher = chokidar.watch(dir, {
-            ignored: /(^|[\/\\])\../, // ignore dotfiles
+            // Use the extracted method for path filtering
+            ignored: (filePath: string) => this.shouldIgnorePath(filePath, watchedDir, smythPath),
             persistent: true,
             ignoreInitial: true, // Don't fire events for files that already exist
             awaitWriteFinish: {