@smythos/sre 1.7.20 → 1.7.41

package/src/Components/Classifier.class.ts

@@ -5,7 +5,9 @@ import { Component } from './Component.class';
 import { IAgent as Agent } from '@sre/types/Agent.types';
 import { TemplateString } from '@sre/helpers/TemplateString.helper';
 import { LLMInference } from '@sre/LLMManager/LLM.inference';
+import { LLMHelper } from '@sre/LLMManager/LLM.helper';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { TLLMEvent } from '@sre/types/LLM.types';
 
 export class Classifier extends Component {
     protected schema = {
@@ -97,7 +99,7 @@ ${JSON.stringify(categories, null, 2)}`;
             prompt = TemplateString(prompt).parse(input).result;
         }
 
-        logger.log(` Enhanced prompt \n${prompt}\n`);
+        logger.log(` Enhanced prompt \n${prompt}`);
 
         if (!prompt) {
             logger.error(` Missing information, Cannot run classifier`);
@@ -114,21 +116,82 @@ ${JSON.stringify(categories, null, 2)}`;
         }
 
         try {
-            let response = await llmInference
-                .prompt({
-                    query: prompt,
-                    params: { ...config, agentId: agent.id },
-                    onFallback: (data) => {
-                        logger.debug(`\n ↩️ Using Fallback Model: ${data.model}`);
-                    },
-                })
-                .catch((error) => ({ error: error }));
-
-            if (response?.error) {
-                const error = response?.error + ' ' + (response?.details || '');
-                logger.error(` LLM Error=`, error);
-
-                return { _error: error, _debug: logger.output };
+            let response;
+
+            // Use streaming for Claude 4 family models
+            if (LLMHelper.isClaude4Family(modelId || model)) {
+                logger.debug(`\n ⚡ Using streaming for Claude 4 family model`);
+
+                const contentPromise = new Promise(async (resolve, reject) => {
+                    let _content = '';
+                    let eventEmitter;
+
+                    eventEmitter = await llmInference
+                        .promptStream({
+                            contextWindow: [{ role: 'user', content: prompt }],
+                            files: [],
+                            params: {
+                                ...config.data,
+                                agentId: agent.id,
+                                responseFormat: 'json',
+                            },
+                            onFallback: (fallbackInfo) => {
+                                logger.debug(`\n ↩️ Using fallback model: ${fallbackInfo.model}`);
+                            },
+                        })
+                        .catch((error) => {
+                            console.error('Error on promptStream: ', error);
+                            reject(error);
+                        });
+
+                    eventEmitter.on(TLLMEvent.Content, (content) => {
+                        _content += content;
+                    });
+
+                    eventEmitter.on(TLLMEvent.End, () => {
+                        resolve(_content);
+                    });
+
+                    eventEmitter.on(TLLMEvent.Error, (error) => {
+                        reject(error);
+                    });
+                });
+
+                response = await contentPromise.catch((error) => {
+                    return { error: error.message || error };
+                });
+
+                // Handle streaming errors
+                if (response?.error) {
+                    const error = response?.error + ' ' + (response?.details || '');
+                    logger.error(` LLM Error=`, error);
+                    return { _error: error, _debug: logger.output };
+                }
+
+                // Post-process the streaming response
+                const postProcessed = llmInference.connector.postProcess(response);
+                if (postProcessed.error) {
+                    logger.error(` LLM Post-process Error=`, postProcessed.error);
+                    return { _error: postProcessed.error, _debug: logger.output };
+                }
+                response = postProcessed;
+            } else {
+                // Use regular prompt for non-Claude 4 models
+                response = await llmInference
+                    .prompt({
+                        query: prompt,
+                        params: { ...config, agentId: agent.id },
+                        onFallback: (data) => {
+                            logger.debug(`\n ↩️ Using Fallback Model: ${data.model}`);
+                        },
+                    })
+                    .catch((error) => ({ error: error }));
+
+                if (response?.error) {
+                    const error = response?.error + ' ' + (response?.details || '');
+                    logger.error(` LLM Error=`, error);
+                    return { _error: error, _debug: logger.output };
+                }
             }
 
             // let parsed = parseJson(response);

package/src/Components/Component.class.ts

@@ -3,6 +3,7 @@ import { IAgent as Agent } from '@sre/types/Agent.types';
 import { Logger } from '@sre/helpers/Log.helper';
 import { performTypeInference } from '@sre/helpers/TypeChecker.helper';
 import { hookableClass, hookAsync } from '@sre/Core/HookService';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
 
 export type TComponentSchema = {
     name: string;
@@ -123,7 +124,19 @@ export class Component {
         if (agent.isKilled()) {
             throw new Error('Agent killed');
         }
-        const _input = await performTypeInference(input, config?.inputs, agent);
+
+        let _input = {};
+
+        // #region Resolve agent variables so that:
+        // - type inference works correctly
+        // - we don’t need a separate resolution step when the variable name
+        //   matches the component input name
+        for (let [key, value] of Object.entries(input)) {
+            _input[key] = TemplateString(value as string).parse(agent.agentVariables).result;
+        }
+        // #endregion
+
+        _input = await performTypeInference(_input, config?.inputs, agent);
 
         // modify the input object for component's process method
         for (const [key, value] of Object.entries(_input)) {

package/src/Components/ForEach.class.ts

@@ -18,6 +18,8 @@ export class ForEach extends Component {
         let _in_progress = true;
         const logger = this.createComponentLogger(agent, config);
         try {
+            logger.debug(`=== ForEach Log ===`);
+
             const inputObject = input.Input;
             let inputArray;
 
@@ -38,18 +40,30 @@ export class ForEach extends Component {
             const runtimeData = agent.agentRuntime.getRuntimeData(config.id);
             const _ForEachData = runtimeData._LoopData || { parentId: config.id, loopIndex: 0, loopLength: inputArray.length };
 
-            logger.debug(`Loop: ${_ForEachData.loopIndex} / ${_ForEachData.loopLength}`);
             delete _ForEachData.branches; //reset branches (the number of branches is calculated in CallComponent@Agent.class.ts )
 
             if (_ForEachData.result) {
                 _temp_result = _ForEachData.result;
-                logger.debug(`  => Loop Result : ${JSON.stringify(Loop, null, 2)}`);
-                logger.debug(`---------------------------------------------------`);
             }
 
             Loop = inputArray[_ForEachData.loopIndex];
 
-            logger.debug(`  => Loop Data : ${JSON.stringify(Loop, null, 2)}`);
+            // Log each iteration: show iteration number, input, and previous iteration details (if available)
+            if (Loop !== undefined) {
+                logger.debug(` Iteration ${_ForEachData.loopIndex + 1}/${_ForEachData.loopLength}`);
+                logger.debug(` In Progress: ${_in_progress}`);
+                logger.debug(` Input: \n${JSON.stringify(Loop, null, 2)}`);
+
+                // Show previous iteration's input and result if available
+                if (_ForEachData.loopIndex > 0 && _temp_result && _temp_result[_ForEachData.loopIndex - 1]) {
+                    const prevInput = inputArray[_ForEachData.loopIndex - 1];
+                    const prevItem = _temp_result[_ForEachData.loopIndex - 1];
+                    logger.debug(''); // empty line
+                    logger.debug(` Previous Input: \n${JSON.stringify(prevInput, null, 2)}`);
+                    logger.debug(''); // empty line
+                    logger.debug(` Previous Result: \n${JSON.stringify(prevItem.result || prevItem, null, 2)}`);
+                }
+            }
 
             _in_progress = Loop !== undefined;
             if (_in_progress) {
@@ -67,12 +81,26 @@ export class ForEach extends Component {
 
             switch (config?.data?.format) {
                 case 'minimal':
-                    Result = Result.map((item) => cleanupResult(item.result));
+                    Result = Result.map((item) => cleanupResult(item.result || item));
                     break;
                 case 'results-array':
-                    Result = Result.map((item) => Object.values(cleanupResult(item.result))).flat(Infinity);
+                    Result = Result.map((item) => Object.values(cleanupResult(item.result || item))).flat(Infinity);
                     break;
             }
+
+            // Final summary: Input array, total iterations, and result
+            logger.debug(` Total Iterations: ${Result.length}`);
+            logger.debug(` In Progress: ${_in_progress}`);
+            logger.debug(''); // empty line
+            logger.debug(` Input: \n${JSON.stringify(input.Input, null, 2)}`);
+            logger.debug(''); // empty line
+            logger.debug(
+                ` Result: \n${JSON.stringify(
+                    Result.map((item) => item.result || item),
+                    null,
+                    2
+                )}`
+            );
         }
 
         return { Loop, Result, _temp_result, _error, _in_progress, _debug: logger.output };

package/src/Components/GenAILLM.class.ts

@@ -107,25 +107,25 @@ export class GenAILLM extends Component {
             },
             webSearchCity: {
                 type: 'string',
-                max: 100,
+                max: 255,
                 label: 'Web Search City',
                 allowEmpty: true,
             },
             webSearchCountry: {
                 type: 'string',
-                max: 2,
+                max: 255,
                 label: 'Web Search Country',
                 allowEmpty: true,
             },
             webSearchRegion: {
                 type: 'string',
-                max: 100,
+                max: 255,
                 label: 'Web Search Region',
                 allowEmpty: true,
             },
             webSearchTimezone: {
                 type: 'string',
-                max: 100,
+                max: 255,
                 label: 'Web Search Timezone',
                 allowEmpty: true,
             },
@@ -165,7 +165,7 @@ export class GenAILLM extends Component {
             },
             searchCountry: {
                 type: 'string',
-                max: 2,
+                max: 255,
                 label: 'Search Country',
                 allowEmpty: true,
             },
@@ -247,7 +247,7 @@ export class GenAILLM extends Component {
             },
             reasoningEffort: {
                 type: 'string',
-                valid: ['none', 'default', 'low', 'medium', 'high'],
+                valid: ['none', 'default', 'low', 'medium', 'high', 'xhigh'],
                 description: 'Controls the level of effort the model will put into reasoning',
                 label: 'Reasoning Effort',
             },
@@ -295,10 +295,10 @@ export class GenAILLM extends Component {
         // #region Web Search
         useWebSearch: Joi.boolean().optional().label('Use Web Search'),
         webSearchContextSize: Joi.string().valid('high', 'medium', 'low').optional().label('Web Search Context Size'),
-        webSearchCity: Joi.string().max(100).optional().allow('').label('Web Search City'),
-        webSearchCountry: Joi.string().max(2).optional().allow('').label('Web Search Country'),
-        webSearchRegion: Joi.string().max(100).optional().allow('').label('Web Search Region'),
-        webSearchTimezone: Joi.string().max(100).optional().allow('').label('Web Search Timezone'),
+        webSearchCity: Joi.string().max(255).optional().allow('').label('Web Search City'),
+        webSearchCountry: Joi.string().max(255).optional().allow('').label('Web Search Country'),
+        webSearchRegion: Joi.string().max(255).optional().allow('').label('Web Search Region'),
+        webSearchTimezone: Joi.string().max(255).optional().allow('').label('Web Search Timezone'),
         // #endregion
 
         // #region xAI Search
@@ -307,7 +307,7 @@ export class GenAILLM extends Component {
         returnCitations: Joi.boolean().optional().allow('').label('Return Citations'),
         maxSearchResults: Joi.number().min(1).max(100).optional().allow('').label('Max Search Results'),
         searchDataSources: Joi.array().items(Joi.string().valid('web', 'x', 'news', 'rss')).max(4).optional().allow('').label('Search Data Sources'),
-        searchCountry: Joi.string().length(2).optional().allow('').label('Search Country'),
+        searchCountry: Joi.string().max(255).optional().allow('').label('Search Country'),
         excludedWebsites: Joi.string().max(10000).optional().allow('').label('Excluded Websites'),
         allowedWebsites: Joi.string().max(10000).optional().allow('').label('Allowed Websites'),
         includedXHandles: Joi.string().max(1000).optional().allow('').label('Included X Handles'),
@@ -330,7 +330,11 @@ export class GenAILLM extends Component {
 
         // #region Reasoning
         useReasoning: Joi.boolean().optional().label('Use Reasoning'),
-        reasoningEffort: Joi.string().valid('none', 'default', 'minimal', 'low', 'medium', 'high').optional().allow('').label('Reasoning Effort'),
+        reasoningEffort: Joi.string()
+            .valid('none', 'default', 'minimal', 'low', 'medium', 'high', 'xhigh')
+            .optional()
+            .allow('')
+            .label('Reasoning Effort'),
         maxThinkingTokens: Joi.number().min(1).optional().label('Maximum Thinking Tokens'),
         // #endregion
     });
@@ -348,13 +352,24 @@ export class GenAILLM extends Component {
             logger.debug(`=== GenAILLM Log ===`);
             let teamId = agent?.teamId;
 
-            const passThrough: boolean = config.data.passthrough || false;
-            const useContextWindow: boolean = config.data.useContextWindow || false;
-            const useSystemPrompt: boolean = config.data.useSystemPrompt || false;
-            const useWebSearch: boolean = config.data.useWebSearch || false;
-            const maxTokens: number = parseInt(config.data.maxTokens) || 1024;
-            const maxContextWindowLength: number = parseInt(config.data.maxContextWindowLength) || 1024;
-            const model: string = config.data.model || 'echo';
+            // Resolve template variables in config.data without mutating original config
+            const resolvedConfigData = {
+                ...config.data,
+                prompt: config.data.prompt && TemplateString(config.data.prompt).parse(input).result,
+                webSearchCity: config.data.webSearchCity && TemplateString(config.data.webSearchCity).parse(input).result,
+                webSearchCountry: config.data.webSearchCountry && TemplateString(config.data.webSearchCountry).parse(input).result,
+                webSearchRegion: config.data.webSearchRegion && TemplateString(config.data.webSearchRegion).parse(input).result,
+                webSearchTimezone: config.data.webSearchTimezone && TemplateString(config.data.webSearchTimezone).parse(input).result,
+
+                searchCountry: config.data.searchCountry && TemplateString(config.data.searchCountry).parse(input).result,
+            };
+
+            const passThrough: boolean = resolvedConfigData.passthrough || false;
+            const useContextWindow: boolean = resolvedConfigData.useContextWindow || false;
+            const useSystemPrompt: boolean = resolvedConfigData.useSystemPrompt || false;
+            const maxTokens: number = parseInt(resolvedConfigData.maxTokens) || 1024;
+            const maxContextWindowLength: number = parseInt(resolvedConfigData.maxContextWindowLength) || 1024;
+            const model: string = resolvedConfigData.model || 'echo';
             const llmInference: LLMInference = await LLMInference.getInstance(model, AccessCandidate.agent(agent.id));
 
             // if the llm is undefined, then it means we removed the model from our system
@@ -371,7 +386,7 @@ export class GenAILLM extends Component {
 
             logger.debug(` Model : ${modelId || model}`);
 
-            let prompt: any = TemplateString(config.data.prompt).parse(input).result;
+            const prompt: any = resolvedConfigData.prompt;
 
             let files: any[] = parseFiles(input, config);
             let isMultimodalRequest = false;
@@ -403,8 +418,24 @@ export class GenAILLM extends Component {
                 files = validFiles.filter(Boolean);
 
                 if (files.length === 0) {
+                    // No valid files after filtering - determine the cause
+                    const hasDetectedMimeTypes = fileTypes.size > 0;
+
+                    if (!hasDetectedMimeTypes) {
+                        // Case 1: No mime types detected - files are corrupted/invalid
+                        return {
+                            _error: `Unable to process the provided file(s). Please ensure file(s) are not corrupted, have valid formats, and contain readable data.`,
+                            _debug: logger.output,
+                        };
+                    }
+
+                    // Case 2: Files detected but model doesn't support those types
+                    const detectedTypes = Array.from(fileTypes).join(', ');
+                    const supportedTypes = new Set(Object.values(supportedFileTypes).flat());
+                    const supportedTypesText = supportedTypes.size > 0 ? `\nSupported types: ${Array.from(supportedTypes).join(', ')}` : '';
+
                     return {
-                        _error: `Model does not support ${fileTypes?.size > 0 ? Array.from(fileTypes).join(', ') : 'File(s)'}`,
+                        _error: `Model '${model}' does not support the provided file type(s): ${detectedTypes}.${supportedTypesText}`,
                         _debug: logger.output,
                     };
                 }
@@ -420,7 +451,7 @@ export class GenAILLM extends Component {
 
             // default to json response format
             const hasCustomOutputs = config?.outputs?.some((output) => !output.default);
-            config.data.responseFormat = config.data?.responseFormat || (hasCustomOutputs ? 'json' : '');
+            resolvedConfigData.responseFormat = resolvedConfigData?.responseFormat || (hasCustomOutputs ? 'json' : '');
 
             // request to LLM
             let response: any;
@@ -478,7 +509,7 @@ export class GenAILLM extends Component {
                         contextWindow: messages,
                         files,
                         params: {
-                            ...config.data,
+                            ...resolvedConfigData,
                             agentId: agent.id,
                         },
                         onFallback: (fallbackInfo) => {
@@ -528,26 +559,36 @@ export class GenAILLM extends Component {
             response = await contentPromise.catch((error) => {
                 return { error: error.message || error };
             });
-            // If the model stopped before completing the response, this is usually due to output token limit reached.
+
+            // #region Handle Response Errors
+            if (response?.error) {
+                const error = response?.error + ' ' + (response?.details || '');
+                logger.error(` LLM Error=`, error);
+
+                return { Output: response?.data, _error: error, _debug: logger.output };
+            }
+
+            const emptyResponseErrorMsg =
+                "Empty response. This is usually due to output token limit reached. Please try again with a higher 'Maximum Output Tokens'.";
+
+            // If the finish reason is not "stop", it means the model stopped before completing the response.
             if (finishReason !== 'stop') {
+                let errMsg = `The model stopped before completing the response.
+                \nReason: ${finishReason}.
+                \n${!response ? emptyResponseErrorMsg : ''}`;
+
                 return {
                     Reply: response,
-                    _error: 'The model stopped before completing the response, this is usually due to output token limit reached.',
+                    _error: errMsg,
                     _debug: logger.output,
                 };
             }
 
-            // in case we have the response but it's empty string, undefined or null
+            // If the finish reason is "stop" but there is still no response, it is usually caused by reaching the output token limit.
             if (!response) {
-                return { _error: ' LLM Error = Empty Response!', _debug: logger.output };
-            }
-
-            if (response?.error) {
-                const error = response?.error + ' ' + (response?.details || '');
-                logger.error(` LLM Error=`, error);
-
-                return { Output: response?.data, _error: error, _debug: logger.output };
+                return { _error: emptyResponseErrorMsg, _debug: logger.output };
             }
+            // #endregion
 
             const Reply = llmInference.connector.postProcess(response);
             if (Reply.error) {

package/src/Components/LLMAssistant.class.ts

@@ -10,7 +10,8 @@ import { encode } from 'gpt-tokenizer';
 import { Component } from './Component.class';
 import { JSONContent } from '@sre/helpers/JsonContent.helper';
 import { LLMInference } from '@sre/LLMManager/LLM.inference';
-import { TLLMMessageRole } from '@sre/types/LLM.types';
+import { LLMHelper } from '@sre/LLMManager/LLM.helper';
+import { TLLMMessageRole, TLLMEvent } from '@sre/types/LLM.types';
 import { VaultHelper } from '@sre/Security/Vault.service/Vault.helper';
 import path from 'path';
 import config from '@sre/config';
@@ -113,7 +114,7 @@ export class LLMAssistant extends Component {
             const conversationId = input.ConversationId;
 
             let behavior = TemplateString(config.data.behavior).parse(input).result;
-            logger.debug(`[Parsed Behavior] \n${behavior}`);
+            logger.debug(` [Parsed Behavior] \n${behavior}`);
 
             //#region get max tokens
             let maxTokens = 2048;
@@ -147,7 +148,14 @@ export class LLMAssistant extends Component {
             };
 
             let response: any;
-            if (passThrough) {
+            const isClaude4 = LLMHelper.isClaude4Family(modelId || model);
+
+            // Use streaming for passthrough OR Claude 4 family models
+            if (passThrough || isClaude4) {
+                if (isClaude4) {
+                    logger.debug(`\n ⚡ Using streaming for Claude 4 family model`);
+                }
+
                 const contentPromise = new Promise(async (resolve, reject) => {
                     let _content = '';
                     const eventEmitter: any = await llmInference
@@ -162,25 +170,53 @@ export class LLMAssistant extends Component {
                             console.error('Error on promptStream: ', error);
                             reject(error);
                         });
-                    eventEmitter.on('content', (content) => {
-                        if (typeof agent.callback === 'function') {
-                            agent.callback({ content });
+
+                    eventEmitter.on(TLLMEvent.Content, (content) => {
+                        if (passThrough) {
+                            if (typeof agent.callback === 'function') {
+                                agent.callback({ content });
+                            }
+                            agent.sse.send('llm/passthrough/content', content);
                         }
-                        agent.sse.send('llm/passthrough/content', content);
                         _content += content;
                     });
-                    eventEmitter.on('thinking', (thinking) => {
-                        if (typeof agent.callback === 'function') {
-                            agent.callback({ thinking });
+
+                    eventEmitter.on(TLLMEvent.Thinking, (thinking) => {
+                        if (passThrough) {
+                            if (typeof agent.callback === 'function') {
+                                agent.callback({ thinking });
+                            }
+                            agent.sse.send('llm/passthrough/thinking', thinking);
                         }
-                        agent.sse.send('llm/passthrough/thinking', thinking);
                     });
-                    eventEmitter.on('end', () => {
-                        console.log('end');
+
+                    eventEmitter.on(TLLMEvent.End, () => {
                         resolve(_content);
                     });
+
+                    eventEmitter.on(TLLMEvent.Error, (error) => {
+                        reject(error);
+                    });
                 });
-                response = await contentPromise;
+
+                response = await contentPromise.catch((error) => {
+                    return { error: error.message || error };
+                });
+
+                // Handle streaming errors
+                if (response?.error) {
+                    const error = response?.error + ' ' + (response?.details || '');
+                    logger.error(` LLM Error=`, error);
+                    return { Response: response?.data, _error: error, _debug: logger.output };
+                }
+
+                // Post-process the streaming response
+                const postProcessed = llmInference.connector.postProcess(response);
+                if (postProcessed.error) {
+                    logger.error(` LLM Post-process Error=`, postProcessed.error);
+                    return { _error: postProcessed.error, _debug: logger.output };
+                }
+                response = postProcessed;
             } else {
                 response = await llmInference
                     .prompt({
@@ -191,6 +227,12 @@ export class LLMAssistant extends Component {
                         },
                     })
                     .catch((error) => ({ error: error }));
+
+                if (response?.error) {
+                    const error = response?.error + ' ' + (response?.details || '');
+                    logger.error(` LLM Error=`, error);
+                    return { Response: response?.data, _error: error, _debug: logger.output };
+                }
             }
 
             // in case we have the response but it's empty string, undefined or null
@@ -198,13 +240,6 @@ export class LLMAssistant extends Component {
                 return { _error: ' LLM Error = Empty Response!', _debug: logger.output };
             }
 
-            if (response?.error) {
-                const error = response?.error + ' ' + (response?.details || '');
-                logger.error(` LLM Error=`, error);
-
-                return { Response: response?.data, _error: error, _debug: logger.output };
-            }
-
             messages.push({ role: 'assistant', content: response });
             saveMessagesToSession(agent.id, userId, conversationId, messages, ttl);