@smythos/sre 1.5.39 → 1.5.40

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

@@ -0,0 +1,19 @@
+import Joi from 'joi';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+export declare class MemoryDeleteKeyVal extends Component {
+    protected configSchema: Joi.ObjectSchema<any>;
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<{
+        Key: string;
+        deleted: boolean;
+        _debug: string;
+        _error?: undefined;
+    } | {
+        _error: any;
+        _debug: string;
+        Key?: undefined;
+        deleted?: undefined;
+    }>;
+}

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

@@ -0,0 +1,17 @@
+import Joi from 'joi';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+export declare class MemoryReadKeyVal extends Component {
+    protected configSchema: Joi.ObjectSchema<any>;
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<{
+        Value: any;
+        _debug: string;
+        _error?: undefined;
+    } | {
+        _error: any;
+        _debug: string;
+        Value?: undefined;
+    }>;
+}

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

@@ -0,0 +1,17 @@
+import Joi from 'joi';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+export declare class MemoryWriteKeyVal extends Component {
+    protected configSchema: Joi.ObjectSchema<any>;
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<{
+        Key: string;
+        _debug: string;
+        _error?: undefined;
+    } | {
+        _error: any;
+        _debug: string;
+        Key?: undefined;
+    }>;
+}

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

@@ -0,0 +1,19 @@
+import Joi from 'joi';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+export declare class MemoryWriteObject extends Component {
+    protected configSchema: Joi.ObjectSchema<any>;
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<{
+        Keys: string[];
+        Count: number;
+        _debug: string;
+        _error?: undefined;
+    } | {
+        _error: any;
+        _debug: string;
+        Keys?: undefined;
+        Count?: undefined;
+    }>;
+}

package/dist/types/Components/index.d.ts

@@ -38,6 +38,10 @@ import { ImageGenerator } from './ImageGenerator.class';
 import { MCPClient } from './MCPClient.class';
 import { OpenAPI } from './OpenAPI.class';
 import { ECMASandbox } from './ECMASandbox.class';
+import { MemoryWriteKeyVal } from './MemoryWriteKeyVal.class';
+import { MemoryReadKeyVal } from './MemoryReadKeyVal.class';
+import { MemoryDeleteKeyVal } from './MemoryDeleteKeyVal.class';
+import { MemoryWriteObject } from './MemoryWriteObject.class';
 export declare const ComponentInstances: {
     Component: Component;
     Note: Component;
@@ -83,4 +87,8 @@ export declare const ComponentInstances: {
     MCPClient: MCPClient;
     OpenAPI: OpenAPI;
     ECMASandbox: ECMASandbox;
+    MemoryWriteKeyVal: MemoryWriteKeyVal;
+    MemoryReadKeyVal: MemoryReadKeyVal;
+    MemoryDeleteKeyVal: MemoryDeleteKeyVal;
+    MemoryWriteObject: MemoryWriteObject;
 };

package/dist/types/index.d.ts

@@ -32,6 +32,10 @@ export * from './Components/LogicAtMost.class';
 export * from './Components/LogicOR.class';
 export * from './Components/LogicXOR.class';
 export * from './Components/MCPClient.class';
+export * from './Components/MemoryDeleteKeyVal.class';
+export * from './Components/MemoryReadKeyVal.class';
+export * from './Components/MemoryWriteKeyVal.class';
+export * from './Components/MemoryWriteObject.class';
 export * from './Components/MultimodalLLM.class';
 export * from './Components/PromptGenerator.class';
 export * from './Components/ScrapflyWebScrape.class';

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

@@ -1,16 +1,14 @@
 import { type UsageMetadata } from '@google-cloud/vertexai';
 import EventEmitter from 'events';
-import { APIKeySource, ILLMRequestFuncParams, TGoogleAIRequestBody, TLLMPreparedParams, TLLMMessageBlock, ToolData, TLLMToolResultMessageBlock, TLLMMessageRole } from '@sre/types/LLM.types';
+import { APIKeySource, ILLMRequestFuncParams, TGoogleAIRequestBody, TLLMPreparedParams, TLLMMessageBlock, ToolData, TLLMToolResultMessageBlock, TLLMChatResponse } from '@sre/types/LLM.types';
 import { LLMConnector } from '../LLMConnector';
 export declare class VertexAIConnector extends LLMConnector {
     name: string;
     private getClient;
-    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<any>;
+    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
     protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
     protected reqBodyAdapter(params: TLLMPreparedParams): Promise<TGoogleAIRequestBody>;
-    protected reportUsage(usage: UsageMetadata & {
-        cachedContentTokenCount?: number;
-    }, metadata: {
+    protected reportUsage(usage: UsageMetadata, metadata: {
         modelEntryName: string;
         keySource: APIKeySource;
         agentId: string;
@@ -25,7 +23,10 @@ export declare class VertexAIConnector extends LLMConnector {
         agentId: string;
         teamId: string;
     };
-    private sanitizeFunctionName;
+    private prepareMessages;
+    private processFiles;
+    private convertMessagesToVertexAIFormat;
+    private formatToolsForVertexAI;
     formatToolsConfig({ toolDefinitions, toolChoice }: {
         toolDefinitions: any;
         toolChoice?: string;
@@ -39,8 +40,4 @@ export declare class VertexAIConnector extends LLMConnector {
         messageBlock: TLLMMessageBlock;
         toolsData: ToolData[];
     }): TLLMToolResultMessageBlock[];
-    getConsistentMessages(messages: any): {
-        role: TLLMMessageRole;
-        parts: any[];
-    }[];
 }

package/package.json

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

package/src/Components/MemoryDeleteKeyVal.class.ts

@@ -0,0 +1,70 @@
+import Joi from 'joi';
+
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+import { ICacheRequest } from '@sre/MemoryManager/Cache.service/CacheConnector';
+
+export class MemoryDeleteKeyVal extends Component {
+    protected configSchema = Joi.object({
+        memoryName: Joi.string().max(255).allow('').label('Memory Name'),
+        key: Joi.string().max(255).allow('').label('Key'),
+    });
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+
+        const logger = this.createComponentLogger(agent, config);
+
+        try {
+            const cacheConnector = ConnectorService.getCacheConnector();
+            const connectorRequester: ICacheRequest = cacheConnector.agent(agent.id);
+            const teamId = agent.teamId;
+            const agentId = agent.id;
+
+            const memoryName = config.data.memoryName;
+            const key = TemplateString(config.data.key).parse(input).result;
+
+            const sessionId = agent.sessionId;
+            const workflowId = agent.agentRuntime.workflowReqId;
+
+            logger.debug(`Reading Scope Data for deletion`);
+            const scopeKeyId = `${agentId}:${memoryName}:${key}_scope`;
+            const scopeStrData = await connectorRequester.get(scopeKeyId);
+
+            if (!scopeStrData) {
+                return { _error: 'key not found', _debug: logger.output };
+            }
+
+            logger.debug(`Checking Scope for deletion`);
+            const scopeData = JSON.parse(scopeStrData);
+            const scopeKey = scopeData.value;
+
+            // Validate scope access like in MemoryReadKeyVal
+            if (scopeData.scope === 'session' && scopeKey !== sessionId) {
+                return { _error: 'key not found', _debug: logger.output };
+            }
+
+            if (scopeData.scope === 'request' && scopeKey !== workflowId) {
+                return { _error: 'key not found', _debug: logger.output };
+            }
+
+            logger.debug(`Deleting memory value and scope data`);
+
+            // Delete the actual value
+            const fullKey = `${agentId}:${scopeKey}:${memoryName}:${key}`;
+            await connectorRequester.delete(fullKey);
+
+            // Delete the scope metadata
+            await connectorRequester.delete(scopeKeyId);
+
+            return { Key: key, deleted: true, _debug: logger.output };
+        } catch (error: any) {
+            return { _error: error.message, _debug: logger.output };
+        }
+    }
+}

package/src/Components/MemoryReadKeyVal.class.ts

@@ -0,0 +1,66 @@
+import Joi from 'joi';
+
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+import { ICacheRequest } from '@sre/MemoryManager/Cache.service/CacheConnector';
+
+const memory = {};
+export class MemoryReadKeyVal extends Component {
+    protected configSchema = Joi.object({
+        memoryName: Joi.string().max(255).allow('').label('Memory Name'),
+    });
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+
+        const logger = this.createComponentLogger(agent, config);
+
+        try {
+            const cacheConnector = ConnectorService.getCacheConnector();
+            const connectorRequester: ICacheRequest = cacheConnector.agent(agent.id);
+            const teamId = agent.teamId;
+            const agentId = agent.id;
+
+            const memoryName = config.data.memoryName;
+
+            const key = input.Key;
+
+            const sessionId = agent.sessionId;
+            const workflowId = agent.agentRuntime.workflowReqId;
+
+            logger.debug(`Reading Scope Data`);
+            const scopeKeyId = `${agentId}:${memoryName}:${key}_scope`;
+            const scopeStrData = await connectorRequester.get(scopeKeyId);
+
+            if (!scopeStrData) {
+                return { _error: 'key not found', _debug: logger.output };
+            }
+
+            logger.debug(`Checking Scope`);
+            const scopeData = JSON.parse(scopeStrData);
+            const scopeKey = scopeData.value;
+            if (scopeData.scope === 'session' && scopeKey !== sessionId) {
+                return { _error: 'key not found', _debug: logger.output };
+            }
+
+            if (scopeData.scope === 'request' && scopeKey !== workflowId) {
+                return { _error: 'key not found', _debug: logger.output };
+            }
+
+            logger.debug(`Reading Value`);
+
+            const fullKey = `${agentId}:${scopeKey}:${memoryName}:${key}`;
+
+            const value = await connectorRequester.get(fullKey);
+
+            return { Value: value, _debug: logger.output };
+        } catch (error: any) {
+            return { _error: error.message, _debug: logger.output };
+        }
+    }
+}

package/src/Components/MemoryWriteKeyVal.class.ts

@@ -0,0 +1,62 @@
+import Joi from 'joi';
+
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+import { ICacheRequest } from '@sre/MemoryManager/Cache.service/CacheConnector';
+
+const memory = {};
+export class MemoryWriteKeyVal extends Component {
+    protected configSchema = Joi.object({
+        memoryName: Joi.string().max(255).allow('').label('Memory Name'),
+        key: Joi.string().max(255).allow('').label('Key'),
+        value: Joi.string().max(100000).allow('').label('Value'),
+        scope: Joi.string().max(20).allow('').label('Scope'),
+        ttl: Joi.number().min(300).max(604800).allow('').label('TTL'),
+    });
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+
+        const logger = this.createComponentLogger(agent, config);
+
+        try {
+            const cacheConnector = ConnectorService.getCacheConnector();
+            const connectorRequester: ICacheRequest = cacheConnector.agent(agent.id);
+            const teamId = agent.teamId;
+            const agentId = agent.id;
+
+            const memoryName = config.data.memoryName;
+            const key = TemplateString(config.data.key).parse(input).result;
+            const value = TemplateString(config.data.value).parse(input).result;
+            const scope = config.data.scope;
+            const ttl = scope === 'ttl' ? config?.data?.ttl : 3 * 60 * 60; // 3 hours default ttl
+
+            const sessionId = agent.sessionId;
+            const workflowId = agent.agentRuntime.workflowReqId;
+
+            let scopeKey = '';
+            if (scope === 'session') {
+                scopeKey = sessionId;
+            } else if (scope === 'request') {
+                scopeKey = workflowId;
+            } else if (scope === 'ttl') {
+                scopeKey = 'ttl';
+            }
+
+            const scopeKeyId = `${agentId}:${memoryName}:${key}_scope`;
+            await connectorRequester.set(scopeKeyId, JSON.stringify({ scope, value: scopeKey }), null, null, ttl);
+
+            const fullKey = `${agentId}:${scopeKey}:${memoryName}:${key}`;
+            await connectorRequester.set(fullKey, value, null, null, ttl);
+
+            return { Key: key, _debug: logger.output };
+        } catch (error: any) {
+            return { _error: error.message, _debug: logger.output };
+        }
+    }
+}

package/src/Components/MemoryWriteObject.class.ts

@@ -0,0 +1,97 @@
+import Joi from 'joi';
+
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+import { ICacheRequest } from '@sre/MemoryManager/Cache.service/CacheConnector';
+
+export class MemoryWriteObject extends Component {
+    protected configSchema = Joi.object({
+        memoryName: Joi.string().max(255).allow('').label('Memory Name'),
+        scope: Joi.string().max(20).allow('').label('Scope'),
+        ttl: Joi.number().min(300).max(604800).allow('').label('TTL'),
+    });
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+
+        const logger = this.createComponentLogger(agent, config);
+
+        try {
+            const cacheConnector = ConnectorService.getCacheConnector();
+            const connectorRequester: ICacheRequest = cacheConnector.agent(agent.id);
+            const teamId = agent.teamId;
+            const agentId = agent.id;
+
+            const memoryName = config.data.memoryName;
+            const dataString = input.Data;
+            const scope = config.data.scope;
+            const ttl = scope === 'ttl' ? config?.data?.ttl : 3 * 60 * 60; // 3 hours default ttl
+
+            // Parse the JSON data
+            let dataObject;
+            try {
+                dataObject = JSON.parse(dataString);
+            } catch (parseError) {
+                return { _error: 'Invalid JSON data provided', _debug: logger.output };
+            }
+
+            // Validate that the parsed data is an object
+            if (typeof dataObject !== 'object' || dataObject === null || Array.isArray(dataObject)) {
+                return { _error: 'Data must be a valid JSON object', _debug: logger.output };
+            }
+
+            const sessionId = agent.sessionId;
+            const workflowId = agent.agentRuntime.workflowReqId;
+
+            let scopeKey = '';
+            if (scope === 'session') {
+                scopeKey = sessionId;
+            } else if (scope === 'request') {
+                scopeKey = workflowId;
+            } else if (scope === 'ttl') {
+                scopeKey = 'ttl';
+            }
+
+            // Get all keys from the data object
+            const keys = Object.keys(dataObject);
+            logger.debug(`Writing ${keys.length} key-value pairs to memory`);
+
+            // Create promises for parallel execution
+            const writePromises = keys.map(async (key) => {
+                const value = String(dataObject[key]); // Convert value to string
+
+                // Write scope metadata
+                const scopeKeyId = `${agentId}:${memoryName}:${key}_scope`;
+                const scopePromise = connectorRequester.set(scopeKeyId, JSON.stringify({ scope, value: scopeKey }), null, null, ttl);
+
+                // Write actual value
+                const fullKey = `${agentId}:${scopeKey}:${memoryName}:${key}`;
+                const valuePromise = connectorRequester.set(fullKey, value, null, null, ttl);
+
+                // Wait for both operations to complete for this key
+                await Promise.all([scopePromise, valuePromise]);
+
+                return { key, success: true };
+            });
+
+            // Execute all write operations in parallel
+            const results = await Promise.all(writePromises);
+            const successfulKeys = results.filter((result) => result.success).map((result) => result.key);
+
+            logger.debug(`Successfully wrote ${successfulKeys.length} keys to memory`);
+
+            return {
+                Keys: successfulKeys,
+                Count: successfulKeys.length,
+                _debug: logger.output,
+            };
+        } catch (error: any) {
+            return { _error: error.message, _debug: logger.output };
+        }
+    }
+}

package/src/Components/index.ts

@@ -38,6 +38,10 @@ import { ImageGenerator } from './ImageGenerator.class'; // Legacy
 import { MCPClient } from './MCPClient.class';
 import { OpenAPI } from './OpenAPI.class';
 import { ECMASandbox } from './ECMASandbox.class';
+import { MemoryWriteKeyVal } from './MemoryWriteKeyVal.class';
+import { MemoryReadKeyVal } from './MemoryReadKeyVal.class';
+import { MemoryDeleteKeyVal } from './MemoryDeleteKeyVal.class';
+import { MemoryWriteObject } from './MemoryWriteObject.class';
 
 const components = {
     Component: new Component(),
@@ -84,6 +88,10 @@ const components = {
     MCPClient: new MCPClient(),
     OpenAPI: new OpenAPI(),
     ECMASandbox: new ECMASandbox(),
+    MemoryWriteKeyVal: new MemoryWriteKeyVal(),
+    MemoryReadKeyVal: new MemoryReadKeyVal(),
+    MemoryDeleteKeyVal: new MemoryDeleteKeyVal(),
+    MemoryWriteObject: new MemoryWriteObject(),
 };
 
 export const ComponentInstances = components;

package/src/helpers/Conversation.helper.ts

@@ -130,8 +130,14 @@ export class Conversation extends EventEmitter {
             this._lastError = error;
             console.warn('Conversation Error: ', error?.message);
         });
-        if (_settings?.maxContextSize) this._maxContextSize = _settings.maxContextSize;
-        if (_settings?.maxOutputTokens) this._maxOutputTokens = _settings.maxOutputTokens;
+        this._maxContextSize =
+            _settings.maxContextSize || (this._model as TLLMModel).tokens || (this._model as TLLMModel).keyOptions?.tokens || this._maxContextSize;
+        this._maxOutputTokens =
+            _settings.maxOutputTokens ||
+            (this._model as TLLMModel).completionTokens ||
+            (this._model as TLLMModel).keyOptions?.completionTokens ||
+            this._maxOutputTokens;
+
         if (_settings?.systemPrompt) {
             this.userDefinedSystemPrompt = _settings.systemPrompt;
         }
@@ -490,9 +496,11 @@ export class Conversation extends EventEmitter {
                     //this._context.addAssistantMessage(passThroughContent, message_id);
                     llmMessage.content += '\n' + passThroughContent;
                     this._context.addToolMessage(llmMessage, processedToolsData, message_id);
+
+                    //this._context.addAssistantMessage(passThroughContent, message_id, { passthrough: true });
                     //this should not be stored in the persistent conversation store
                     //it's just a workaround to avoid generating more content after passthrough content
-                    this._context.addUserMessage(passThroughtContinueMessage, message_id, { internal: true });
+                    //this._context.addUserMessage(passThroughtContinueMessage, message_id, { internal: true });
                     //toolHeaders['x-passthrough'] = 'true';
                 }
 

package/src/index.ts

@@ -38,6 +38,10 @@ export * from './Components/LogicAtMost.class';
 export * from './Components/LogicOR.class';
 export * from './Components/LogicXOR.class';
 export * from './Components/MCPClient.class';
+export * from './Components/MemoryDeleteKeyVal.class';
+export * from './Components/MemoryReadKeyVal.class';
+export * from './Components/MemoryWriteKeyVal.class';
+export * from './Components/MemoryWriteObject.class';
 export * from './Components/MultimodalLLM.class';
 export * from './Components/PromptGenerator.class';
 export * from './Components/ScrapflyWebScrape.class';

package/src/index.ts.bak

@@ -38,6 +38,10 @@ export * from './Components/LogicAtMost.class';
 export * from './Components/LogicOR.class';
 export * from './Components/LogicXOR.class';
 export * from './Components/MCPClient.class';
+export * from './Components/MemoryDeleteKeyVal.class';
+export * from './Components/MemoryReadKeyVal.class';
+export * from './Components/MemoryWriteKeyVal.class';
+export * from './Components/MemoryWriteObject.class';
 export * from './Components/MultimodalLLM.class';
 export * from './Components/PromptGenerator.class';
 export * from './Components/ScrapflyWebScrape.class';

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

@@ -315,8 +315,10 @@ export abstract class LLMConnector extends Connector {
             imageGeneration: features.includes('image-generation'),
         };
 
-        // * We may have other tools info like file search, image generation, etc.
-        // Organize web search parameters from both flat and nested structures
+        // We're using an object with providers instead of setting toolsInfo directly based on the provider,
+        // so the code stays clean and easy to read in connectors like toolsInfo.openai.webSearch or toolsInfo.xai.search.
+        // it helps prevent errors such as mistakenly using toolsInfo.search in the OpenAI connector and similar cases.
+        // This also helps enable autocomplete, so when typing toolsInfo.openai, it shows suggestions like webSearch.
         _params.toolsInfo = {
             openai: await this.prepareOpenAIToolsInfo(_params),
             xai: await this.prepareXAIToolsInfo(_params),

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

@@ -440,9 +440,11 @@ export class AnthropicConnector extends LLMConnector {
         }
         //#endregion Prepare system message and add JSON response instruction if needed
 
-        if (params?.temperature !== undefined) body.temperature = params.temperature;
-        if (params?.topP !== undefined) body.top_p = params.topP;
-        if (params?.topK !== undefined) body.top_k = params.topK;
+        const isReasoningModel = params?.capabilities?.reasoning;
+
+        if (params?.temperature !== undefined && !isReasoningModel) body.temperature = params.temperature;
+        if (params?.topP !== undefined && !isReasoningModel) body.top_p = params.topP;
+        if (params?.topK !== undefined && !isReasoningModel) body.top_k = params.topK;
         if (params?.stopSequences?.length) body.stop_sequences = params.stopSequences;
 
         // #region Tools

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

@@ -3,7 +3,7 @@ import path from 'path';
 import EventEmitter from 'events';
 import fs from 'fs';
 
-import { GoogleGenerativeAI, ModelParams, GenerationConfig, GenerateContentRequest, UsageMetadata } from '@google/generative-ai';
+import { GoogleGenerativeAI, ModelParams, GenerationConfig, GenerateContentRequest, UsageMetadata, FunctionCallingMode } from '@google/generative-ai';
 import { GoogleAIFileManager, FileState } from '@google/generative-ai/server';
 import { GoogleGenAI } from '@google/genai';
 
@@ -397,7 +397,7 @@ export class GoogleAIConnector extends LLMConnector {
 
         const transformedToolsData = toolsData.map(
             (toolData): TLLMToolResultMessageBlock => ({
-                role: TLLMMessageRole.Function,
+                role: TLLMMessageRole.User,
                 parts: [
                     {
                         functionResponse: {
@@ -565,8 +565,23 @@ export class GoogleAIConnector extends LLMConnector {
 
         if (params?.toolsConfig?.tools) toolsPrompt.tools = params?.toolsConfig?.tools as any;
         if (params?.toolsConfig?.tool_choice) {
+            // Map tool choice to valid Google AI function calling modes
+            let mode: FunctionCallingMode = FunctionCallingMode.AUTO; // default
+            const toolChoice = params?.toolsConfig?.tool_choice;
+
+            if (toolChoice === 'auto') {
+                mode = FunctionCallingMode.AUTO;
+            } else if (toolChoice === 'required') {
+                mode = FunctionCallingMode.ANY;
+            } else if (toolChoice === 'none') {
+                mode = FunctionCallingMode.NONE;
+            } else if (typeof toolChoice === 'object' && toolChoice.type === 'function') {
+                // Handle OpenAI-style named tool choice - force any function call
+                mode = FunctionCallingMode.ANY;
+            }
+
             toolsPrompt.toolConfig = {
-                functionCallingConfig: { mode: (params?.toolsConfig?.tool_choice as any) || 'auto' },
+                functionCallingConfig: { mode },
             };
         }