@smythos/sre 1.5.43 → 1.5.44

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/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;
@@ -154,8 +157,9 @@ export type TLLMParams = {
      * For GPT-OSS models (20B, 120B): "low" | "medium" | "high"
      * For Qwen 3 32B: "none" | "default"
      */
-    reasoningEffort?: 'none' | 'default' | 'low' | 'medium' | 'high';
+    reasoningEffort?: 'none' | 'default' | OpenAIReasoningEffort;
     max_output_tokens?: number;
+    verbosity?: OpenAI.Responses.ResponseCreateParams['text']['verbosity'];
     abortSignal?: AbortSignal;
 };