@smythos/sre 1.7.40 → 1.7.41

package/src/helpers/Conversation.helper.ts

@@ -4,7 +4,7 @@ import { Logger } from '@sre/helpers/Log.helper';
 import { LLMInference } from '@sre/LLMManager/LLM.inference';
 import { LLMContext } from '@sre/MemoryManager/LLMContext';
 import { TAgentProcessParams } from '@sre/types/Agent.types';
-import { ILLMContextStore, TLLMEvent, TLLMModel, ToolData } from '@sre/types/LLM.types';
+import { IConversationSettings, ILLMContextStore, TLLMEvent, TLLMModel, ToolData } from '@sre/types/LLM.types';
 import { isUrl } from '@sre/utils/data.utils';
 import { processWithConcurrencyLimit, uid } from '@sre/utils/general.utils';
 import axios, { AxiosRequestConfig } from 'axios';
@@ -76,10 +76,24 @@ export class Conversation extends EventEmitter {
         return this._id;
     }
 
+    // Tool call limit tracking
+    private _toolCallCount: number = 0;
+    private _maxToolCallsPerSession: number = Infinity; // Default limit
+    private _disableToolsForNextCall: boolean = false;
+
     public get context() {
         return this._context;
     }
 
+    public get storeId() {
+        return this._llmContextStore?.id;
+    }
+
+    /**
+     * Headers to be added to all tool call requests
+     */
+    public headers: Record<string, string> = {};
+
     private _lastError;
     private _spec;
     private _customToolsDeclarations: FunctionDeclaration[] = [];
@@ -122,22 +136,7 @@ export class Conversation extends EventEmitter {
         return this._llmInference;
     }
 
-    constructor(
-        private _model: string | TLLMModel,
-        private _specSource?: string | Record<string, any>,
-        private _settings?: {
-            maxContextSize?: number;
-            maxOutputTokens?: number;
-            systemPrompt?: string;
-            toolChoice?: string;
-            store?: ILLMContextStore;
-            experimentalCache?: boolean;
-            toolsStrategy?: (toolsConfig) => any;
-            agentId?: string;
-            agentVersion?: string;
-            baseUrl?: string;
-        }
-    ) {
+    constructor(private _model: string | TLLMModel, private _specSource?: string | Record<string, any>, private _settings?: IConversationSettings) {
         //TODO: handle loading previous session (messages)
         super();
 
@@ -166,6 +165,10 @@ export class Conversation extends EventEmitter {
             this._llmContextStore = _settings.store;
         }
 
+        if (_settings?.maxToolCalls !== undefined) {
+            this._maxToolCallsPerSession = _settings.maxToolCalls;
+        }
+
         this._baseUrl = _settings?.baseUrl;
 
         this._agentVersion = _settings?.agentVersion;
@@ -305,6 +308,9 @@ export class Conversation extends EventEmitter {
         const baseUrl = this._baseUrl;
         const message_id = 'msg_' + randomUUID();
         const isDebugSession = toolHeaders['X-DEBUG'];
+        for (let [key, value] of Object.entries(this.headers)) {
+            toolHeaders[key] = value;
+        }
 
         /* ==================== STEP ENTRY ==================== */
         // console.debug('Request to LLM with the given model, messages and functions properties.', {
@@ -333,13 +339,17 @@ export class Conversation extends EventEmitter {
             requestId: llmReqUid,
         });
 
+        // Disable tools if we've reached the limit (for final synthesis call)
+        const effectiveToolsConfig = this._disableToolsForNextCall ? null : toolsConfig;
+        this._disableToolsForNextCall = false; // Reset flag after using it
+
         const eventEmitter: any = await this.llmInference
             .promptStream({
                 contextWindow,
                 files,
                 params: {
                     model: this.model,
-                    toolsConfig: this._settings?.toolsStrategy ? this._settings.toolsStrategy(toolsConfig) : toolsConfig,
+                    toolsConfig: this._settings?.toolsStrategy ? this._settings.toolsStrategy(effectiveToolsConfig) : effectiveToolsConfig,
                     maxTokens,
                     cache: this._settings?.experimentalCache,
                     agentId: this._agentId,
@@ -431,13 +441,44 @@ export class Conversation extends EventEmitter {
                     llmMessage.thinkingBlocks = thinkingBlocks;
                 }
 
+                // Check if we're at or over the tool call limit BEFORE processing this batch
+                const remainingToolCalls = this._maxToolCallsPerSession - this._toolCallCount;
+
+                if (remainingToolCalls <= 0) {
+                    // Already at limit, don't execute any tools from this batch - all will be pending
+                    const pendingToolNames = toolsData.map((t: ToolData) => t.name).join(', ');
+                    const systemInstruction = `You have reached the maximum number of tool calls (${this._maxToolCallsPerSession}). The following tools were requested but marked as "pending": ${pendingToolNames}. Please provide a helpful response based on the information you've gathered so far. You may acknowledge these pending tools and suggest the user can continue in a follow-up request.`;
+                    this._context.addUserMessage(systemInstruction, message_id, { internal: true });
+                    this.emit(TLLMEvent.Interrupted, 'max_tool_calls', { requestId: llmReqUid });
+                    this._disableToolsForNextCall = true;
+
+                    // Continue to get final synthesis without executing tools
+                    this.streamPrompt(null, toolHeaders, concurrentToolCalls, abortSignal).then(resolve).catch(reject);
+                    return;
+                }
+
+                // If this batch would exceed the limit, truncate to only execute remaining quota
+                let actualToolsData = toolsData;
+                let skippedToolsData: ToolData[] = [];
+
+                if (toolsData.length > remainingToolCalls) {
+                    actualToolsData = toolsData.slice(0, remainingToolCalls);
+                    skippedToolsData = toolsData.slice(remainingToolCalls);
+
+                    const skippedToolNames = skippedToolsData.map((t) => t.name).join(', ');
+                    console.warn(
+                        `Tool call limit will be reached. Executing only ${remainingToolCalls} of ${toolsData.length} requested tools. ` +
+                            `Skipped tools: ${skippedToolNames}`
+                    );
+                }
+
                 //add tool status for every tool entry
-                toolsData.forEach((tool) => {
+                actualToolsData.forEach((tool) => {
                     tool.status = tool.name ? this._toolStatusMap?.[tool.name] : undefined;
                 });
-                toolsData.content = _content;
-                toolsData.requestId = llmReqUid;
-                toolsData.contextWindow = contextWindow;
+                actualToolsData.content = _content;
+                actualToolsData.requestId = llmReqUid;
+                actualToolsData.contextWindow = contextWindow;
 
                 llmMessage.tool_calls = toolsData.map((tool) => {
                     return {
@@ -452,7 +493,8 @@ export class Conversation extends EventEmitter {
 
                 //if (llmMessage.tool_calls?.length <= 0) return;
 
-                this.emit(TLLMEvent.ToolInfo, toolsData);
+                // Emit ToolInfo with only the tools we'll actually execute
+                this.emit(TLLMEvent.ToolInfo, actualToolsData);
 
                 //initialize the agent callback logic
                 const _agentCallback = (data) => {
@@ -487,7 +529,8 @@ export class Conversation extends EventEmitter {
                     //eventEmitter.emit('content', data);
                 };
 
-                const toolProcessingTasks = toolsData.map(
+                // Only process tools up to the limit
+                const toolProcessingTasks = actualToolsData.map(
                     (tool: { index: number; name: string; type: string; arguments: Record<string, any> }) => async () => {
                         const endpoint = endpoints?.get(tool?.name) || tool?.name;
                         // Sometimes we have object response from the LLM such as Anthropic
@@ -532,22 +575,47 @@ export class Conversation extends EventEmitter {
                         this.emit('afterToolCall', { tool, args }, functionResponse); // Deprecated
                         this.emit(TLLMEvent.ToolResult, { tool, result, requestId: llmReqUid });
 
+                        // Increment tool call counter
+                        this._toolCallCount++;
+
                         return { ...tool, result: functionResponse };
                     }
                 );
 
                 const processedToolsData = await processWithConcurrencyLimit<ToolData>(toolProcessingTasks, concurrentToolCalls);
 
+                // Add skipped tools with pending status (not errors - they can be executed in next request)
+                const skippedToolsWithPendingStatus = skippedToolsData.map((tool) => ({
+                    ...tool,
+                    result: JSON.stringify({
+                        status: 'pending',
+                        message: `Tool execution deferred - maximum tool call limit (${this._maxToolCallsPerSession}) reached for this request. This tool can be executed in a follow-up request.`,
+                        pending: true,
+                    }),
+                }));
+
+                // Combine executed tools and pending tools for context
+                const allToolsData = [...processedToolsData, ...skippedToolsWithPendingStatus];
+
+                // Emit pending status for skipped tools (not errors - these are valid requests)
+                skippedToolsWithPendingStatus.forEach((tool) => {
+                    this.emit(TLLMEvent.ToolResult, {
+                        tool,
+                        result: { status: 'pending', message: 'Tool execution deferred - limit reached', pending: true },
+                        requestId: llmReqUid,
+                    });
+                });
+
                 //if (!passThroughContent) {
 
                 if (!passThroughContent) {
-                    this._context.addToolMessage(llmMessage, processedToolsData, message_id);
+                    this._context.addToolMessage(llmMessage, allToolsData, message_id);
                     //delete toolHeaders['x-passthrough'];
                 } else {
                     //this._context.addAssistantMessage(passThroughContent, message_id);
 
                     //llmMessage.content += '\n' + passThroughContent;
-                    this._context.addToolMessage(llmMessage, processedToolsData, message_id, { passThrough: true });
+                    this._context.addToolMessage(llmMessage, allToolsData, message_id, { passThrough: true });
 
                     //this._context.addAssistantMessage(passThroughContent, message_id, { passthrough: true });
                     //this should not be stored in the persistent conversation store
@@ -556,6 +624,24 @@ export class Conversation extends EventEmitter {
                     //toolHeaders['x-passthrough'] = 'true';
                 }
 
+                // Check if tool call limit has been reached AFTER processing this batch
+                const limitReached = this._toolCallCount >= this._maxToolCallsPerSession;
+                const hasPendingTools = skippedToolsWithPendingStatus.length > 0;
+
+                if (limitReached) {
+                    // Disable tools for the next (final) call to prevent infinite loops
+                    this._disableToolsForNextCall = true;
+
+                    if (hasPendingTools) {
+                        // Only add system instruction if there are pending tools
+                        // If no pending tools, LLM completed naturally - don't confuse it with limit messages
+                        const systemInstruction = `You have reached the maximum number of tool calls (${this._maxToolCallsPerSession}) for this request. Some tools are marked as "pending" and were not executed. Please provide a helpful response based on the information you've gathered so far. You may acknowledge these pending tools and suggest the user can continue in a follow-up request.`;
+
+                        this._context.addUserMessage(systemInstruction, message_id, { internal: true });
+                        this.emit(TLLMEvent.Interrupted, 'max_tool_calls', { requestId: llmReqUid });
+                    }
+                }
+
                 this.streamPrompt(null, toolHeaders, concurrentToolCalls, abortSignal).then(resolve).catch(reject);
 
                 //} else {

package/src/helpers/TemplateString.helper.ts

@@ -103,7 +103,7 @@ export class TemplateStringHelper {
      * unmatched placeholders will be left as is
      * Recursively resolves nested template variables until no more variables are found
      */
-    public parse(data: Record<string, string>, regex: TemplateStringMatch = Match.default, maxDepth: number = 5) {
+    public parse(data: Record<string, unknown>, regex: TemplateStringMatch = Match.default, maxDepth: number = 5) {
         if (typeof this._current !== 'string' || typeof data !== 'object') return this;
 
         // Keep parsing until no more template variables are resolved or max depth is reached
@@ -114,12 +114,13 @@ export class TemplateStringHelper {
             this._current = this._current.replace(regex, (match, token) => {
                 let val = data?.[token] ?? match; // Use nullish coalescing to preserve falsy values (0, '', false)
 
-                //if no exact match, try to parse the token as a JSON expression
-                if (!data?.[token]) {
-                    val = JSONExpression(data, token) || `{{${token}}}`; //if no match, use the token as is
+                // if no exact match, try to parse the token as a JSON expression
+                // * Nullish check: using `==` intentionally to match both null and undefined
+                if (data?.[token] == null) {
+                    val = JSONExpression(data, token) ?? `{{${token}}}`; //if no match, use the token as is
                 }
 
-                return typeof val === 'object' ? JSON.stringify(val) : escapeJsonField(val);
+                return typeof val === 'object' ? JSON.stringify(val) : escapeJsonField(val as string);
             });
 
             // Break early if no changes were made : we parsed all the template variables

package/src/index.ts

@@ -93,6 +93,7 @@ export * from './Components/APICall/parseUrl';
 export * from './Components/Image/imageSettings.config';
 export * from './Components/RAG/DataSourceCleaner.class';
 export * from './Components/RAG/DataSourceComponent.class';
+export * from './Components/RAG/DataSourceIndexer.class';
 export * from './Components/RAG/DataSourceLookup.class';
 export * from './Components/Triggers/Gmail.trigger';
 export * from './Components/Triggers/JobScheduler.trigger';

package/src/index.ts.bak

@@ -93,6 +93,7 @@ export * from './Components/APICall/parseUrl';
 export * from './Components/Image/imageSettings.config';
 export * from './Components/RAG/DataSourceCleaner.class';
 export * from './Components/RAG/DataSourceComponent.class';
+export * from './Components/RAG/DataSourceIndexer.class';
 export * from './Components/RAG/DataSourceLookup.class';
 export * from './Components/Triggers/Gmail.trigger';
 export * from './Components/Triggers/JobScheduler.trigger';

package/src/subsystems/IO/VectorDB.service/VectorDBConnector.ts

@@ -35,6 +35,7 @@ export interface IVectorDBRequest {
 
 export abstract class VectorDBConnector extends SecureConnector<IVectorDBRequest> {
     protected readonly USER_METADATA_KEY = 'user_metadata';
+    protected readonly LEGACY_USER_METADATA_KEY = 'metadata';
 
     public abstract id: string;
     public abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;

package/src/subsystems/IO/VectorDB.service/connectors/PineconeVectorDB.class.ts

@@ -201,10 +201,21 @@ export class PineconeVectorDB extends VectorDBConnector {
         for (const match of results.matches) {
             if (match.metadata?.isSkeletonVector) continue;
 
+            // priortize user metadata over the default flat metadata
             if (match.metadata?.[this.USER_METADATA_KEY]) {
                 match.metadata[this.USER_METADATA_KEY] = JSONContentHelper.create(match.metadata[this.USER_METADATA_KEY].toString()).tryParse();
             }
 
+            // if legacy metadata is present, we add it to the fallback metadata obj
+            if (match.metadata?.[this.LEGACY_USER_METADATA_KEY]) {
+                const parsedMetadata = JSONContentHelper.create(match.metadata[this.LEGACY_USER_METADATA_KEY].toString()).tryParse();
+                match.metadata = {
+                    ...match.metadata,
+                    ...parsedMetadata,
+                };
+                delete match.metadata?.[this.LEGACY_USER_METADATA_KEY];
+            }
+
             const text = match.metadata?.text as string | undefined;
             delete match.metadata?.text; // delete the text metadata to avoid duplication in case we returned the default raw metadata
 

package/src/subsystems/IO/VectorDB.service/embed/index.ts

@@ -40,16 +40,14 @@ export class EmbeddingsFactory {
     }
 
     public static getModels() {
-        return Object.keys(supportedProviders)
-            .reduce((acc, provider) => {
-                acc.push(
-                    ...supportedProviders[provider].models.map((model) => ({
-                        provider,
-                        model,
-                    }))
-                );
-                return acc;
-            }, [] as { provider: SupportedProviders; model: SupportedModels[SupportedProviders] }[])
-            .filter((item) => item.model !== 'text-embedding-ada-002'); //! SPECIAL case for ada-002, it doesn't support dimensions passing
+        return Object.keys(supportedProviders).reduce((acc, provider) => {
+            acc.push(
+                ...supportedProviders[provider].models.map((model) => ({
+                    provider,
+                    model,
+                }))
+            );
+            return acc;
+        }, [] as { provider: SupportedProviders; model: SupportedModels[SupportedProviders] }[]);
     }
 }

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

@@ -248,4 +248,29 @@ export class LLMHelper {
 
         return _messages;
     }
+
+    /**
+     * Checks if the given model is part of the Claude 4 family.
+     *
+     * @param {string} modelId - The model identifier to check.
+     * @returns {boolean} True if the model is Claude 4 family, false otherwise.
+     *
+     * @example
+     * const isClaude4 = LLMHelper.isClaude4Family('claude-sonnet-4-20250514');
+     * console.log(isClaude4); // true
+     *
+     * @example
+     * const isClaude4 = LLMHelper.isClaude4Family('claude-opus-4-5');
+     * console.log(isClaude4); // true
+     *
+     * @example
+     * const isClaude4 = LLMHelper.isClaude4Family('gpt-4-turbo');
+     * console.log(isClaude4); // false
+     */
+    public static isClaude4Family(modelId: string): boolean {
+        if (!modelId) return false;
+        // Match patterns like: claude-4-*, claude-{variant}-4-*, claude-{variant}-4
+        // Examples: claude-opus-4-5, claude-sonnet-4-20250514, claude-4-opus
+        return /claude-(?:\w+-)?4(?:-|$)/i.test(modelId);
+    }
 }

package/src/subsystems/LLMManager/LLM.service/LLMConnector.ts

@@ -275,7 +275,7 @@ export abstract class LLMConnector extends Connector {
         const teamId = await this.getTeamId(candidate);
 
         // We need the model entry name for usage reporting
-        _params.modelEntryName = typeof model === 'string' ? model : (model as TLLMModel).modelId;
+        _params.modelEntryName = typeof model === 'string' ? model : model?.modelEntryName || model?.modelId;
         _params.teamId = teamId;
 
         const modelProviderCandidate = modelsProvider.requester(candidate);