@smythos/sre 1.5.41 → 1.5.43

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

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

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

@@ -10,7 +10,7 @@ export declare class GPTPlugin extends Component {
         _debug: string;
         Output?: undefined;
     } | {
-        Output: any;
+        Output: string;
         _debug: string;
         _error?: undefined;
     }>;

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

@@ -27,11 +27,6 @@ export declare class GenAILLM extends Component {
                 min: number;
                 label: string;
             };
-            maxThinkingTokens: {
-                type: string;
-                min: number;
-                label: string;
-            };
             stopSequences: {
                 type: string;
                 max: number;
@@ -221,6 +216,22 @@ export declare class GenAILLM extends Component {
                 label: string;
                 allowEmpty: boolean;
             };
+            useReasoning: {
+                type: string;
+                description: string;
+                label: string;
+            };
+            reasoningEffort: {
+                type: string;
+                valid: string[];
+                description: string;
+                label: string;
+            };
+            maxThinkingTokens: {
+                type: string;
+                min: number;
+                label: string;
+            };
         };
         inputs: {
             Input: {

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

@@ -10,7 +10,7 @@ export declare class MCPClient extends Component {
         _debug: string;
         Output?: undefined;
     } | {
-        Output: any;
+        Output: string;
         _debug: string;
         _error?: undefined;
     }>;

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

@@ -10,7 +10,7 @@ export declare class OpenAPI extends Component {
         _debug: string;
         Output?: undefined;
     } | {
-        Output: any;
+        Output: string;
         _debug: string;
         _error?: undefined;
     }>;

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

@@ -46,8 +46,8 @@ export declare class Conversation extends EventEmitter {
         agentVersion?: string;
     });
     get ready(): any;
-    prompt(message?: string | any, toolHeaders?: {}, concurrentToolCalls?: number, abortSignal?: AbortSignal): Promise<any>;
-    streamPrompt(message?: string | any, toolHeaders?: {}, concurrentToolCalls?: number, abortSignal?: AbortSignal): Promise<any>;
+    prompt(message?: string | any, toolHeaders?: {}, concurrentToolCalls?: number, abortSignal?: AbortSignal): Promise<string>;
+    streamPrompt(message?: string | any, toolHeaders?: {}, concurrentToolCalls?: number, abortSignal?: AbortSignal): Promise<string>;
     private resolveToolEndpoint;
     private useTool;
     addTool(tool: {

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

@@ -5,6 +5,7 @@ import { LLMConnector } from '../LLMConnector';
 type ChatCompletionCreateParams = {
     model: string;
     messages: any;
+    max_completion_tokens?: number;
     max_tokens?: number;
     temperature?: number;
     stop?: string[];
@@ -12,6 +13,7 @@ type ChatCompletionCreateParams = {
     tools?: any;
     tool_choice?: string;
     stream?: boolean;
+    reasoning_effort?: 'none' | 'default' | 'low' | 'medium' | 'high';
 };
 export declare class GroqConnector extends LLMConnector {
     name: string;

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

@@ -124,6 +124,12 @@ export type TLLMParams = {
     fromDate?: string;
     toDate?: string;
     useReasoning?: boolean;
+    /**
+     * Controls the level of effort the model will put into reasoning
+     * For GPT-OSS models (20B, 120B): "low" | "medium" | "high"
+     * For Qwen 3 32B: "none" | "default"
+     */
+    reasoningEffort?: 'none' | 'default' | 'low' | 'medium' | 'high';
     max_output_tokens?: number;
     abortSignal?: AbortSignal;
 };

package/package.json

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

package/src/Components/GenAILLM.class.ts

@@ -36,11 +36,6 @@ export class GenAILLM extends Component {
                 min: 1,
                 label: 'Maximum Tokens',
             },
-            maxThinkingTokens: {
-                type: 'number',
-                min: 1,
-                label: 'Maximum Thinking Tokens',
-            },
             stopSequences: {
                 type: 'string',
                 max: 400,
@@ -236,6 +231,25 @@ export class GenAILLM extends Component {
                 allowEmpty: true,
             },
             // #endregion
+
+            // #region Reasoning
+            useReasoning: {
+                type: 'boolean',
+                description: 'If true, the component will use reasoning capabilities for complex problem-solving',
+                label: 'Use Reasoning',
+            },
+            reasoningEffort: {
+                type: 'string',
+                valid: ['none', 'default', 'low', 'medium', 'high'],
+                description: 'Controls the level of effort the model will put into reasoning',
+                label: 'Reasoning Effort',
+            },
+            maxThinkingTokens: {
+                type: 'number',
+                min: 1,
+                label: 'Maximum Thinking Tokens',
+            },
+            // #endregion
         },
         inputs: {
             Input: {
@@ -306,8 +320,11 @@ export class GenAILLM extends Component {
             .label('To Date'),
         // #endregion
 
+        // #region Reasoning
         useReasoning: Joi.boolean().optional().label('Use Reasoning'),
-        maxThinkingTokens: Joi.number().min(1).label('Maximum Thinking Tokens'),
+        reasoningEffort: Joi.string().valid('none', 'default', 'low', 'medium', 'high').optional().allow('').label('Reasoning Effort'),
+        maxThinkingTokens: Joi.number().min(1).optional().label('Maximum Thinking Tokens'),
+        // #endregion
     });
     constructor() {
         super();

package/src/helpers/Conversation.helper.ts

@@ -348,11 +348,13 @@ export class Conversation extends EventEmitter {
             //     console.log('Passthrough skiped content ', content);
             //     return;
             // }
-            const lastMessage = this._context?.messages?.[this._context?.messages?.length - 1];
-            //const skip = lastMessage?.content?.includes(passThroughtContinueMessage) && lastMessage?.__smyth_data__?.internal;
+            //const lastMessage = this._context?.messages?.[this._context?.messages?.length - 1];
+            //const skip = lastMessage?.__smyth_data__?.internal;
 
             //skip if the content is the last generated message after a passthrough content
-            //if (skip) return;
+            // if (skip) {
+            //     let s = true;
+            // }
             _content += content;
             this.emit(TLLMEvent.Content, content);
         });
@@ -494,8 +496,9 @@ export class Conversation extends EventEmitter {
                     //delete toolHeaders['x-passthrough'];
                 } else {
                     //this._context.addAssistantMessage(passThroughContent, message_id);
-                    llmMessage.content += '\n' + passThroughContent;
-                    this._context.addToolMessage(llmMessage, processedToolsData, message_id);
+
+                    //llmMessage.content += '\n' + passThroughContent;
+                    this._context.addToolMessage(llmMessage, processedToolsData, message_id, { passThrough: true });
 
                     //this._context.addAssistantMessage(passThroughContent, message_id, { passthrough: true });
                     //this should not be stored in the persistent conversation store
@@ -545,7 +548,7 @@ export class Conversation extends EventEmitter {
             return '';
         });
         _content += toolsContent;
-        let content = JSONContent(_content).tryParse();
+        //let content = JSONContent(_content).tryParse();
 
         // let streamPromise = new Promise((resolve, reject) => {
         //     eventEmitter.on('end', async () => {
@@ -573,7 +576,7 @@ export class Conversation extends EventEmitter {
             //console.log('tool content', content);
         }
 
-        return content;
+        return _content;
     }
 
     private resolveToolEndpoint(baseUrl: string, method: string, endpoint: string, params: Record<string, any>): string {

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

@@ -5,7 +5,9 @@ import { TBedrockSettings, TCustomLLMModel, TLLMCredentials, TLLMModel, TVertexA
 export async function getLLMCredentials(candidate: AccessCandidate, modelInfo: TLLMModel | TCustomLLMModel) {
     //create a credentials list that we can iterate over
     //if the credentials are not provided, we will use None as a default in order to return empty credentials
-    const credentialsList: any[] = !Array.isArray(modelInfo.credentials) ? [modelInfo.credentials] : modelInfo.credentials || [TLLMCredentials.None];
+    const credentialsList: any[] = !Array.isArray(modelInfo.credentials)
+        ? [modelInfo.credentials || TLLMCredentials.Internal]
+        : modelInfo.credentials || [TLLMCredentials.Internal];
 
     for (let credentialsMode of credentialsList) {
         if (typeof credentialsMode === 'object') {

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

@@ -23,6 +23,7 @@ import { SystemEvents } from '@sre/Core/SystemEvents';
 type ChatCompletionCreateParams = {
     model: string;
     messages: any;
+    max_completion_tokens?: number;
     max_tokens?: number;
     temperature?: number;
     stop?: string[];
@@ -30,6 +31,7 @@ type ChatCompletionCreateParams = {
     tools?: any;
     tool_choice?: string;
     stream?: boolean;
+    reasoning_effort?: 'none' | 'default' | 'low' | 'medium' | 'high';
 };
 
 export class GroqConnector extends LLMConnector {
@@ -44,113 +46,105 @@ export class GroqConnector extends LLMConnector {
     }
 
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
-        try {
-            const groq = await this.getClient(context);
-            const result = await groq.chat.completions.create(body);
-            const message = result?.choices?.[0]?.message;
-            const finishReason = result?.choices?.[0]?.finish_reason;
-            const toolCalls = message?.tool_calls;
-            const usage = result.usage;
-            this.reportUsage(usage, {
-                modelEntryName: context.modelEntryName,
-                keySource: context.isUserKey ? APIKeySource.User : APIKeySource.Smyth,
-                agentId: context.agentId,
-                teamId: context.teamId,
-            });
-
-            let toolsData: ToolData[] = [];
-            let useTool = false;
-
-            if (toolCalls) {
-                toolsData = toolCalls.map((tool, index) => ({
-                    index,
-                    id: tool.id,
-                    type: tool.type,
-                    name: tool.function.name,
-                    arguments: tool.function.arguments,
-                    role: TLLMMessageRole.Assistant,
-                }));
-                useTool = true;
-            }
+        const groq = await this.getClient(context);
+        const result = await groq.chat.completions.create(body);
+        const message = result?.choices?.[0]?.message;
+        const finishReason = result?.choices?.[0]?.finish_reason;
+        const toolCalls = message?.tool_calls;
+        const usage = result.usage;
+        this.reportUsage(usage, {
+            modelEntryName: context.modelEntryName,
+            keySource: context.isUserKey ? APIKeySource.User : APIKeySource.Smyth,
+            agentId: context.agentId,
+            teamId: context.teamId,
+        });
 
-            return {
-                content: message?.content ?? '',
-                finishReason,
-                useTool,
-                toolsData,
-                message,
-                usage,
-            };
-        } catch (error: any) {
-            throw error;
+        let toolsData: ToolData[] = [];
+        let useTool = false;
+
+        if (toolCalls) {
+            toolsData = toolCalls.map((tool, index) => ({
+                index,
+                id: tool.id,
+                type: tool.type,
+                name: tool.function.name,
+                arguments: tool.function.arguments,
+                role: TLLMMessageRole.Assistant,
+            }));
+            useTool = true;
         }
+
+        return {
+            content: message?.content ?? '',
+            finishReason,
+            useTool,
+            toolsData,
+            message,
+            usage,
+        };
     }
 
     protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
         const emitter = new EventEmitter();
         const usage_data = [];
 
-        try {
-            const groq = await this.getClient(context);
-            const stream = await groq.chat.completions.create({ ...body, stream: true, stream_options: { include_usage: true } });
-
-            let toolsData: ToolData[] = [];
-
-            (async () => {
-                for await (const chunk of stream as any) {
-                    const delta = chunk.choices[0]?.delta;
-                    const usage = chunk['x_groq']?.usage || chunk['usage'];
-
-                    if (usage) {
-                        usage_data.push(usage);
-                    }
-                    emitter.emit('data', delta);
-
-                    if (delta?.content) {
-                        emitter.emit('content', delta.content);
-                    }
-
-                    if (delta?.tool_calls) {
-                        delta.tool_calls.forEach((toolCall, index) => {
-                            if (!toolsData[index]) {
-                                toolsData[index] = {
-                                    index,
-                                    id: toolCall.id,
-                                    type: toolCall.type,
-                                    name: toolCall.function?.name,
-                                    arguments: toolCall.function?.arguments,
-                                    role: 'assistant',
-                                };
-                            } else {
-                                toolsData[index].arguments += toolCall.function?.arguments || '';
-                            }
-                        });
-                    }
+        const groq = await this.getClient(context);
+        const stream = await groq.chat.completions.create({ ...body, stream: true, stream_options: { include_usage: true } });
+
+        let toolsData: ToolData[] = [];
+
+        (async () => {
+            for await (const chunk of stream as any) {
+                const delta = chunk.choices[0]?.delta;
+                const usage = chunk['x_groq']?.usage || chunk['usage'];
+
+                if (usage) {
+                    usage_data.push(usage);
                 }
+                emitter.emit('data', delta);
 
-                if (toolsData.length > 0) {
-                    emitter.emit(TLLMEvent.ToolInfo, toolsData);
+                if (delta?.content) {
+                    emitter.emit('content', delta.content);
                 }
 
-                usage_data.forEach((usage) => {
-                    // probably we can acc them and send them as one event
-                    this.reportUsage(usage, {
-                        modelEntryName: context.modelEntryName,
-                        keySource: context.isUserKey ? APIKeySource.User : APIKeySource.Smyth,
-                        agentId: context.agentId,
-                        teamId: context.teamId,
+                if (delta?.tool_calls) {
+                    delta.tool_calls.forEach((toolCall, index) => {
+                        if (!toolsData[index]) {
+                            toolsData[index] = {
+                                index,
+                                id: toolCall.id,
+                                type: toolCall.type,
+                                name: toolCall.function?.name,
+                                arguments: toolCall.function?.arguments,
+                                role: 'assistant',
+                            };
+                        } else {
+                            toolsData[index].arguments += toolCall.function?.arguments || '';
+                        }
                     });
+                }
+            }
+
+            if (toolsData.length > 0) {
+                emitter.emit(TLLMEvent.ToolInfo, toolsData);
+            }
+
+            usage_data.forEach((usage) => {
+                // probably we can acc them and send them as one event
+                this.reportUsage(usage, {
+                    modelEntryName: context.modelEntryName,
+                    keySource: context.isUserKey ? APIKeySource.User : APIKeySource.Smyth,
+                    agentId: context.agentId,
+                    teamId: context.teamId,
                 });
+            });
 
-                setTimeout(() => {
-                    emitter.emit('end', toolsData);
-                }, 100);
-            })();
+            setTimeout(() => {
+                emitter.emit('end', toolsData);
+            }, 100);
+        })();
 
-            return emitter;
-        } catch (error: any) {
-            throw error;
-        }
+        return emitter;
     }
 
     protected async reqBodyAdapter(params: TLLMPreparedParams): Promise<ChatCompletionCreateParams> {
@@ -172,7 +166,15 @@ export class GroqConnector extends LLMConnector {
         }
         //#endregion Handle JSON response format
 
-        if (params.maxTokens !== undefined) body.max_tokens = params.maxTokens;
+        const isReasoningModel = params.useReasoning && params.capabilities?.reasoning;
+
+        if (params.maxTokens !== undefined) {
+            if (isReasoningModel) {
+                body.max_completion_tokens = params.maxTokens;
+            } else {
+                body.max_tokens = params.maxTokens;
+            }
+        }
         if (params.temperature !== undefined) body.temperature = params.temperature;
         if (params.topP !== undefined) body.top_p = params.topP;
         if (params.stopSequences?.length) body.stop = params.stopSequences;
@@ -180,6 +182,11 @@ export class GroqConnector extends LLMConnector {
         if (params.toolsConfig?.tools) body.tools = params.toolsConfig?.tools;
         if (params.toolsConfig?.tool_choice) body.tool_choice = params.toolsConfig?.tool_choice as any;
 
+        // Apply user-specified reasoning parameters
+        if (isReasoningModel) {
+            if (params.reasoningEffort !== undefined) body.reasoning_effort = params.reasoningEffort;
+        }
+
         return body;
     }
 

package/src/subsystems/LLMManager/ModelsProvider.service/ModelsProviderConnector.ts

@@ -59,6 +59,15 @@ export abstract class ModelsProviderConnector extends SecureConnector {
                     return null;
                 }
             }
+            //Workaround : non-blocking auto-refresh of team models
+            //this will force team models to refresh for the next request
+            //TODO: we need a more elegant cache invalidation mechanism, and only refresh the team models if the custom models have changed
+            setImmediate(async () => {
+                const _customModels = await this.getCustomModels(candidate);
+                teamModels = { ...teamModels, ..._customModels };
+            });
+
+            //immediatelly return the team models
             return teamModels;
         };
         loadTeamModels();

package/src/subsystems/MemoryManager/Cache.service/connectors/RedisCache.class.ts

@@ -26,27 +26,9 @@ export class RedisCache extends CacheConnector {
         let host = sentinels.length === 1 ? sentinels[0].host : null;
         let port = sentinels.length === 1 ? sentinels[0].port : null;
 
-        const redisConfig = {
-            // HEAVILY OPTIMIZED: Aggressive storm prevention parameters
-            maxRetriesPerRequest: 1, // VERY LIMITED retries (official)
-            retryDelayOnFailover: 50, // Fast failover (official)
-            connectTimeout: 3000, // SHORT timeout (official)
-            lazyConnect: false,
-            enableReadyCheck: false, // Skip ready check for speed (official)
-            commandTimeout: 2000, // VERY SHORT command timeout (official)
-            keepAlive: 10000, // Shorter keepalive - 10sec (official)
-            family: 4, // Force IPv4 (official)
-            maxLoadingTimeout: 2000, // Short loading timeout (official)
-            // Additional aggressive settings
-            enableOfflineQueue: false, // Disable offline queue (official)
-            db: 0, // Explicit DB (official)
-            stringNumbers: false, // No string conversion (official)
-        };
-
         this.redis = new IORedis({
             ...(host ? { host, port } : { sentinels, name: _settings.name || process.env.REDIS_MASTER_NAME }),
             password: _settings.password || process.env.REDIS_PASSWORD,
-            ...redisConfig,
         });
 
         this.redis.on('error', (error) => {

package/src/types/LLM.types.ts

@@ -149,6 +149,12 @@ export type TLLMParams = {
     // #endregion
 
     useReasoning?: boolean;
+    /**
+     * Controls the level of effort the model will put into reasoning
+     * For GPT-OSS models (20B, 120B): "low" | "medium" | "high"
+     * For Qwen 3 32B: "none" | "default"
+     */
+    reasoningEffort?: 'none' | 'default' | 'low' | 'medium' | 'high';
     max_output_tokens?: number;
     abortSignal?: AbortSignal;
 };