@smythos/sre 1.7.40 → 1.7.42

package/dist/types/Components/AgentPlugin.class.d.ts

@@ -9,7 +9,7 @@ export declare class AgentPlugin extends Component {
         _debug: string;
         Response?: undefined;
     } | {
-        Response: string;
+        Response: any;
         _debug: string;
         _error?: undefined;
     }>;

package/dist/types/Components/RAG/DataSourceCleaner.class.d.ts

@@ -6,13 +6,13 @@ export declare class DataSourceCleaner extends DataSourceComponent {
     constructor();
     init(): void;
     process(input: any, config: any, agent: Agent): Promise<{
-        _debug: string;
-        Success: boolean;
-        _error?: undefined;
-    } | {
         _debug: string;
         _error: any;
         Success?: undefined;
+    } | {
+        _debug: string;
+        Success: boolean;
+        _error?: undefined;
     }>;
     processV1(input: any, config: any, agent: Agent): Promise<{
         _debug: string;

package/dist/types/Components/RAG/DataSourceComponent.class.d.ts

@@ -21,7 +21,11 @@ export declare class DataSourceCompError extends Error {
 }
 export declare class DataSourceComponent extends Component {
     constructor();
-    resolveVectorDbConnector(namespace: string | NsRecord, teamId: string): Promise<VectorDBConnector>;
+    resolveVectorDbConnector(namespace: string | NsRecord, teamId: string): Promise<{
+        vecDbConnector: VectorDBConnector;
+        namespaceRecord: NsRecord;
+    }>;
+    private resolveNamespaceRecord;
     buildEmbeddingConfig(embedding: {
         dimensions: string;
         modelId: string;

package/dist/types/config.d.ts

@@ -3,6 +3,7 @@ declare const config: {
         LOG_LEVEL: string;
         LOG_FILTER: string;
         NODE_ENV: string;
+        ROLLOUT_RAG_V2: string;
     };
     agent: {
         ENDPOINT_PREFIX: string;

package/dist/types/helpers/Conversation.helper.d.ts

@@ -1,6 +1,6 @@
 import { LLMInference } from '@sre/LLMManager/LLM.inference';
 import { LLMContext } from '@sre/MemoryManager/LLMContext';
-import { ILLMContextStore, TLLMModel } from '@sre/types/LLM.types';
+import { IConversationSettings, TLLMModel } from '@sre/types/LLM.types';
 import EventEmitter from 'events';
 export declare class Conversation extends EventEmitter {
     private _model;
@@ -30,7 +30,15 @@ export declare class Conversation extends EventEmitter {
     agentData: any;
     private _id;
     get id(): string;
+    private _toolCallCount;
+    private _maxToolCallsPerSession;
+    private _disableToolsForNextCall;
     get context(): LLMContext;
+    get storeId(): string;
+    /**
+     * Headers to be added to all tool call requests
+     */
+    headers: Record<string, string>;
     private _lastError;
     private _spec;
     private _customToolsDeclarations;
@@ -41,18 +49,7 @@ export declare class Conversation extends EventEmitter {
     get model(): string | TLLMModel;
     private _llmInference;
     get llmInference(): LLMInference;
-    constructor(_model: string | TLLMModel, _specSource?: string | Record<string, any>, _settings?: {
-        maxContextSize?: number;
-        maxOutputTokens?: number;
-        systemPrompt?: string;
-        toolChoice?: string;
-        store?: ILLMContextStore;
-        experimentalCache?: boolean;
-        toolsStrategy?: (toolsConfig: any) => any;
-        agentId?: string;
-        agentVersion?: string;
-        baseUrl?: string;
-    });
+    constructor(_model: string | TLLMModel, _specSource?: string | Record<string, any>, _settings?: IConversationSettings);
     get ready(): any;
     prompt(message?: string | any, toolHeaders?: {}, concurrentToolCalls?: number, abortSignal?: AbortSignal): Promise<string>;
     streamPrompt(message?: string | any, toolHeaders?: {}, concurrentToolCalls?: number, abortSignal?: AbortSignal): Promise<string>;

package/dist/types/helpers/TemplateString.helper.d.ts

@@ -33,7 +33,7 @@ export declare class TemplateStringHelper {
      * unmatched placeholders will be left as is
      * Recursively resolves nested template variables until no more variables are found
      */
-    parse(data: Record<string, string>, regex?: TemplateStringMatch, maxDepth?: number): this;
+    parse(data: Record<string, unknown>, regex?: TemplateStringMatch, maxDepth?: number): this;
     /**
      * Parses a template string by replacing placeholders with values from the provided data object, keeping the original raw values intact. This is particularly important for BinaryInput instances, as they include buffer data.
      * unmatched placeholders will be left as is

package/dist/types/index.d.ts

@@ -87,6 +87,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/dist/types/subsystems/IO/VectorDB.service/VectorDBConnector.d.ts

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

package/dist/types/subsystems/LLMManager/LLM.helper.d.ts

@@ -133,4 +133,23 @@ export declare class LLMHelper {
      * @returns {TLLMMessageBlock[]} The modified array of message objects.
      */
     static removeDuplicateUserMessages(messages: TLLMMessageBlock[]): TLLMMessageBlock[];
+    /**
+     * 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
+     */
+    static isClaude4Family(modelId: string): boolean;
 }

package/dist/types/subsystems/LLMManager/LLM.service/connectors/GoogleAI.class.d.ts

@@ -1,6 +1,6 @@
 import EventEmitter from 'events';
 import { type GenerateContentResponseUsageMetadata } from '@google/genai/node';
-import { TLLMMessageBlock, ToolData, TLLMToolResultMessageBlock, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TGoogleAIRequestBody, ILLMRequestContext, TLLMPreparedParams } from '@sre/types/LLM.types';
+import { TLLMMessageBlock, ToolData, TLLMToolResultMessageBlock, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TGoogleAIRequestBody, TLLMPreparedParams } from '@sre/types/LLM.types';
 import { LLMConnector } from '../LLMConnector';
 type UsageMetadataWithThoughtsToken = GenerateContentResponseUsageMetadata & {
     thoughtsTokenCount?: number;
@@ -26,6 +26,7 @@ export declare class GoogleAIConnector extends LLMConnector {
         sourceId: string;
         input_tokens: number;
         output_tokens: number;
+        output_tokens_image: number;
         input_tokens_audio: number;
         input_tokens_cache_read: number;
         input_tokens_cache_read_audio: number;
@@ -33,22 +34,26 @@ export declare class GoogleAIConnector extends LLMConnector {
         keySource: APIKeySource;
         agentId: string;
         teamId: string;
-        inTier: string;
-        outTier: string;
-        crTier: string;
+        tier: string;
     };
     /**
      * Extract text and image tokens from Google AI usage metadata
      */
     private extractTokenCounts;
-    protected reportImageUsage({ usage, context, numberOfImages, }: {
-        usage: {
-            cost?: number;
-            usageMetadata?: UsageMetadataWithThoughtsToken;
-        };
-        context: ILLMRequestContext;
+    protected reportImageCost({ cost, context, numberOfImages }: {
+        cost: any;
+        context: any;
         numberOfImages?: number;
     }): void;
+    /**
+     * Normalizes function response values to ensure they conform to Google AI's STRUCT requirement.
+     * Gemini expects functionResponse.response to be a STRUCT (JSON object format), not a list or scalar.
+     */
+    private normalizeFunctionResponse;
+    /**
+     * Parses and normalizes function response values, handling string JSON and various data types.
+     */
+    private parseFunctionResponse;
     formatToolsConfig({ toolDefinitions, toolChoice }: {
         toolDefinitions: any;
         toolChoice?: string;

package/dist/types/types/LLM.types.d.ts

@@ -196,6 +196,7 @@ export type TLLMModel = {
     isCustomLLM?: boolean;
     isUserCustomLLM?: boolean;
     modelId?: string;
+    modelEntryName?: string;
     tokens?: number;
     completionTokens?: number;
     components?: string[];
@@ -394,10 +395,32 @@ export type TLLMInputMessage = {
     }[];
 };
 export interface ILLMContextStore {
+    id: string;
     save(messages: any[]): Promise<void>;
     load(count?: number): Promise<any[]>;
     getMessage(message_id: string): Promise<any[]>;
 }
+/**
+ * Configuration options for Conversation helper
+ */
+export interface IConversationSettings {
+    maxContextSize?: number;
+    maxOutputTokens?: number;
+    systemPrompt?: string;
+    toolChoice?: string;
+    store?: ILLMContextStore;
+    experimentalCache?: boolean;
+    toolsStrategy?: (toolsConfig: any) => any;
+    agentId?: string;
+    agentVersion?: string;
+    baseUrl?: string;
+    /**
+     * Maximum number of tool calls allowed in a single conversation session.
+     * Prevents infinite loops in tool calling scenarios.
+     * @default 100
+     */
+    maxToolCalls?: number;
+}
 export declare enum APIKeySource {
     Smyth = "smyth-managed",
     User = "user-managed",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smythos/sre",
-  "version": "1.7.40",
+  "version": "1.7.42",
   "description": "Smyth Runtime Environment",
   "author": "Alaa-eddine KADDOURI",
   "license": "MIT",

package/src/Components/AgentPlugin.class.ts

@@ -6,6 +6,8 @@ import { TemplateString } from '@sre/helpers/TemplateString.helper';
 import { IAgent as Agent } from '@sre/types/Agent.types';
 import { Conversation } from '@sre/helpers/Conversation.helper';
 import { Component } from './Component.class';
+import { LLMInference } from '@sre/LLMManager/LLM.inference';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
 
 export class AgentPlugin extends Component {
     protected configSchema = Joi.object({
@@ -84,16 +86,31 @@ export class AgentPlugin extends Component {
 
             const conv = new Conversation(model, subAgentId, { systemPrompt: descForModel, agentVersion: version });
 
-            const result = await conv.prompt(prompt, {
+            // # Region: enhance the prompt to produce a JSON output format based on the available component outputs.
+            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
+            if (!llmInference.connector) {
+                return {
+                    _error: `The model '${model}' is not available. Please try a different one.`,
+                    _debug: logger.output,
+                };
+            }
+            const enhancedPrompt = llmInference.connector.enhancePrompt(prompt, config);
+            // # End Region: prompt enhancement
+
+            const result = await conv.prompt(enhancedPrompt, {
                 'X-AGENT-ID': subAgentId,
                 'X-AGENT-VERSION': version,
                 'X-REQUEST-TAG': reqTag, //request Tag identifies the request and tells the called agent that the call comes from internal agent
                 'x-caller-session-id': agent.callerSessionId,
             });
 
-            logger.debug(`Response:\n`, result, '\n');
+            const processedResponse = llmInference.connector.postProcess(result);
+
+            logger.debug(`Response:\n`, processedResponse, '\n');
 
-            return { Response: result, _debug: logger.output };
+            return { Response: processedResponse, _debug: logger.output };
         } catch (error: any) {
             console.error('Error on running Agent Component: ', error);
             return { _error: `Error on running Agent Component!\n${error?.message || JSON.stringify(error)}`, _debug: logger.output };

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/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) => {