@smythos/sre 1.6.0 → 1.6.8

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

@@ -1,100 +1,100 @@
-import EventEmitter from 'events';
-import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
-import { TLLMParams, ILLMRequestContext, TLLMToolChoice, OpenAIToolDefinition, LegacyToolDefinition, LLMModelInfo } from '@sre/types/LLM.types';
-import { HandlerDependencies } from '../types';
-
-/**
- * OpenAI-specific tool configuration interface
- * Only deals with OpenAI tool definitions for clean separation
- */
-export interface ToolConfig {
-    type?: string;
-    toolDefinitions: (OpenAIToolDefinition | LegacyToolDefinition)[];
-    toolChoice?: TLLMToolChoice;
-    modelInfo?: LLMModelInfo | null;
-}
-
-/**
- * Abstract base class for OpenAI API interfaces
- * Defines the contract that all OpenAI API implementations must follow
- *
- * This follows the Strategy pattern - each API interface (responses, chat.completions)
- * implements this interface with its own specific behavior
- */
-export abstract class OpenAIApiInterface {
-    protected context: ILLMRequestContext;
-
-    constructor(context: ILLMRequestContext) {
-        this.context = context;
-    }
-
-    /**
-     * Create a regular (non-streaming) request for this API interface
-     * @param body - The request body prepared for this API
-     * @param context - The request context
-     */
-    abstract createRequest(body: any, context: ILLMRequestContext): Promise<any>;
-
-    /**
-     * Create a stream for this API interface
-     * @param body - The request body prepared for this API
-     * @param context - The request context
-     */
-    abstract createStream(body: any, context: ILLMRequestContext): Promise<any>;
-
-    /**
-     * Handle the stream response from this API interface
-     * @param stream - The stream returned from createStream
-     * @param context - The request context
-     */
-    abstract handleStream(stream: any, context: ILLMRequestContext): EventEmitter;
-
-    /**
-     * Prepare the request body for this API interface
-     * @param params - The LLM parameters
-     */
-    abstract prepareRequestBody(params: TLLMParams): Promise<any>;
-
-    /**
-     * Transform tools configuration for this API interface
-     * @param config - The tool configuration
-     */
-    abstract transformToolsConfig(config: ToolConfig): any[];
-
-    /**
-     * Handle file attachments for this API interface
-     * @param files - The files to attach
-     * @param agentId - The agent ID
-     * @param messages - The messages to attach files to
-     */
-    abstract handleFileAttachments(files: BinaryInput[], agentId: string, messages: any[]): Promise<any[]>;
-
-    /**
-     * Get the API interface name
-     */
-    abstract getInterfaceName(): string;
-
-    /**
-     * Validate if this interface supports the given parameters
-     * @param params - The parameters to validate
-     */
-    abstract validateParameters(params: TLLMParams): boolean;
-}
-
-/**
- * Factory interface for creating OpenAI API interfaces
- */
-export interface OpenAIApiInterfaceFactory {
-    /**
-     * Create an API interface instance for the specified type
-     * @param interfaceType - The type of interface to create
-     * @param context - The context for the interface
-     * @param deps - The handler dependencies for the interface
-     */
-    createInterface(interfaceType: string, context: ILLMRequestContext, deps: HandlerDependencies): OpenAIApiInterface;
-
-    /**
-     * Get supported interface types
-     */
-    getSupportedInterfaces(): string[];
-}
+import EventEmitter from 'events';
+import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
+import { TLLMParams, ILLMRequestContext, TLLMToolChoice, OpenAIToolDefinition, LegacyToolDefinition, LLMModelInfo } from '@sre/types/LLM.types';
+import { HandlerDependencies } from '../types';
+
+/**
+ * OpenAI-specific tool configuration interface
+ * Only deals with OpenAI tool definitions for clean separation
+ */
+export interface ToolConfig {
+    type?: string;
+    toolDefinitions: (OpenAIToolDefinition | LegacyToolDefinition)[];
+    toolChoice?: TLLMToolChoice;
+    modelInfo?: LLMModelInfo | null;
+}
+
+/**
+ * Abstract base class for OpenAI API interfaces
+ * Defines the contract that all OpenAI API implementations must follow
+ *
+ * This follows the Strategy pattern - each API interface (responses, chat.completions)
+ * implements this interface with its own specific behavior
+ */
+export abstract class OpenAIApiInterface {
+    protected context: ILLMRequestContext;
+
+    constructor(context: ILLMRequestContext) {
+        this.context = context;
+    }
+
+    /**
+     * Create a regular (non-streaming) request for this API interface
+     * @param body - The request body prepared for this API
+     * @param context - The request context
+     */
+    abstract createRequest(body: any, context: ILLMRequestContext): Promise<any>;
+
+    /**
+     * Create a stream for this API interface
+     * @param body - The request body prepared for this API
+     * @param context - The request context
+     */
+    abstract createStream(body: any, context: ILLMRequestContext): Promise<any>;
+
+    /**
+     * Handle the stream response from this API interface
+     * @param stream - The stream returned from createStream
+     * @param context - The request context
+     */
+    abstract handleStream(stream: any, context: ILLMRequestContext): EventEmitter;
+
+    /**
+     * Prepare the request body for this API interface
+     * @param params - The LLM parameters
+     */
+    abstract prepareRequestBody(params: TLLMParams): Promise<any>;
+
+    /**
+     * Transform tools configuration for this API interface
+     * @param config - The tool configuration
+     */
+    abstract transformToolsConfig(config: ToolConfig): any[];
+
+    /**
+     * Handle file attachments for this API interface
+     * @param files - The files to attach
+     * @param agentId - The agent ID
+     * @param messages - The messages to attach files to
+     */
+    abstract handleFileAttachments(files: BinaryInput[], agentId: string, messages: any[]): Promise<any[]>;
+
+    /**
+     * Get the API interface name
+     */
+    abstract getInterfaceName(): string;
+
+    /**
+     * Validate if this interface supports the given parameters
+     * @param params - The parameters to validate
+     */
+    abstract validateParameters(params: TLLMParams): boolean;
+}
+
+/**
+ * Factory interface for creating OpenAI API interfaces
+ */
+export interface OpenAIApiInterfaceFactory {
+    /**
+     * Create an API interface instance for the specified type
+     * @param interfaceType - The type of interface to create
+     * @param context - The context for the interface
+     * @param deps - The handler dependencies for the interface
+     */
+    createInterface(interfaceType: string, context: ILLMRequestContext, deps: HandlerDependencies): OpenAIApiInterface;
+
+    /**
+     * Get supported interface types
+     */
+    getSupportedInterfaces(): string[];
+}

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

@@ -1,81 +1,81 @@
-import { OpenAIApiInterface, OpenAIApiInterfaceFactory as IOpenAIApiInterfaceFactory } from './OpenAIApiInterface';
-import { ResponsesApiInterface } from './ResponsesApiInterface';
-import { ChatCompletionsApiInterface } from './ChatCompletionsApiInterface';
-import { HandlerDependencies } from '../types';
-import { ILLMRequestContext } from '@sre/types/LLM.types';
-
-/**
- * Factory for creating OpenAI API interfaces
- * Implements the Factory pattern to provide clean abstraction for different OpenAI API types
- * Each API interface now handles its own streaming functionality
- *
- * Usage:
- * ```typescript
- * const factory = new OpenAIApiInterfaceFactory();
- * const apiInterface = factory.createInterface('responses', context, deps);
- * ```
- */
-export class OpenAIApiInterfaceFactory implements IOpenAIApiInterfaceFactory {
-    constructor() {
-        // No dependencies needed at factory level anymore
-    }
-
-    /**
-     * Create an API interface instance for the specified type
-     * @param interfaceType - The type of interface to create ('responses', 'chat.completions')
-     * @param context - The context for the interface
-     * @param deps - The handler dependencies for the interface
-     * @returns The appropriate OpenAI API interface instance
-     */
-    createInterface(interfaceType: string, context: ILLMRequestContext, deps: HandlerDependencies): OpenAIApiInterface {
-        if (!context || !deps) {
-            throw new Error('Context and dependencies (getClient(), reportUsage()) are required to create an interface');
-        }
-
-        switch (interfaceType) {
-            case 'responses':
-                return new ResponsesApiInterface(context, deps);
-            case 'chat.completions':
-                return new ChatCompletionsApiInterface(context, deps);
-            default:
-                throw new Error(
-                    `Unsupported OpenAI API interface type: ${interfaceType}. Supported types: ${this.getSupportedInterfaces().join(', ')}`
-                );
-        }
-    }
-
-    /**
-     * Get list of supported interface types
-     * @returns Array of supported interface type strings
-     */
-    getSupportedInterfaces(): string[] {
-        return ['responses', 'chat.completions'];
-    }
-
-    /**
-     * Check if an interface type is supported
-     * @param interfaceType - The interface type to check
-     * @returns True if supported, false otherwise
-     */
-    isInterfaceSupported(interfaceType: string): boolean {
-        return this.getSupportedInterfaces().includes(interfaceType);
-    }
-
-    /**
-     * Get the default interface type
-     * @returns The default interface type string
-     */
-    getDefaultInterfaceType(): string {
-        return 'chat.completions';
-    }
-
-    /**
-     * Get interface type based on model information
-     * @param modelInfo - Model information object
-     * @returns The appropriate interface type for the model
-     */
-    getInterfaceTypeFromModelInfo(modelInfo?: { interface?: string } | unknown): string {
-        const info = modelInfo as { interface?: string } | undefined;
-        return info?.interface || this.getDefaultInterfaceType();
-    }
-}
+import { OpenAIApiInterface, OpenAIApiInterfaceFactory as IOpenAIApiInterfaceFactory } from './OpenAIApiInterface';
+import { ResponsesApiInterface } from './ResponsesApiInterface';
+import { ChatCompletionsApiInterface } from './ChatCompletionsApiInterface';
+import { HandlerDependencies } from '../types';
+import { ILLMRequestContext } from '@sre/types/LLM.types';
+
+/**
+ * Factory for creating OpenAI API interfaces
+ * Implements the Factory pattern to provide clean abstraction for different OpenAI API types
+ * Each API interface now handles its own streaming functionality
+ *
+ * Usage:
+ * ```typescript
+ * const factory = new OpenAIApiInterfaceFactory();
+ * const apiInterface = factory.createInterface('responses', context, deps);
+ * ```
+ */
+export class OpenAIApiInterfaceFactory implements IOpenAIApiInterfaceFactory {
+    constructor() {
+        // No dependencies needed at factory level anymore
+    }
+
+    /**
+     * Create an API interface instance for the specified type
+     * @param interfaceType - The type of interface to create ('responses', 'chat.completions')
+     * @param context - The context for the interface
+     * @param deps - The handler dependencies for the interface
+     * @returns The appropriate OpenAI API interface instance
+     */
+    createInterface(interfaceType: string, context: ILLMRequestContext, deps: HandlerDependencies): OpenAIApiInterface {
+        if (!context || !deps) {
+            throw new Error('Context and dependencies (getClient(), reportUsage()) are required to create an interface');
+        }
+
+        switch (interfaceType) {
+            case 'responses':
+                return new ResponsesApiInterface(context, deps);
+            case 'chat.completions':
+                return new ChatCompletionsApiInterface(context, deps);
+            default:
+                throw new Error(
+                    `Unsupported OpenAI API interface type: ${interfaceType}. Supported types: ${this.getSupportedInterfaces().join(', ')}`
+                );
+        }
+    }
+
+    /**
+     * Get list of supported interface types
+     * @returns Array of supported interface type strings
+     */
+    getSupportedInterfaces(): string[] {
+        return ['responses', 'chat.completions'];
+    }
+
+    /**
+     * Check if an interface type is supported
+     * @param interfaceType - The interface type to check
+     * @returns True if supported, false otherwise
+     */
+    isInterfaceSupported(interfaceType: string): boolean {
+        return this.getSupportedInterfaces().includes(interfaceType);
+    }
+
+    /**
+     * Get the default interface type
+     * @returns The default interface type string
+     */
+    getDefaultInterfaceType(): string {
+        return 'chat.completions';
+    }
+
+    /**
+     * Get interface type based on model information
+     * @param modelInfo - Model information object
+     * @returns The appropriate interface type for the model
+     */
+    getInterfaceTypeFromModelInfo(modelInfo?: { interface?: string } | unknown): string {
+        const info = modelInfo as { interface?: string } | undefined;
+        return info?.interface || this.getDefaultInterfaceType();
+    }
+}