@smythos/sre 1.5.42 → 1.5.44

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,8 +31,11 @@ type ChatCompletionCreateParams = {
     tools?: any;
     tool_choice?: string;
     stream?: boolean;
+    reasoning_effort?: 'none' | 'default' | 'low' | 'medium' | 'high';
 };
 
+const MODELS_WITHOUT_REASONING_EFFORT_SUPPORT = ['deepseek-r1-distill-llama-70b'];
+
 export class GroqConnector extends LLMConnector {
     public name = 'LLM:Groq';
 
@@ -44,113 +48,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 +168,15 @@ export class GroqConnector extends LLMConnector {
         }
         //#endregion Handle JSON response format
 
-        if (params.maxTokens !== undefined) body.max_tokens = params.maxTokens;
+        const allowReasoning = params.useReasoning && params.capabilities?.reasoning;
+
+        if (params.maxTokens !== undefined) {
+            if (allowReasoning) {
+                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 +184,15 @@ 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 (
+            allowReasoning &&
+            isValidGroqReasoningEffort(params?.reasoningEffort) &&
+            !MODELS_WITHOUT_REASONING_EFFORT_SUPPORT.includes(params?.modelEntryName)
+        ) {
+            if (params.reasoningEffort !== undefined) body.reasoning_effort = params.reasoningEffort;
+        }
+
         return body;
     }
 
@@ -282,3 +295,10 @@ export class GroqConnector extends LLMConnector {
         });
     }
 }
+/**
+ * Type guard to check if a value is a valid OpenAI reasoning effort.
+ * Uses array includes for better maintainability when OpenAI adds new values.
+ */
+export function isValidGroqReasoningEffort(value: unknown): value is 'low' | 'medium' | 'high' | 'none' | 'default' {
+    return ['none', 'default', 'low', 'medium', 'high'].includes(value as string);
+}

package/src/subsystems/LLMManager/LLM.service/connectors/openai/OpenAIConnector.class.ts

@@ -173,7 +173,7 @@ export class OpenAIConnector extends LLMConnector {
         const openai = await this.getClient(context);
         const response = await openai.images.generate(body as OpenAI.Images.ImageGenerateParams);
 
-        return response;
+        return response as OpenAI.ImagesResponse;
     }
 
     protected async imageEditRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<OpenAI.ImagesResponse> {
@@ -182,7 +182,7 @@ export class OpenAIConnector extends LLMConnector {
         const openai = await this.getClient(context);
         const response = await openai.images.edit(_body);
 
-        return response;
+        return response as OpenAI.ImagesResponse;
     }
     // #endregion
 

package/src/subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/ChatCompletionsApiInterface.ts

@@ -2,17 +2,7 @@ import EventEmitter from 'events';
 import OpenAI from 'openai';
 import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-import {
-    TLLMParams,
-    TLLMPreparedParams,
-    ILLMRequestContext,
-    ToolData,
-    TLLMMessageRole,
-    APIKeySource,
-    TLLMEvent,
-    OpenAIToolDefinition,
-    LegacyToolDefinition,
-} from '@sre/types/LLM.types';
+import { TLLMParams, TLLMPreparedParams, ILLMRequestContext, ToolData, TLLMMessageRole, APIKeySource, TLLMEvent } from '@sre/types/LLM.types';
 import { OpenAIApiInterface, ToolConfig } from './OpenAIApiInterface';
 import { HandlerDependencies } from '../types';
 import { JSON_RESPONSE_INSTRUCTION, SUPPORTED_MIME_TYPES_MAP } from '@sre/constants';
@@ -23,6 +13,8 @@ import {
     MODELS_WITHOUT_JSON_RESPONSE_SUPPORT,
 } from './constants';
 
+import { isValidOpenAIReasoningEffort } from './utils';
+
 // File size limits in bytes
 const MAX_IMAGE_SIZE = 20 * 1024 * 1024; // 20MB
 const MAX_DOCUMENT_SIZE = 25 * 1024 * 1024; // 25MB
@@ -67,9 +59,6 @@ export class ChatCompletionsApiInterface extends OpenAIApiInterface {
 
     public handleStream(stream: AsyncIterable<OpenAI.ChatCompletionChunk>, context: ILLMRequestContext): EventEmitter {
         const emitter = new EventEmitter();
-        const usage_data: OpenAI.Completions.CompletionUsage[] = [];
-        const reportedUsage: any[] = [];
-        let finishReason = 'stop';
 
         // Process stream asynchronously while returning emitter immediately
         (async () => {
@@ -77,12 +66,14 @@ export class ChatCompletionsApiInterface extends OpenAIApiInterface {
 
             try {
                 // Step 1: Process the stream
-                const streamResult = await this.processStream(stream, emitter, usage_data);
+                const streamResult = await this.processStream(stream, emitter);
                 finalToolsData = streamResult.toolsData;
-                finishReason = streamResult.finishReason;
+
+                const finishReason = streamResult.finishReason || 'stop';
+                const usageData = streamResult.usageData;
 
                 // Step 2: Report usage statistics
-                this.reportUsageStatistics(usage_data, context, reportedUsage);
+                const reportedUsage = this.reportUsageStatistics(usageData, context);
 
                 // Step 3: Emit final events
                 this.emitFinalEvents(emitter, finalToolsData, reportedUsage, finishReason);
@@ -172,6 +163,18 @@ export class ChatCompletionsApiInterface extends OpenAIApiInterface {
             body.stop = params.stopSequences;
         }
 
+        // #region GPT 5 specific fields
+        const isGPT5ReasoningModels = params.modelEntryName?.includes('gpt-5') && params?.capabilities?.reasoning;
+        if (isGPT5ReasoningModels && params?.verbosity) {
+            body.verbosity = params.verbosity;
+        }
+
+        // We need to validate the `reasoningEffort` parameter for OpenAI models, since models like `qwen/qwen3-32b` and `deepseek-r1-distill-llama-70b` (available via Groq) also support this parameter but use different values, such as `none` and `default`. These values are valid in our system but not specifically for OpenAI.
+        if (isGPT5ReasoningModels && isValidOpenAIReasoningEffort(params.reasoningEffort)) {
+            body.reasoning_effort = params.reasoningEffort;
+        }
+        // #endregion GPT 5 specific fields
+
         // Handle tools configuration
         if (params?.toolsConfig?.tools && params?.toolsConfig?.tools?.length > 0) {
             body.tools = params?.toolsConfig?.tools as OpenAI.ChatCompletionTool[];
@@ -181,20 +184,13 @@ export class ChatCompletionsApiInterface extends OpenAIApiInterface {
         return body;
     }
 
-    /**
-     * Type guard to check if a tool is an OpenAI tool definition
-     */
-    private isOpenAIToolDefinition(tool: OpenAIToolDefinition | LegacyToolDefinition): tool is OpenAIToolDefinition {
-        return 'parameters' in tool;
-    }
-
     /**
      * Transform OpenAI tool definitions to ChatCompletionTool format
      */
     public transformToolsConfig(config: ToolConfig): OpenAI.ChatCompletionTool[] {
         return config.toolDefinitions.map((tool) => {
             // Handle OpenAI tool definition format
-            if (this.isOpenAIToolDefinition(tool)) {
+            if ('parameters' in tool) {
                 return {
                     type: 'function',
                     function: {
@@ -259,11 +255,11 @@ export class ChatCompletionsApiInterface extends OpenAIApiInterface {
      */
     private async processStream(
         stream: AsyncIterable<OpenAI.ChatCompletionChunk>,
-        emitter: EventEmitter,
-        usage_data: OpenAI.Completions.CompletionUsage[]
-    ): Promise<{ toolsData: ToolData[]; finishReason: string }> {
+        emitter: EventEmitter
+    ): Promise<{ toolsData: ToolData[]; finishReason: string; usageData: any[] }> {
         let toolsData: ToolData[] = [];
         let finishReason = 'stop';
+        const usageData = [];
 
         for await (const part of stream) {
             const delta = part.choices[0]?.delta;
@@ -271,7 +267,7 @@ export class ChatCompletionsApiInterface extends OpenAIApiInterface {
 
             // Collect usage statistics
             if (usage) {
-                usage_data.push(usage);
+                usageData.push(usage);
             }
 
             // Emit data event for delta
@@ -315,7 +311,7 @@ export class ChatCompletionsApiInterface extends OpenAIApiInterface {
             }
         }
 
-        return { toolsData: this.extractToolCalls(toolsData), finishReason };
+        return { toolsData: this.extractToolCalls(toolsData), finishReason, usageData };
     }
 
     /**
@@ -335,12 +331,16 @@ export class ChatCompletionsApiInterface extends OpenAIApiInterface {
     /**
      * Report usage statistics
      */
-    private reportUsageStatistics(usage_data: OpenAI.Completions.CompletionUsage[], context: ILLMRequestContext, reportedUsage: any[]): void {
+    private reportUsageStatistics(usage_data: OpenAI.Completions.CompletionUsage[], context: ILLMRequestContext): any[] {
+        const reportedUsage: any[] = [];
+
         // Report normal usage
         usage_data.forEach((usage) => {
             const reported = this.deps.reportUsage(usage, this.buildUsageContext(context));
             reportedUsage.push(reported);
         });
+
+        return reportedUsage;
     }
 
     /**

package/src/subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/ResponsesApiInterface.ts

@@ -22,12 +22,12 @@ import { OpenAIApiInterface, ToolConfig } from './OpenAIApiInterface';
 import { HandlerDependencies, TToolType } from '../types';
 import { SUPPORTED_MIME_TYPES_MAP } from '@sre/constants';
 import { MODELS_WITHOUT_TEMPERATURE_SUPPORT, SEARCH_TOOL_COSTS } from './constants';
+import { isValidOpenAIReasoningEffort } from './utils';
 
 // File size limits in bytes
 const MAX_IMAGE_SIZE = 20 * 1024 * 1024; // 20MB
 const MAX_DOCUMENT_SIZE = 25 * 1024 * 1024; // 25MB
 
-type TSearchContextSize = 'low' | 'medium' | 'high';
 type TSearchLocation = {
     type: 'approximate';
     city?: string;
@@ -75,9 +75,6 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
 
     public handleStream(stream: Stream<OpenAI.Responses.ResponseStreamEvent>, context: ILLMRequestContext): EventEmitter {
         const emitter = new EventEmitter();
-        const usage_data: any[] = [];
-        const reportedUsage: any[] = [];
-        let finishReason = 'stop';
 
         // Process stream asynchronously while returning emitter immediately
         (async () => {
@@ -85,12 +82,14 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
 
             try {
                 // Step 1: Process the stream
-                const streamResult = await this.processStream(stream, emitter, usage_data);
+                const streamResult = await this.processStream(stream, emitter);
                 finalToolsData = streamResult.toolsData;
-                finishReason = streamResult.finishReason;
+
+                const finishReason = streamResult.finishReason || 'stop';
+                const usageData = streamResult.usageData;
 
                 // Step 2: Report usage statistics
-                this.reportUsageStatistics(usage_data, context, reportedUsage);
+                const reportedUsage = this.reportUsageStatistics(usageData, context);
 
                 // Step 3: Emit final events
                 this.emitFinalEvents(emitter, finalToolsData, reportedUsage, finishReason);
@@ -107,11 +106,11 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
      */
     private async processStream(
         stream: Stream<OpenAI.Responses.ResponseStreamEvent>,
-        emitter: EventEmitter,
-        usage_data: any[]
-    ): Promise<{ toolsData: ToolData[]; finishReason: string }> {
+        emitter: EventEmitter
+    ): Promise<{ toolsData: ToolData[]; finishReason: string; usageData: any[] }> {
         let toolsData: ToolData[] = [];
         let finishReason = 'stop';
+        const usageData = [];
 
         for await (const part of stream) {
             // Handle different event types from the Responses API stream
@@ -189,12 +188,12 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
             }
 
             // Handle usage statistics from response object
-            if ('response' in part && (part as any).response?.usage) {
-                usage_data.push((part as any).response.usage);
+            if (part?.type === 'response.completed' && part?.response?.usage) {
+                usageData.push(part.response.usage);
             }
         }
 
-        return { toolsData: this.extractToolCalls(toolsData), finishReason };
+        return { toolsData: this.extractToolCalls(toolsData), finishReason, usageData };
     }
 
     /**
@@ -214,7 +213,9 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
     /**
      * Report usage statistics
      */
-    private reportUsageStatistics(usage_data: any[], context: ILLMRequestContext, reportedUsage: any[]): void {
+    private reportUsageStatistics(usage_data: any[], context: ILLMRequestContext): any[] {
+        const reportedUsage: any[] = [];
+
         // Report normal usage
         usage_data.forEach((usage) => {
             // Convert ResponseUsage to CompletionUsage format for compatibility
@@ -234,6 +235,8 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
             const reported = this.deps.reportUsage(searchUsage, this.buildUsageContext(context));
             reportedUsage.push(reported);
         }
+
+        return reportedUsage;
     }
 
     /**
@@ -310,6 +313,19 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
             body.top_p = params.topP;
         }
 
+        // #region GPT 5 specific fields
+
+        const isGPT5ReasoningModels = params.modelEntryName?.includes('gpt-5') && params?.capabilities?.reasoning;
+        if (isGPT5ReasoningModels && params?.verbosity) {
+            body.text = { verbosity: params.verbosity };
+        }
+
+        // We need to validate the `reasoningEffort` parameter for OpenAI models, since models like `qwen/qwen3-32b` and `deepseek-r1-distill-llama-70b` (available via Groq) also support this parameter but use different values, such as `none` and `default`. These values are valid in our system but not specifically for OpenAI.
+        if (isGPT5ReasoningModels && isValidOpenAIReasoningEffort(params.reasoningEffort)) {
+            body.reasoning = { effort: params.reasoningEffort };
+        }
+        // #endregion GPT 5 specific fields
+
         let tools: OpenAI.Responses.Tool[] = [];
 
         if (params?.toolsConfig?.tools && params?.toolsConfig?.tools?.length > 0) {
@@ -333,20 +349,13 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
         return body;
     }
 
-    /**
-     * Type guard to check if a tool is an OpenAI tool definition
-     */
-    private isOpenAIToolDefinition(tool: OpenAIToolDefinition | LegacyToolDefinition): tool is OpenAIToolDefinition {
-        return 'parameters' in tool;
-    }
-
     /**
      * Transform OpenAI tool definitions to Responses.Tool format
      */
     public transformToolsConfig(config: ToolConfig): OpenAI.Responses.Tool[] {
         return config.toolDefinitions.map((tool) => {
             // Handle OpenAI tool definition format
-            if (this.isOpenAIToolDefinition(tool)) {
+            if ('parameters' in tool) {
                 return {
                     type: 'function' as const,
                     name: tool.name,

package/src/subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/utils.ts

@@ -0,0 +1,11 @@
+import OpenAI from 'openai';
+
+// * We may move some OpenAI Connector–related utility functions here in the future.
+
+/**
+ * Type guard to check if a value is a valid OpenAI reasoning effort.
+ * Uses array includes for better maintainability when OpenAI adds new values.
+ */
+export function isValidOpenAIReasoningEffort(value: unknown): value is OpenAI.Responses.ResponseCreateParams['reasoning']['effort'] {
+    return ['minimal', 'low', 'medium', 'high'].includes(value as string);
+}

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

@@ -45,6 +45,9 @@ export type ILLMConnectorCredentials = BasicCredentials | BedrockCredentials | V
 export type TOpenAIResponseToolChoice = OpenAI.Responses.ToolChoiceOptions | OpenAI.Responses.ToolChoiceTypes | OpenAI.Responses.ToolChoiceFunction;
 export type TLLMToolChoice = OpenAI.ChatCompletionToolChoiceOption;
 
+// Local alias to the upstream OpenAI reasoning effort union type
+export type OpenAIReasoningEffort = NonNullable<OpenAI.Responses.ResponseCreateParams['reasoning']>['effort'];
+
 export type TOpenAIToolsInfo = {
     webSearch: {
         enabled: boolean;
@@ -149,7 +152,14 @@ 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' | OpenAIReasoningEffort;
     max_output_tokens?: number;
+    verbosity?: OpenAI.Responses.ResponseCreateParams['text']['verbosity'];
     abortSignal?: AbortSignal;
 };