@smythos/sre 1.5.37 → 1.5.40

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[];
+}

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

@@ -0,0 +1,49 @@
+import { OpenAIApiInterface, OpenAIApiInterfaceFactory as IOpenAIApiInterfaceFactory } from './OpenAIApiInterface';
+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 declare class OpenAIApiInterfaceFactory implements IOpenAIApiInterfaceFactory {
+    constructor();
+    /**
+     * 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;
+    /**
+     * Get list of supported interface types
+     * @returns Array of supported interface type strings
+     */
+    getSupportedInterfaces(): string[];
+    /**
+     * Check if an interface type is supported
+     * @param interfaceType - The interface type to check
+     * @returns True if supported, false otherwise
+     */
+    isInterfaceSupported(interfaceType: string): boolean;
+    /**
+     * Get the default interface type
+     * @returns The default interface type string
+     */
+    getDefaultInterfaceType(): string;
+    /**
+     * 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;
+}

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

@@ -0,0 +1,146 @@
+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 { OpenAIApiInterface, ToolConfig } from './OpenAIApiInterface';
+import { HandlerDependencies } from '../types';
+/**
+ * OpenAI Responses API interface implementation
+ * Handles all Responses API-specific logic including:
+ * - Stream creation and handling
+ * - Request body preparation
+ * - Tool and message transformations
+ * - File attachment handling
+ */
+export declare class ResponsesApiInterface extends OpenAIApiInterface {
+    private deps;
+    private validImageMimeTypes;
+    private validDocumentMimeTypes;
+    constructor(context: ILLMRequestContext, deps: HandlerDependencies);
+    createRequest(body: OpenAI.Responses.ResponseCreateParams, context: ILLMRequestContext): Promise<OpenAI.Responses.Response>;
+    createStream(body: OpenAI.Responses.ResponseCreateParams, context: ILLMRequestContext): Promise<Stream<OpenAI.Responses.ResponseStreamEvent>>;
+    handleStream(stream: Stream<OpenAI.Responses.ResponseStreamEvent>, context: ILLMRequestContext): EventEmitter;
+    /**
+     * Process the responses 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;
+    /**
+     * Calculate search tool usage with cost
+     */
+    private calculateSearchToolUsage;
+    prepareRequestBody(params: TLLMPreparedParams): Promise<OpenAI.Responses.ResponseCreateParams>;
+    /**
+     * Type guard to check if a tool is an OpenAI tool definition
+     */
+    private isOpenAIToolDefinition;
+    /**
+     * Transform OpenAI tool definitions to Responses.Tool format
+     */
+    transformToolsConfig(config: ToolConfig): OpenAI.Responses.Tool[];
+    /**
+     * Transform assistant message block with tool calls for Responses API
+     */
+    private transformAssistantMessageBlock;
+    /**
+     * Transform individual tool calls to ensure proper formatting
+     */
+    private transformToolCalls;
+    /**
+     * Transform tool results with comprehensive error handling and type support
+     */
+    private transformToolResults;
+    /**
+     * Create a tool result message for the Responses API format
+     */
+    private createToolResultMessage;
+    /**
+     * Format tool result content based on type and handle special cases
+     */
+    private formatToolResult;
+    /**
+     * Format tool error messages with context
+     */
+    private formatToolError;
+    /**
+     * Normalize content to string format for Responses API
+     */
+    private normalizeContent;
+    /**
+     * Normalize tool arguments to string format for Responses API
+     */
+    private normalizeToolArguments;
+    /**
+     * Validate if tool data is complete and valid for transformation
+     */
+    private isValidToolData;
+    /**
+     * Check if the tool is a web search tool based on type or name
+     */
+    private isWebSearchTool;
+    /**
+     * Format web search results with better structure
+     */
+    private formatWebSearchResult;
+    handleFileAttachments(files: BinaryInput[], agentId: string, messages: any[]): Promise<any[]>;
+    /**
+     * 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 Responses API specific formatting
+     */
+    private processImageData;
+    /**
+     * Process document files with Responses API specific formatting
+     */
+    private processDocumentData;
+    /**
+     * Validate file size before processing
+     */
+    private validateFileSize;
+    getInterfaceName(): string;
+    validateParameters(params: TLLMParams): boolean;
+    /**
+     * Prepare input messages for Responses API
+     */
+    private prepareInputMessages;
+    /**
+     * Prepare tools for request
+     */
+    private prepareFunctionTools;
+    /**
+     * Get web search tool configuration for OpenAI Responses API
+     * According to OpenAI documentation: https://platform.openai.com/docs/api-reference/responses/create
+     */
+    private prepareWebSearchTool;
+    private applyToolMessageTransformation;
+    /**
+     * Get search tool cost for a specific model and context size
+     */
+    private getSearchToolCost;
+}

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

@@ -0,0 +1,10 @@
+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[];
+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;

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

@@ -0,0 +1,4 @@
+export { OpenAIApiInterface, ToolConfig } from './OpenAIApiInterface';
+export { ResponsesApiInterface } from './ResponsesApiInterface';
+export { ChatCompletionsApiInterface } from './ChatCompletionsApiInterface';
+export { OpenAIApiInterfaceFactory } from './OpenAIApiInterfaceFactory';

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

@@ -0,0 +1,38 @@
+import EventEmitter from 'events';
+import OpenAI from 'openai';
+import { ILLMRequestContext, APIKeySource } from '@sre/types/LLM.types';
+export declare enum TToolType {
+    WebSearch = "web_search_preview"
+}
+export interface IResponseHandler {
+    createStream(body: Record<string, unknown>, context: ILLMRequestContext): Promise<unknown>;
+    handleStream(stream: unknown, context: ILLMRequestContext): EventEmitter;
+}
+export type HandlerDependencies = {
+    getClient: (context: ILLMRequestContext) => Promise<OpenAI>;
+    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;
+    }) => any;
+};
+export interface CostConfig {
+    [modelName: string]: {
+        [contextSize: string]: number;
+    };
+}
+export interface SearchToolCostConfig {
+    normalModels: CostConfig;
+    miniModels: CostConfig;
+}

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

@@ -63,7 +63,6 @@ export declare class xAIConnector 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 reportUsage(usage: TUsage, metadata: {
         modelEntryName: string;
@@ -100,7 +99,7 @@ export declare class xAIConnector 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/Security/Vault.service/connectors/JSONFileVault.class.d.ts

@@ -13,6 +13,8 @@ export declare class JSONFileVault extends VaultConnector {
     private vaultData;
     private index;
     private shared;
+    private vaultFile;
+    private watcher;
     constructor(_settings: JSONFileVaultConfig);
     private findVaultFile;
     private getMasterKeyInteractive;
@@ -27,4 +29,7 @@ export declare class JSONFileVault extends VaultConnector {
     protected exists(acRequest: AccessRequest, keyId: string): Promise<boolean>;
     protected listKeys(acRequest: AccessRequest): Promise<string[]>;
     getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    private fetchVaultData;
+    private initFileWatcher;
+    stop(): Promise<void>;
 }

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

@@ -35,10 +35,43 @@ export interface BedrockCredentials {
 export type ILLMConnectorCredentials = BasicCredentials | BedrockCredentials | VertexAICredentials;
 export type TOpenAIResponseToolChoice = OpenAI.Responses.ToolChoiceOptions | OpenAI.Responses.ToolChoiceTypes | OpenAI.Responses.ToolChoiceFunction;
 export type TLLMToolChoice = OpenAI.ChatCompletionToolChoiceOption;
+export type TOpenAIToolsInfo = {
+    webSearch: {
+        enabled: boolean;
+        contextSize: TSearchContextSize;
+        city?: string;
+        country?: string;
+        region?: string;
+        timezone?: string;
+    };
+};
+export type TxAIToolsInfo = {
+    search: {
+        enabled: boolean;
+        mode?: 'auto' | 'on' | 'off';
+        returnCitations?: boolean;
+        maxResults?: number;
+        dataSources?: string[];
+        country?: string;
+        excludedWebsites?: string[];
+        allowedWebsites?: string[];
+        includedXHandles?: string[];
+        excludedXHandles?: string[];
+        postFavoriteCount?: number;
+        postViewCount?: number;
+        rssLinks?: string;
+        safeSearch?: boolean;
+        fromDate?: string;
+        toDate?: string;
+    };
+};
+export type TToolsInfo = {
+    openai: TOpenAIToolsInfo;
+    xai: TxAIToolsInfo;
+};
+export type TSearchContextSize = 'low' | 'medium' | 'high';
 export type TLLMParams = {
     model: TLLMModel | string;
-    modelEntryName?: string;
-    credentials?: ILLMConnectorCredentials;
     prompt?: string;
     messages?: any[];
     temperature?: number;
@@ -69,7 +102,7 @@ export type TLLMParams = {
     };
     maxThinkingTokens?: number;
     useWebSearch?: boolean;
-    webSearchContextSize?: 'high' | 'medium' | 'low';
+    webSearchContextSize?: TSearchContextSize;
     webSearchCity?: string;
     webSearchCountry?: string;
     webSearchRegion?: string;
@@ -91,6 +124,13 @@ export type TLLMParams = {
     fromDate?: string;
     toDate?: string;
     useReasoning?: boolean;
+    max_output_tokens?: number;
+    abortSignal?: AbortSignal;
+};
+export type TLLMPreparedParams = TLLMParams & {
+    body: any;
+    modelEntryName?: string;
+    credentials?: ILLMConnectorCredentials;
     isUserKey?: boolean;
     capabilities?: {
         search?: boolean;
@@ -98,38 +138,7 @@ export type TLLMParams = {
         imageGeneration?: boolean;
         imageEditing?: boolean;
     };
-    max_output_tokens?: number;
-    abortSignal?: AbortSignal;
-};
-export type TLLMParamsV2 = {
-    model: string;
-    modelEntryName: string;
-    messages: any[];
-    toolsConfig?: {
-        tools?: OpenAI.Responses.Tool[];
-        tool_choice?: OpenAI.Responses.ToolChoiceOptions | OpenAI.Responses.ToolChoiceTypes | OpenAI.Responses.ToolChoiceFunction;
-    };
-    baseURL?: string;
-    stream?: boolean;
-    responseFormat?: any;
-    credentials?: {
-        apiKey?: string;
-        isUserKey?: boolean;
-    };
-    max_output_tokens?: number;
-    temperature?: number;
-    top_p?: number;
-    top_k?: number;
-    frequency_penalty?: number;
-    presence_penalty?: number;
-    teamId?: string;
-    files?: BinaryInput[];
-    useWebSearch?: boolean;
-    webSearchContextSize?: 'high' | 'medium' | 'low';
-    webSearchCity?: string;
-    webSearchCountry?: string;
-    webSearchRegion?: string;
-    webSearchTimezone?: string;
+    toolsInfo?: TToolsInfo;
 };
 export type TLLMConnectorParams = Omit<TLLMParams, 'model'> & {
     model: string | TLLMModel | TCustomLLMModel;
@@ -174,6 +183,12 @@ export type TLLMModel = {
     };
     credentials?: TLLMCredentials;
     params?: TLLMParams;
+    /**
+     * Specifies the API interface type to use for this model
+     * Examples: 'chat.completions', 'responses'
+     * This determines which OpenAI API endpoint and interface implementation to use
+     */
+    interface?: 'chat.completions' | 'responses';
 };
 export declare const BuiltinLLMProviders: {
     readonly Echo: "Echo";
@@ -214,6 +229,7 @@ export type TVertexAISettings = {
     projectId: string;
     credentialsName: string;
     jsonCredentialsName: string;
+    apiEndpoint?: string;
 };
 export type TCustomLLMModel = TLLMModel & {
     name: string;
@@ -234,16 +250,44 @@ export type ToolData = {
     function?: any;
     error?: string;
 };
-export interface AnthropicToolDefinition {
+/**
+ * Base tool definition interface - only truly common properties
+ * All provider-specific tool definitions extend from this
+ */
+export interface ToolDefinition {
     name: string;
     description: string;
+}
+/**
+ * OpenAI-specific tool definition
+ * Extends base with OpenAI's parameter format
+ */
+export interface OpenAIToolDefinition extends ToolDefinition {
+    parameters: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+/**
+ * Anthropic-specific tool definition
+ * Extends base with Anthropic's input_schema format
+ */
+export interface AnthropicToolDefinition extends ToolDefinition {
     input_schema: {
         type: 'object';
         properties: Record<string, unknown>;
         required: string[];
     };
 }
-export type ToolDefinition = OpenAI.ChatCompletionTool | AnthropicToolDefinition;
+/**
+ * Legacy tool definition for backward compatibility
+ * @deprecated Use provider-specific definitions instead
+ */
+export interface LegacyToolDefinition extends ToolDefinition {
+    properties?: Record<string, unknown>;
+    requiredFields?: string[];
+}
 export type ToolChoice = OpenAI.ChatCompletionToolChoiceOption | FunctionCallingMode;
 export interface ToolsConfig {
     tools?: ToolDefinition[];
@@ -358,6 +402,7 @@ export interface ILLMRequestContext {
     hasFiles?: boolean;
     modelInfo: TCustomLLMModel | TLLMModel;
     credentials: ILLMConnectorCredentials;
+    toolsInfo?: TToolsInfo;
 }
 export interface ILLMRequestFuncParams<TBody = any> {
     acRequest: AccessRequest;

package/dist/types/utils/data.utils.d.ts

@@ -1,5 +1,6 @@
 import { Readable } from 'stream';
 import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
+import { IAccessCandidate } from '@sre/types/ACL.types';
 export declare function streamToBuffer(stream: Readable): Promise<Buffer>;
 export declare function dataToBuffer(data: any): Buffer | null;
 export declare const getSizeFromBinary: (data: any) => number;
@@ -14,5 +15,5 @@ export declare const isSmythFileObject: (data: any) => boolean;
 export declare const isBufferObject: (data: Record<string, any>) => boolean;
 export declare const isBase64Object: (data: Record<string, any>) => boolean;
 export declare function getMimeType(data: any): Promise<string>;
-export declare function formatDataForDebug(data: any): Promise<any>;
+export declare function formatDataForDebug(data: any, candidate: IAccessCandidate): Promise<any>;
 export declare function normalizeImageInput(inputImage: string | BinaryInput): Promise<string>;