@smythos/sre 1.5.44 → 1.5.45

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

@@ -42,7 +42,12 @@ export declare class OpenAIConnector extends LLMConnector {
         }[] | 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?: {
+            functionCall? /**
+             * Safely compute prompt token count across different interfaces (Chat Completions, Responses)
+             * - Normalizes message content to strings for encodeChat
+             * - Handles vision prompts when files are present
+             * - Never throws; defaults to 0 on failure
+             */: {
                 name: string;
                 args: string;
             };
@@ -58,6 +63,13 @@ export declare class OpenAIConnector extends LLMConnector {
     }[];
     private validateTokenLimit;
     private getProvider;
+    /**
+     * Safely compute prompt token count across different interfaces (Chat Completions, Responses)
+     * - Normalizes message content to strings for encodeChat
+     * - Handles vision prompts when files are present
+     * - Never throws; defaults to 0 on failure
+     */
+    private computePromptTokens;
     /**
      * Prepare request body for OpenAI Responses API
      * Uses MessageTransformer and ToolsTransformer for clean interface transformations

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

@@ -2,7 +2,7 @@ import EventEmitter from 'events';
 import OpenAI from 'openai';
 import type { Stream } from 'openai/streaming';
 import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
-import { TLLMParams, TLLMPreparedParams, ILLMRequestContext } from '@sre/types/LLM.types';
+import { TLLMParams, TLLMPreparedParams, ILLMRequestContext, ToolData } from '@sre/types/LLM.types';
 import { OpenAIApiInterface, ToolConfig } from './OpenAIApiInterface';
 import { HandlerDependencies } from '../types';
 /**
@@ -45,55 +45,56 @@ export declare class ResponsesApiInterface extends OpenAIApiInterface {
      * Calculate search tool usage with cost
      */
     private calculateSearchToolUsage;
-    prepareRequestBody(params: TLLMPreparedParams): Promise<OpenAI.Responses.ResponseCreateParams>;
     /**
-     * Transform OpenAI tool definitions to Responses.Tool format
+     * Handle web search completed event with proper type safety
      */
-    transformToolsConfig(config: ToolConfig): OpenAI.Responses.Tool[];
+    private handleWebSearchCompleted;
     /**
-     * Transform assistant message block with tool calls for Responses API
+     * Handle web search in-progress event (official typed)
      */
-    private transformAssistantMessageBlock;
+    private handleWebSearchInProgress;
     /**
-     * Transform individual tool calls to ensure proper formatting
+     * Handle web search searching event (official typed)
      */
-    private transformToolCalls;
+    private handleWebSearchSearching;
     /**
-     * Transform tool results with comprehensive error handling and type support
+     * Handle output text delta events
      */
-    private transformToolResults;
+    private handleOutputTextDelta;
     /**
-     * Create a tool result message for the Responses API format
+     * Handle output item added events (function calls)
      */
-    private createToolResultMessage;
+    private handleOutputItemAdded;
     /**
-     * Format tool result content based on type and handle special cases
+     * Handle function call arguments delta events
      */
-    private formatToolResult;
+    private handleFunctionCallArgumentsDelta;
     /**
-     * Format tool error messages with context
+     * Handle function call arguments done events
      */
-    private formatToolError;
+    private handleFunctionCallArgumentsDone;
     /**
-     * Normalize content to string format for Responses API
+     * Handle output item done events
      */
-    private normalizeContent;
+    private handleOutputItemDone;
     /**
-     * Normalize tool arguments to string format for Responses API
+     * Handle completion events and unknown event types
      */
-    private normalizeToolArguments;
+    private handleCompletionEvent;
+    prepareRequestBody(params: TLLMPreparedParams): Promise<OpenAI.Responses.ResponseCreateParams>;
     /**
-     * Validate if tool data is complete and valid for transformation
+     * Transform OpenAI tool definitions to Responses.Tool format
+     * Handles multiple tool definition formats and ensures compatibility
      */
-    private isValidToolData;
+    transformToolsConfig(config: ToolConfig): OpenAI.Responses.Tool[];
     /**
-     * Check if the tool is a web search tool based on type or name
+     * Normalize tool arguments to string format for Responses API
      */
-    private isWebSearchTool;
+    private normalizeToolArguments;
     /**
-     * Format web search results with better structure
+     * Validate if tool data is complete and valid for transformation
      */
-    private formatWebSearchResult;
+    private isValidToolData;
     handleFileAttachments(files: BinaryInput[], agentId: string, messages: any[]): Promise<any[]>;
     /**
      * Get valid image files based on supported MIME types
@@ -126,7 +127,8 @@ export declare class ResponsesApiInterface extends OpenAIApiInterface {
      */
     private prepareInputMessages;
     /**
-     * Prepare tools for request
+     * Prepare function tools for Responses API request
+     * Transforms tools from various formats to Responses API format
      */
     private prepareFunctionTools;
     /**
@@ -134,9 +136,26 @@ export declare class ResponsesApiInterface extends OpenAIApiInterface {
      * According to OpenAI documentation: https://platform.openai.com/docs/api-reference/responses/create
      */
     private prepareWebSearchTool;
+    /**
+     * Transform messages for Responses API compatibility
+     * Handles the differences between Chat Completions and Responses API message formats
+     */
     private applyToolMessageTransformation;
     /**
      * Get search tool cost for a specific model and context size
      */
     private getSearchToolCost;
+    /**
+     * Process function call responses and integrate them back into the conversation
+     * This method helps maintain compatibility with the chat completion flow
+     */
+    processFunctionCallResults(toolsData: ToolData[]): Promise<ToolData[]>;
+    /**
+     * Validate tool choice parameter for Responses API
+     */
+    private validateToolChoice;
+    /**
+     * Upsert a web search tool entry in toolsData and return its index
+     */
+    private upsertWebSearchToolImmutable;
 }

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

@@ -1,4 +1,3 @@
-import { SearchToolCostConfig } from '../types';
 export declare const MODELS_WITHOUT_TEMPERATURE_SUPPORT: string[];
 export declare const MODELS_WITHOUT_PRESENCE_PENALTY_SUPPORT: string[];
 export declare const MODELS_WITHOUT_JSON_RESPONSE_SUPPORT: string[];
@@ -7,4 +6,7 @@ export declare const MODELS_WITHOUT_SYSTEM_MESSAGE_SUPPORT: string[];
  * Search tool cost configuration
  * Costs are in dollars per 1000 requests
  */
-export declare const SEARCH_TOOL_COSTS: SearchToolCostConfig;
+export declare const SEARCH_TOOL_COSTS: {
+    'gpt-4': number;
+    'gpt-5': number;
+};

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

@@ -32,7 +32,3 @@ export interface CostConfig {
         [contextSize: string]: number;
     };
 }
-export interface SearchToolCostConfig {
-    normalModels: CostConfig;
-    miniModels: CostConfig;
-}

package/dist/types/subsystems/LLMManager/ModelsProvider.service/connectors/SmythModelsProvider.class.d.ts

@@ -0,0 +1,39 @@
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { ModelsProviderConnector } from '../ModelsProviderConnector';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { TLLMModelsList } from '@sre/types/LLM.types';
+type SmythModelsProviderConfig = {
+    /**
+     * The models to be used.
+     *
+     * If a string is provided, it will be used as the directory name to load the models from.
+     * If a TLLMModelsList is provided, it will be used as the models to be used.
+     *
+     */
+    models?: string | TLLMModelsList;
+    /**
+     * The mode to be used.
+     *
+     * If 'append' is used, the models will be appended to the existing models.
+     * If 'replace' is used, the existing models will be replaced with the new models.
+     */
+    mode?: 'merge' | 'replace';
+};
+export declare class SmythModelsProvider extends ModelsProviderConnector {
+    protected _settings?: SmythModelsProviderConfig;
+    name: string;
+    private models;
+    constructor(_settings?: SmythModelsProviderConfig);
+    start(): Promise<void>;
+    addModels(acRequest: AccessRequest, models: TLLMModelsList): Promise<void>;
+    getModels(acRequest: AccessRequest): Promise<any>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    private reindexModels;
+    private scanDirectoryForModels;
+    private getValidModels;
+    private isValidSingleModel;
+    private isValidModel;
+    private initDirWatcher;
+}
+export {};

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

@@ -257,6 +257,7 @@ export type ToolData = {
     result?: string;
     function?: any;
     error?: string;
+    callId?: string;
 };
 /**
  * Base tool definition interface - only truly common properties

package/package.json

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

package/src/Components/APICall/APICall.class.ts

@@ -1,156 +1,156 @@
-import axios, { AxiosRequestConfig } from 'axios';
-import Joi from 'joi';
-
-import { Agent } from '@sre/AgentManager/Agent.class';
-import { Component } from '../Component.class';
-import { parseHeaders } from './parseHeaders';
-import { parseUrl, parseSmythFsUrl, destroyPublicUrls } from './parseUrl';
-import { parseData } from './parseData';
-import { parseProxy } from './parseProxy';
-import { parseArrayBufferResponse } from './ArrayBufferResponse.helper';
-import { extractAdditionalParamsForOAuth1, handleOAuthHeaders as generateOAuthHeaders } from './OAuth.helper';
-import { SocksProxyAgent } from 'socks-proxy-agent';
-import { formatDataForDebug } from '@sre/utils/data.utils';
-import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-
-export class APICall extends Component {
-    protected schema = {
-        name: 'APICall',
-        description: 'Use this component to make an API call',
-        inputs: {},
-        outputs: {
-            Headers: {
-                description: 'The headers of the API call response',
-                default: true,
-            },
-            Response: {
-                description: 'The response of the API call',
-                default: true,
-            },
-        },
-    };
-
-    protected configSchema = Joi.object({
-        method: Joi.string().valid('GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS').required().label('Method'),
-        url: Joi.string()
-            .max(8192) /*.custom(isUrlValid, 'URL validation')*/
-            .required()
-            .label('URL'),
-        headers: Joi.any().allow('').label('Headers'),
-        contentType: Joi.string()
-            .valid('none', 'application/json', 'multipart/form-data', 'binary', 'application/x-www-form-urlencoded', 'text/plain', 'application/xml')
-            .label('Content-Type'),
-        body: Joi.any().allow('').label('Body'),
-        _templateSettings: Joi.object().allow(null).label('Template Settings'),
-        _templateVars: Joi.object().allow(null).label('Template Variables'),
-        proxy: Joi.string().allow('').label('Proxy'),
-        oauthService: Joi.string().allow('').label('OAuth Service'),
-        scope: Joi.string().allow('').label('Scope'),
-        authorizationURL: Joi.string().allow('').label('Authorization URL'),
-        tokenURL: Joi.string().allow('').label('Token URL'),
-        clientID: Joi.string().allow('').label('Client ID'),
-        clientSecret: Joi.string().allow('').label('Client Secret'),
-        oauth2CallbackURL: Joi.string().allow('').label('OAuth2 Callback URL'),
-        callbackURL: Joi.string().allow('').label('Callback URL'), // !TEMP: prevent validation error
-        requestTokenURL: Joi.string().allow('').label('Request Token URL'),
-        accessTokenURL: Joi.string().allow('').label('Access Token URL'),
-        userAuthorizationURL: Joi.string().allow('').label('User Authorization URL'),
-        consumerKey: Joi.string().allow('').label('Consumer Key'),
-        consumerSecret: Joi.string().allow('').label('Consumer Secret'),
-        oauth1CallbackURL: Joi.string().allow('').label('OAuth1 Callback URL'),
-        authenticate: Joi.string().allow('').label('Authenticate'),
-    });
-    constructor() {
-        super();
-    }
-
-    init() {}
-
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-
-        const logger = this.createComponentLogger(agent, config);
-
-        let publicUrls: string[] = [];
-
-        try {
-            logger.debug(`=== API Call Log ===`);
-
-            const method = config?.data?.method || 'get';
-
-            const reqConfig: AxiosRequestConfig = {};
-            reqConfig.method = method;
-
-            reqConfig.url = await parseUrl(input, config, agent);
-
-            // We generate public URLs for any resources specified with the smythfs protocol in the request URL.
-            ({ url: reqConfig.url, publicUrls } = await parseSmythFsUrl(reqConfig.url, agent));
-
-            const { data, headers } = await parseData(input, config, agent);
-
-            // If the data is null, the request may fail. We encountered an issue where a request failed due to null data being provided.
-            let dataForDebug;
-            if (data) {
-                reqConfig.data = data;
-
-                dataForDebug = await formatDataForDebug(data, AccessCandidate.agent(agent.id));
-            }
-
-            reqConfig.headers = (await parseHeaders(input, config, agent)).concat({ ...headers });
-
-            const proxyConfig = await parseProxy(input, config, agent);
-
-            if (proxyConfig) {
-                if (proxyConfig instanceof SocksProxyAgent) {
-                    const isSecureEndpoint = reqConfig.url?.startsWith('https://');
-                    reqConfig[isSecureEndpoint ? 'httpsAgent' : 'httpAgent'] = proxyConfig;
-                } else {
-                    reqConfig.proxy = proxyConfig;
-                }
-            }
-
-            let Response: any = {};
-            let Headers: any = {};
-            let _error: any = undefined;
-            try {
-                if (config?.data?.oauthService && config?.data?.oauthService !== 'None') {
-                    const rootUrl = new URL(reqConfig.url).origin;
-                    const additionalParams = extractAdditionalParamsForOAuth1(reqConfig);
-                    const oauthHeaders = await generateOAuthHeaders(agent, config, reqConfig, logger, additionalParams, rootUrl);
-                    //reqConfig.headers = { ...reqConfig.headers, ...oauthHeaders };
-                    reqConfig.headers = reqConfig.headers.concat({ ...oauthHeaders });
-                }
-
-                // in order to handle binary data automatically, we need to set responseType to 'arraybuffer' for all requests, then parse the response data based on content-type
-                reqConfig.responseType = 'arraybuffer';
-
-                logger.debug('Making API call', { ...reqConfig, data: dataForDebug });
-
-                const response = await axios.request(reqConfig);
-
-                const parsedRes = await parseArrayBufferResponse(response, agent);
-
-                // log response headers
-                logger.debug('API call Response Headers', response.headers);
-                Response = parsedRes;
-
-                logger.debug('API call Response\n', Response);
-
-                Headers = Object.fromEntries(Object.entries(response.headers));
-            } catch (error) {
-                logger.debug(`Error making API call: ${error.message}`);
-                Headers = error?.response?.headers ? Object.fromEntries(Object.entries(error.response.headers)) : {};
-                Response = await parseArrayBufferResponse(error.response, agent);
-                _error = error.message;
-            }
-
-            return { Response, Headers, _error, _debug: logger.output };
-        } catch (error) {
-            return { _error: error.message, _debug: logger.output };
-        } finally {
-            if (publicUrls.length > 0) {
-                await destroyPublicUrls(publicUrls);
-            }
-        }
-    }
-}
+import axios, { AxiosRequestConfig } from 'axios';
+import Joi from 'joi';
+
+import { Agent } from '@sre/AgentManager/Agent.class';
+import { Component } from '../Component.class';
+import { parseHeaders } from './parseHeaders';
+import { parseUrl, parseSmythFsUrl, destroyPublicUrls } from './parseUrl';
+import { parseData } from './parseData';
+import { parseProxy } from './parseProxy';
+import { parseArrayBufferResponse } from './ArrayBufferResponse.helper';
+import { extractAdditionalParamsForOAuth1, handleOAuthHeaders as generateOAuthHeaders } from './OAuth.helper';
+import { SocksProxyAgent } from 'socks-proxy-agent';
+import { formatDataForDebug } from '@sre/utils/data.utils';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+
+export class APICall extends Component {
+    protected schema = {
+        name: 'APICall',
+        description: 'Use this component to make an API call',
+        inputs: {},
+        outputs: {
+            Headers: {
+                description: 'The headers of the API call response',
+                default: true,
+            },
+            Response: {
+                description: 'The response of the API call',
+                default: true,
+            },
+        },
+    };
+
+    protected configSchema = Joi.object({
+        method: Joi.string().valid('GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS').required().label('Method'),
+        url: Joi.string()
+            .max(8192) /*.custom(isUrlValid, 'URL validation')*/
+            .required()
+            .label('URL'),
+        headers: Joi.any().allow('').label('Headers'),
+        contentType: Joi.string()
+            .valid('none', 'application/json', 'multipart/form-data', 'binary', 'application/x-www-form-urlencoded', 'text/plain', 'application/xml')
+            .label('Content-Type'),
+        body: Joi.any().allow('').label('Body'),
+        _templateSettings: Joi.object().allow(null).label('Template Settings'),
+        _templateVars: Joi.object().allow(null).label('Template Variables'),
+        proxy: Joi.string().allow('').label('Proxy'),
+        oauthService: Joi.string().allow('').label('OAuth Service'),
+        scope: Joi.string().allow('').label('Scope'),
+        authorizationURL: Joi.string().allow('').label('Authorization URL'),
+        tokenURL: Joi.string().allow('').label('Token URL'),
+        clientID: Joi.string().allow('').label('Client ID'),
+        clientSecret: Joi.string().allow('').label('Client Secret'),
+        oauth2CallbackURL: Joi.string().allow('').label('OAuth2 Callback URL'),
+        callbackURL: Joi.string().allow('').label('Callback URL'), // !TEMP: prevent validation error
+        requestTokenURL: Joi.string().allow('').label('Request Token URL'),
+        accessTokenURL: Joi.string().allow('').label('Access Token URL'),
+        userAuthorizationURL: Joi.string().allow('').label('User Authorization URL'),
+        consumerKey: Joi.string().allow('').label('Consumer Key'),
+        consumerSecret: Joi.string().allow('').label('Consumer Secret'),
+        oauth1CallbackURL: Joi.string().allow('').label('OAuth1 Callback URL'),
+        authenticate: Joi.string().allow('').label('Authenticate'),
+    });
+    constructor() {
+        super();
+    }
+
+    init() {}
+
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+
+        const logger = this.createComponentLogger(agent, config);
+
+        let publicUrls: string[] = [];
+
+        try {
+            logger.debug(`=== API Call Log ===`);
+
+            const method = config?.data?.method || 'get';
+
+            const reqConfig: AxiosRequestConfig = {};
+            reqConfig.method = method;
+
+            reqConfig.url = await parseUrl(input, config, agent);
+
+            // We generate public URLs for any resources specified with the smythfs protocol in the request URL.
+            ({ url: reqConfig.url, publicUrls } = await parseSmythFsUrl(reqConfig.url, agent));
+
+            const { data, headers } = await parseData(input, config, agent);
+
+            // If the data is null, the request may fail. We encountered an issue where a request failed due to null data being provided.
+            let dataForDebug;
+            if (data) {
+                reqConfig.data = data;
+
+                dataForDebug = await formatDataForDebug(data, AccessCandidate.agent(agent.id));
+            }
+
+            reqConfig.headers = (await parseHeaders(input, config, agent)).concat({ ...headers });
+
+            const proxyConfig = await parseProxy(input, config, agent);
+
+            if (proxyConfig) {
+                if (proxyConfig instanceof SocksProxyAgent) {
+                    const isSecureEndpoint = reqConfig.url?.startsWith('https://');
+                    reqConfig[isSecureEndpoint ? 'httpsAgent' : 'httpAgent'] = proxyConfig;
+                } else {
+                    reqConfig.proxy = proxyConfig;
+                }
+            }
+
+            let Response: any = {};
+            let Headers: any = {};
+            let _error: any = undefined;
+            try {
+                if (config?.data?.oauthService && config?.data?.oauthService !== 'None') {
+                    const rootUrl = new URL(reqConfig.url).origin;
+                    const additionalParams = extractAdditionalParamsForOAuth1(reqConfig);
+                    const oauthHeaders = await generateOAuthHeaders(agent, config, reqConfig, logger, additionalParams, rootUrl);
+                    //reqConfig.headers = { ...reqConfig.headers, ...oauthHeaders };
+                    reqConfig.headers = reqConfig.headers.concat({ ...oauthHeaders });
+                }
+
+                // in order to handle binary data automatically, we need to set responseType to 'arraybuffer' for all requests, then parse the response data based on content-type
+                reqConfig.responseType = 'arraybuffer';
+
+                logger.debug('Making API call', { ...reqConfig, data: dataForDebug });
+
+                const response = await axios.request(reqConfig);
+
+                const parsedRes = await parseArrayBufferResponse(response, agent);
+
+                // log response headers
+                logger.debug('API call Response Headers', response.headers);
+                Response = parsedRes;
+
+                logger.debug('API call Response\n', Response);
+
+                Headers = Object.fromEntries(Object.entries(response.headers));
+            } catch (error) {
+                logger.debug(`Error making API call: ${error.message}`);
+                Headers = error?.response?.headers ? Object.fromEntries(Object.entries(error.response.headers)) : {};
+                Response = await parseArrayBufferResponse(error.response, agent);
+                _error = error.message;
+            }
+
+            return { Response, Headers, _error, _debug: logger.output };
+        } catch (error) {
+            return { _error: error.message, _debug: logger.output };
+        } finally {
+            if (publicUrls.length > 0) {
+                await destroyPublicUrls(publicUrls);
+            }
+        }
+    }
+}