@smythos/sre 1.5.37 → 1.5.39

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

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

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

@@ -37,6 +37,7 @@ import { ServerlessCode } from './ServerlessCode.class';
 import { ImageGenerator } from './ImageGenerator.class';
 import { MCPClient } from './MCPClient.class';
 import { OpenAPI } from './OpenAPI.class';
+import { ECMASandbox } from './ECMASandbox.class';
 export declare const ComponentInstances: {
     Component: Component;
     Note: Component;
@@ -81,4 +82,5 @@ export declare const ComponentInstances: {
     ImageGenerator: ImageGenerator;
     MCPClient: MCPClient;
     OpenAPI: OpenAPI;
+    ECMASandbox: ECMASandbox;
 };

package/dist/types/Core/ConnectorsService.d.ts

@@ -14,6 +14,7 @@ import { ManagedVaultConnector } from '@sre/Security/ManagedVault.service/Manage
 import { LogConnector } from '@sre/IO/Log.service/LogConnector';
 import { ComponentConnector } from '@sre/AgentManager/Component.service/ComponentConnector';
 import { ModelsProviderConnector } from '@sre/LLMManager/ModelsProvider.service/ModelsProviderConnector';
+import { CodeConnector } from '@sre/ComputeManager/Code.service/CodeConnector';
 export declare class ConnectorService {
     static Connectors: {};
     static ConnectorInstances: any;
@@ -56,7 +57,7 @@ export declare class ConnectorService {
     static getModelsProviderConnector(name?: string): ModelsProviderConnector;
     static hasInstance(connectorType: TConnectorService, connectorName?: string): any;
     static getRouterConnector(name?: string): RouterConnector;
-    static getCodeConnector(name?: string): RouterConnector;
+    static getCodeConnector(name?: string): CodeConnector;
 }
 export declare abstract class ConnectorServiceProvider {
     abstract register(): any;

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

@@ -0,0 +1,3 @@
+import 'ses';
+export declare function runJs(code: string): any;
+export declare function generateExecutableCode(code: string, parameters: string[], inputs: Record<string, any>): string;

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

@@ -19,4 +19,4 @@ export declare class LogHelper extends EventEmitter {
     error(...args: any[]): void;
     close(): void;
 }
-export declare function Logger(module: string, withMemoryStore?: boolean): LogHelper;
+export declare function Logger(module: string | any, withMemoryStore?: boolean): LogHelper;

package/dist/types/index.d.ts

@@ -50,6 +50,7 @@ export * from './Core/SystemEvents';
 export * from './helpers/AWSLambdaCode.helper';
 export * from './helpers/BinaryInput.helper';
 export * from './helpers/Conversation.helper';
+export * from './helpers/ECMASandbox.helper';
 export * from './helpers/JsonContent.helper';
 export * from './helpers/LocalCache.helper';
 export * from './helpers/Log.helper';
@@ -162,7 +163,6 @@ export * from './subsystems/LLMManager/LLM.service/connectors/Bedrock.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/Echo.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/GoogleAI.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/Groq.class';
-export * from './subsystems/LLMManager/LLM.service/connectors/OpenAI.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/Perplexity.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/VertexAI.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/xAI.class';
@@ -180,3 +180,6 @@ export * from './subsystems/Security/Vault.service/connectors/HashicorpVault.cla
 export * from './subsystems/Security/Vault.service/connectors/JSONFileVault.class';
 export * from './subsystems/Security/Vault.service/connectors/NullVault.class';
 export * from './subsystems/Security/Vault.service/connectors/SecretsManager.class';
+export * from './subsystems/LLMManager/LLM.service/connectors/openai/OpenAIConnector.class';
+export * from './subsystems/LLMManager/LLM.service/connectors/openai/types';
+export * from './subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/constants';

package/dist/types/subsystems/ComputeManager/Code.service/connectors/ECMASandbox.class.d.ts

@@ -0,0 +1,19 @@
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { CodeConfig, CodePreparationResult, CodeConnector, CodeInput, CodeDeployment, CodeExecutionResult } from '../CodeConnector';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+export declare class ECMASandbox extends CodeConnector {
+    name: string;
+    private sandboxUrl;
+    constructor(config: {
+        sandboxUrl: string;
+    });
+    prepare(acRequest: AccessRequest, codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodePreparationResult>;
+    deploy(acRequest: AccessRequest, codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment>;
+    execute(acRequest: AccessRequest, codeUID: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult>;
+    executeDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult>;
+    listDeployments(acRequest: AccessRequest, codeUID: string, config: CodeConfig): Promise<CodeDeployment[]>;
+    getDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string, config: CodeConfig): Promise<CodeDeployment | null>;
+    deleteDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string): Promise<void>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+}

package/dist/types/subsystems/LLMManager/LLM.helper.d.ts

@@ -49,13 +49,24 @@ export declare class LLMHelper {
      * 2. Calculating tokens for each image in the prompt based on its dimensions.
      * 3. Summing up text and image tokens to get the total token count.
      *
+     * IMPORTANT: This returns the base token calculation for rate limiting and quota management.
+     * The actual tokens charged by OpenAI may differ significantly:
+     * - GPT-4o: Uses base calculation (matches this result)
+     * - GPT-4o-mini: Intentionally inflates image tokens by ~33x (e.g., 431 → 14,180 tokens)
+     * - GPT-4.1 series: Uses different patch-based calculations with various multipliers
+     *
+     * For consistent user limits regardless of model choice, use this base calculation.
+     * For billing estimates, refer to OpenAI's pricing calculator or API response.
+     *
+     * @see https://platform.openai.com/docs/guides/images-vision?api-mode=responses#calculating-costs
+     *
      * @example
      * const prompt = [
      *   { type: 'text', text: 'Describe this image:' },
      *   { type: 'image_url', image_url: { url: 'https://example.com/image.jpg' } }
      * ];
      * const tokenCount = await countVisionPromptTokens(prompt);
-     * console.log(tokenCount); // e.g., 150
+     * console.log(tokenCount); // e.g., 150 (base calculation for rate limiting)
      */
     static countVisionPromptTokens(prompt: any): Promise<number>;
     /**
@@ -88,15 +99,15 @@ export declare class LLMHelper {
      * @returns {number} The number of tokens required to process the image.
      *
      * @description
-     * This method estimates the token count for image processing based on the image dimensions and detail mode.
-     * It uses a tiling approach to calculate the token count, scaling the image if necessary.
-     *
-     * - If detailMode is 'low', it returns a fixed token count of 85.
-     * - For other modes, it calculates based on the image dimensions:
-     *   - Scales down images larger than 2048 pixels in any dimension.
-     *   - Adjusts the scaled dimension to fit within a 768x1024 aspect ratio.
-     *   - Calculates the number of 512x512 tiles needed to cover the image.
-     *   - Returns the total token count based on the number of tiles.
+     * This method calculates the token count for image processing based on OpenAI's official documentation:
+     *
+     * For 'low' detail mode: Returns 85 tokens regardless of image size.
+     *
+     * For 'high' detail mode (default):
+     * 1. Scale image to fit within 2048x2048 square (maintaining aspect ratio)
+     * 2. Scale image so shortest side is 768px (if both dimensions > 768px)
+     * 3. Calculate number of 512x512 tiles needed
+     * 4. Return 85 + (170 * number_of_tiles)
      *
      * @example
      * const tokenCount = countImageTokens(1024, 768);

package/dist/types/subsystems/LLMManager/LLM.service/LLMConnector.d.ts

@@ -1,6 +1,6 @@
 import { Connector } from '@sre/Core/Connector.class';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-import { TLLMConnectorParams, TLLMMessageBlock, TLLMToolResultMessageBlock, ToolData, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMRequestBody } from '@sre/types/LLM.types';
+import type { TLLMConnectorParams, TLLMMessageBlock, TLLMToolResultMessageBlock, ToolData, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMRequestBody } from '@sre/types/LLM.types';
 import EventEmitter from 'events';
 import { Readable } from 'stream';
 export interface ILLMConnectorRequest {
@@ -11,8 +11,6 @@ export interface ILLMConnectorRequest {
 }
 export declare class LLMStream extends Readable {
     private dataQueue;
-    private toolsData;
-    private hasData;
     isReading: boolean;
     constructor(options?: any);
     _read(size: any): void;
@@ -23,7 +21,6 @@ export declare abstract class LLMConnector extends Connector {
     abstract name: string;
     protected abstract request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
     protected abstract streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
-    protected abstract webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
     protected abstract reqBodyAdapter(params: TLLMConnectorParams): Promise<TLLMRequestBody>;
     protected abstract reportUsage(usage: any, metadata: {
         modelEntryName: string;
@@ -37,10 +34,11 @@ export declare abstract class LLMConnector extends Connector {
     requester(candidate: AccessCandidate): ILLMConnectorRequest;
     enhancePrompt(prompt: string, config: any): string;
     postProcess(response: string): any;
-    formatToolsConfig({ type, toolDefinitions, toolChoice }: {
+    formatToolsConfig({ type, toolDefinitions, toolChoice, modelInfo }: {
         type?: string;
         toolDefinitions: any;
         toolChoice?: string;
+        modelInfo?: any;
     }): void;
     transformToolMessageBlocks({ messageBlock, toolsData, }: {
         messageBlock: TLLMMessageBlock;
@@ -48,6 +46,8 @@ export declare abstract class LLMConnector extends Connector {
     }): TLLMToolResultMessageBlock[];
     getConsistentMessages(messages: TLLMMessageBlock[]): TLLMMessageBlock[];
     private prepareParams;
+    private prepareOpenAIToolsInfo;
+    private prepareXAIToolsInfo;
     private formatParamValues;
     /**
      * Retrieves the team ID associated with the given access candidate

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

@@ -1,6 +1,6 @@
 import EventEmitter from 'events';
 import Anthropic from '@anthropic-ai/sdk';
-import { TLLMParams, ToolData, TLLMMessageBlock, TLLMToolResultMessageBlock, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TAnthropicRequestBody } from '@sre/types/LLM.types';
+import { ToolData, TLLMMessageBlock, TLLMToolResultMessageBlock, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TAnthropicRequestBody, TLLMPreparedParams } from '@sre/types/LLM.types';
 import { LLMConnector } from '../LLMConnector';
 export declare class AnthropicConnector extends LLMConnector {
     name: string;
@@ -8,8 +8,7 @@ export declare class AnthropicConnector extends LLMConnector {
     private getClient;
     protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
     protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
-    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
-    protected reqBodyAdapter(params: TLLMParams): Promise<TAnthropicRequestBody>;
+    protected reqBodyAdapter(params: TLLMPreparedParams): Promise<TAnthropicRequestBody>;
     protected reportUsage(usage: Anthropic.Messages.Usage & {
         cache_creation_input_tokens?: number;
         cache_read_input_tokens?: number;

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

@@ -1,14 +1,13 @@
 import { ConverseCommandInput, TokenUsage } from '@aws-sdk/client-bedrock-runtime';
 import EventEmitter from 'events';
-import { TLLMParams, ToolData, TLLMMessageBlock, TLLMToolResultMessageBlock, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse } from '@sre/types/LLM.types';
+import { ToolData, TLLMMessageBlock, TLLMToolResultMessageBlock, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMPreparedParams } from '@sre/types/LLM.types';
 import { LLMConnector } from '../LLMConnector';
 export declare class BedrockConnector extends LLMConnector {
     name: string;
     private getClient;
     protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
     protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
-    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
-    protected reqBodyAdapter(params: TLLMParams): Promise<ConverseCommandInput>;
+    protected reqBodyAdapter(params: TLLMPreparedParams): Promise<ConverseCommandInput>;
     protected reportUsage(usage: TokenUsage & {
         cacheReadInputTokenCount: number;
         cacheWriteInputTokenCount: number;

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

@@ -1,12 +1,11 @@
 import { LLMConnector } from '../LLMConnector';
 import EventEmitter from 'events';
-import { APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMParams } from '@sre/types/LLM.types';
+import { APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMPreparedParams } from '@sre/types/LLM.types';
 export declare class EchoConnector extends LLMConnector {
     name: string;
     protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
     protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
-    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
-    protected reqBodyAdapter(params: TLLMParams): Promise<any>;
+    protected reqBodyAdapter(params: TLLMPreparedParams): Promise<any>;
     enhancePrompt(prompt: string, config: any): string;
     postProcess(response: any): any;
     protected reportUsage(usage: any, metadata: {

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

@@ -1,6 +1,6 @@
 import EventEmitter from 'events';
 import { UsageMetadata } from '@google/generative-ai';
-import { TLLMMessageBlock, ToolData, TLLMToolResultMessageBlock, APIKeySource, TLLMParams, ILLMRequestFuncParams, TLLMChatResponse, TGoogleAIRequestBody } from '@sre/types/LLM.types';
+import { TLLMMessageBlock, ToolData, TLLMToolResultMessageBlock, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TGoogleAIRequestBody, TLLMPreparedParams } from '@sre/types/LLM.types';
 import { LLMConnector } from '../LLMConnector';
 type UsageMetadataWithThoughtsToken = UsageMetadata & {
     thoughtsTokenCount: number;
@@ -11,10 +11,9 @@ export declare class GoogleAIConnector extends LLMConnector {
     private getClient;
     protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
     protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
-    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<any>;
     protected imageGenRequest({ body, context }: ILLMRequestFuncParams): Promise<any>;
     protected imageEditRequest({ body, context }: ILLMRequestFuncParams): Promise<any>;
-    protected reqBodyAdapter(params: TLLMParams): Promise<TGoogleAIRequestBody>;
+    protected reqBodyAdapter(params: TLLMPreparedParams): Promise<TGoogleAIRequestBody>;
     protected reportUsage(usage: UsageMetadataWithThoughtsToken, metadata: {
         modelEntryName: string;
         keySource: APIKeySource;

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

@@ -1,6 +1,6 @@
 import Groq from 'groq-sdk';
 import EventEmitter from 'events';
-import { TLLMMessageBlock, ToolData, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMParams, TLLMToolResultMessageBlock } from '@sre/types/LLM.types';
+import { TLLMMessageBlock, ToolData, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMPreparedParams, TLLMToolResultMessageBlock } from '@sre/types/LLM.types';
 import { LLMConnector } from '../LLMConnector';
 type ChatCompletionCreateParams = {
     model: string;
@@ -18,8 +18,7 @@ export declare class GroqConnector extends LLMConnector {
     private getClient;
     protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
     protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
-    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
-    protected reqBodyAdapter(params: TLLMParams): Promise<ChatCompletionCreateParams>;
+    protected reqBodyAdapter(params: TLLMPreparedParams): Promise<ChatCompletionCreateParams>;
     protected reportUsage(usage: Groq.Completions.CompletionUsage & {
         prompt_tokens_details?: {
             cached_tokens?: number;

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

@@ -1,5 +1,5 @@
 import EventEmitter from 'events';
-import { TLLMParams, ToolData, TLLMMessageBlock, TLLMToolResultMessageBlock, TLLMMessageRole, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse } from '@sre/types/LLM.types';
+import { ToolData, TLLMMessageBlock, TLLMToolResultMessageBlock, TLLMMessageRole, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMPreparedParams } from '@sre/types/LLM.types';
 import { LLMConnector } from '../LLMConnector';
 type ChatCompletionParams = {
     model: string;
@@ -28,8 +28,7 @@ export declare class PerplexityConnector extends LLMConnector {
     private getClient;
     protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
     protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
-    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
-    protected reqBodyAdapter(params: TLLMParams): Promise<ChatCompletionParams>;
+    protected reqBodyAdapter(params: TLLMPreparedParams): Promise<ChatCompletionParams>;
     protected reportUsage(usage: TUsage, metadata: {
         modelEntryName: string;
         keySource: APIKeySource;
@@ -65,7 +64,7 @@ export declare class PerplexityConnector extends LLMConnector {
         role: TLLMMessageRole;
         content?: string | {
             text: string;
-        }[] | Array<import("@anthropic-ai/sdk/resources").TextBlockParam | import("@anthropic-ai/sdk/resources").ImageBlockParam | import("@anthropic-ai/sdk/resources").ToolUseBlockParam | import("@anthropic-ai/sdk/resources").ToolResultBlockParam>;
+        }[] | Array<import("@anthropic-ai/sdk/resources/messages").TextBlockParam | import("@anthropic-ai/sdk/resources/messages").ImageBlockParam | import("@anthropic-ai/sdk/resources/messages").ToolUseBlockParam | import("@anthropic-ai/sdk/resources/messages").ToolResultBlockParam>;
         parts?: {
             text?: string;
             functionCall?: {

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

@@ -1,14 +1,13 @@
 import { type UsageMetadata } from '@google-cloud/vertexai';
 import EventEmitter from 'events';
-import { TLLMParams, APIKeySource, ILLMRequestFuncParams, TGoogleAIRequestBody } from '@sre/types/LLM.types';
+import { APIKeySource, ILLMRequestFuncParams, TGoogleAIRequestBody, TLLMPreparedParams, TLLMMessageBlock, ToolData, TLLMToolResultMessageBlock, TLLMMessageRole } 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 streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
-    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
-    protected reqBodyAdapter(params: TLLMParams): Promise<TGoogleAIRequestBody>;
+    protected reqBodyAdapter(params: TLLMPreparedParams): Promise<TGoogleAIRequestBody>;
     protected reportUsage(usage: UsageMetadata & {
         cachedContentTokenCount?: number;
     }, metadata: {
@@ -26,13 +25,22 @@ export declare class VertexAIConnector extends LLMConnector {
         agentId: string;
         teamId: string;
     };
-    formatToolsConfig({ type, toolDefinitions, toolChoice }: {
-        type?: string;
+    private sanitizeFunctionName;
+    formatToolsConfig({ toolDefinitions, toolChoice }: {
         toolDefinitions: any;
         toolChoice?: string;
-    }): void;
+    }): {
+        tools: any;
+        toolChoice: {
+            type: string;
+        };
+    };
+    transformToolMessageBlocks({ messageBlock, toolsData, }: {
+        messageBlock: TLLMMessageBlock;
+        toolsData: ToolData[];
+    }): TLLMToolResultMessageBlock[];
     getConsistentMessages(messages: any): {
-        role: import("@sre/types/LLM.types").TLLMMessageRole;
+        role: TLLMMessageRole;
         parts: any[];
     }[];
 }

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

@@ -0,0 +1,95 @@
+import EventEmitter from 'events';
+import OpenAI from 'openai';
+import { ToolData, TLLMMessageBlock, TLLMToolResultMessageBlock, TLLMMessageRole, APIKeySource, ILLMRequestFuncParams, TOpenAIRequestBody, TLLMChatResponse, ILLMRequestContext, TLLMPreparedParams } from '@sre/types/LLM.types';
+import { LLMConnector } from '../../LLMConnector';
+export declare class OpenAIConnector extends LLMConnector {
+    name: string;
+    private interfaceFactory;
+    constructor();
+    /**
+     * Get the appropriate API interface for the given interface type and context
+     */
+    private getApiInterface;
+    /**
+     * Determine the appropriate interface type based on context and capabilities
+     */
+    private getInterfaceType;
+    protected getClient(params: ILLMRequestContext): Promise<OpenAI>;
+    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected imageGenRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<OpenAI.ImagesResponse>;
+    protected imageEditRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<OpenAI.ImagesResponse>;
+    formatToolsConfig({ type, toolDefinitions, toolChoice, modelInfo }: {
+        type?: string;
+        toolDefinitions: any;
+        toolChoice?: string;
+        modelInfo?: any;
+    }): {
+        tools: any[];
+        tool_choice: string;
+    } | {
+        tools?: undefined;
+        tool_choice?: undefined;
+    };
+    transformToolMessageBlocks({ messageBlock, toolsData, }: {
+        messageBlock: TLLMMessageBlock;
+        toolsData: ToolData[];
+    }): TLLMToolResultMessageBlock[];
+    getConsistentMessages(messages: any): {
+        role: TLLMMessageRole;
+        content?: string | {
+            text: string;
+        }[] | Array<import("@anthropic-ai/sdk/resources/messages").TextBlockParam | import("@anthropic-ai/sdk/resources/messages").ImageBlockParam | import("@anthropic-ai/sdk/resources/messages").ToolUseBlockParam | import("@anthropic-ai/sdk/resources/messages").ToolResultBlockParam>;
+        parts?: {
+            text?: string;
+            functionCall?: {
+                name: string;
+                args: string;
+            };
+            functionResponse?: {
+                name: string;
+                response: {
+                    name: string;
+                    content: string;
+                };
+            };
+        }[];
+        tool_calls?: ToolData[];
+    }[];
+    private validateTokenLimit;
+    private getProvider;
+    /**
+     * Prepare request body for OpenAI Responses API
+     * Uses MessageTransformer and ToolsTransformer for clean interface transformations
+     */
+    private prepareImageGenerationBody;
+    private prepareImageEditBody;
+    protected reqBodyAdapter(params: TLLMPreparedParams): Promise<TOpenAIRequestBody>;
+    private prepareRequestBody;
+    protected reportUsage(usage: OpenAI.Completions.CompletionUsage & {
+        input_tokens?: number;
+        output_tokens?: number;
+        input_tokens_details?: {
+            cached_tokens?: number;
+        };
+        prompt_tokens_details?: {
+            cached_tokens?: number;
+        };
+        cost?: number;
+    }, metadata: {
+        modelEntryName: string;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    }): {
+        sourceId: string;
+        input_tokens: number;
+        output_tokens: number;
+        input_tokens_cache_write: number;
+        input_tokens_cache_read: number;
+        cost: number;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    };
+}

package/dist/types/subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/ChatCompletionsApiInterface.d.ts

@@ -0,0 +1,87 @@
+import EventEmitter from 'events';
+import OpenAI from 'openai';
+import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
+import { TLLMParams, TLLMPreparedParams, ILLMRequestContext } from '@sre/types/LLM.types';
+import { OpenAIApiInterface, ToolConfig } from './OpenAIApiInterface';
+import { HandlerDependencies } from '../types';
+/**
+ * OpenAI Chat Completions API interface implementation
+ * Handles all Chat Completions API-specific logic including:
+ * - Stream creation and handling
+ * - Request body preparation
+ * - Tool and message transformations
+ * - File attachment handling
+ */
+export declare class ChatCompletionsApiInterface extends OpenAIApiInterface {
+    private deps;
+    private validImageMimeTypes;
+    private validDocumentMimeTypes;
+    constructor(context: ILLMRequestContext, deps: HandlerDependencies);
+    createRequest(body: OpenAI.ChatCompletionCreateParams, context: ILLMRequestContext): Promise<OpenAI.ChatCompletion>;
+    createStream(body: OpenAI.ChatCompletionCreateParams, context: ILLMRequestContext): Promise<AsyncIterable<OpenAI.ChatCompletionChunk>>;
+    handleStream(stream: AsyncIterable<OpenAI.ChatCompletionChunk>, context: ILLMRequestContext): EventEmitter;
+    prepareRequestBody(params: TLLMPreparedParams): Promise<OpenAI.ChatCompletionCreateParams>;
+    /**
+     * Type guard to check if a tool is an OpenAI tool definition
+     */
+    private isOpenAIToolDefinition;
+    /**
+     * Transform OpenAI tool definitions to ChatCompletionTool format
+     */
+    transformToolsConfig(config: ToolConfig): OpenAI.ChatCompletionTool[];
+    handleFileAttachments(files: BinaryInput[], agentId: string, messages: OpenAI.ChatCompletionMessageParam[]): Promise<OpenAI.ChatCompletionMessageParam[]>;
+    /**
+     * Process the chat completions API stream format
+     */
+    private processStream;
+    /**
+     * Extract and format tool calls from the accumulated data
+     */
+    private extractToolCalls;
+    /**
+     * Report usage statistics
+     */
+    private reportUsageStatistics;
+    /**
+     * Emit final events
+     */
+    private emitFinalEvents;
+    /**
+     * Build usage context parameters from request context
+     */
+    private buildUsageContext;
+    /**
+     * Get valid image files based on supported MIME types
+     */
+    private getValidImageFiles;
+    /**
+     * Get valid document files based on supported MIME types
+     */
+    private getValidDocumentFiles;
+    /**
+     * Upload files to storage
+     */
+    private uploadFiles;
+    /**
+     * Process image files with Chat Completions specific formatting
+     */
+    private processImageData;
+    /**
+     * Process document files with Chat Completions specific formatting
+     */
+    private processDocumentData;
+    /**
+     * Validate file size before processing
+     */
+    private validateFileSize;
+    getInterfaceName(): string;
+    validateParameters(params: TLLMParams): boolean;
+    /**
+     * Convert system messages to user messages for models that don't support system messages
+     */
+    private convertSystemMessagesToUserMessages;
+    /**
+     * Prepare messages for Chat Completions API
+     */
+    private prepareMessages;
+}

package/dist/types/subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/OpenAIApiInterface.d.ts

@@ -0,0 +1,85 @@
+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 declare abstract class OpenAIApiInterface {
+    protected context: ILLMRequestContext;
+    constructor(context: ILLMRequestContext);
+    /**
+     * 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[];
+}