@smythos/sre 1.5.37 → 1.5.40

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

@@ -0,0 +1,37 @@
+import { SearchToolCostConfig } from '../types';
+
+export const MODELS_WITHOUT_TEMPERATURE_SUPPORT = ['o3-pro', 'o4-mini'];
+export const MODELS_WITHOUT_PRESENCE_PENALTY_SUPPORT = ['o4-mini'];
+export const MODELS_WITHOUT_JSON_RESPONSE_SUPPORT = ['o1-preview'];
+export const MODELS_WITHOUT_SYSTEM_MESSAGE_SUPPORT = ['o1-mini', 'o1-preview'];
+
+/**
+ * Search tool cost configuration
+ * Costs are in dollars per 1000 requests
+ */
+export const SEARCH_TOOL_COSTS: SearchToolCostConfig = {
+    normalModels: {
+        'gpt-4.1': {
+            low: 30 / 1000,
+            medium: 35 / 1000,
+            high: 50 / 1000,
+        },
+        'gpt-4o': {
+            low: 30 / 1000,
+            medium: 35 / 1000,
+            high: 50 / 1000,
+        },
+    },
+    miniModels: {
+        'gpt-4.1-mini': {
+            low: 25 / 1000,
+            medium: 27.5 / 1000,
+            high: 30 / 1000,
+        },
+        'gpt-4o-mini': {
+            low: 25 / 1000,
+            medium: 27.5 / 1000,
+            high: 30 / 1000,
+        },
+    },
+};

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

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

package/src/subsystems/LLMManager/LLM.service/connectors/openai/types.ts

@@ -0,0 +1,37 @@
+import EventEmitter from 'events';
+import OpenAI from 'openai';
+import { ILLMRequestContext, APIKeySource } from '@sre/types/LLM.types';
+
+export 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/src/subsystems/LLMManager/LLM.service/connectors/xAI.class.ts

@@ -266,11 +266,6 @@ export class xAIConnector extends LLMConnector {
         return emitter;
     }
 
-    // TODO: will be removed when we merge with interface support of OpenAI
-    protected async webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
-        throw new Error('Not implemented');
-    }
-
     protected async reqBodyAdapter(params: TLLMParams): Promise<ChatCompletionParams> {
         const messages = params?.messages || [];
         const modelName = params.model as string;

package/src/subsystems/LLMManager/LLM.service/index.ts

@@ -3,7 +3,7 @@
 import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
 import { TConnectorService } from '@sre/types/SRE.types';
 import { EchoConnector } from './connectors/Echo.class';
-import { OpenAIConnector } from './connectors/OpenAI.class';
+import { OpenAIConnector } from './connectors/openai/OpenAIConnector.class';
 import { GoogleAIConnector } from './connectors/GoogleAI.class';
 import { AnthropicConnector } from './connectors/Anthropic.class';
 import { GroqConnector } from './connectors/Groq.class';

package/src/subsystems/LLMManager/ModelsProvider.service/ModelsProviderConnector.ts

@@ -43,7 +43,7 @@ export abstract class ModelsProviderConnector extends SecureConnector {
         const cacheKey = `ModelsProviderConnector:${candidate.toString()}`;
         if (ModelsProviderConnector.localCache.has(cacheKey)) {
             //update the TTL every time the requester is called
-            return ModelsProviderConnector.localCache.get(cacheKey, 60 * 60 * 1000) as IModelsProviderRequest;
+            return ModelsProviderConnector.localCache.get(cacheKey, 10 * 60 * 1000) as IModelsProviderRequest;
         }
 
         let teamModels = null;
@@ -135,7 +135,7 @@ export abstract class ModelsProviderConnector extends SecureConnector {
                 }
             },
         };
-        ModelsProviderConnector.localCache.set(cacheKey, instance, 60 * 60 * 1000); // cache for 1 hour
+        ModelsProviderConnector.localCache.set(cacheKey, instance, 10 * 60 * 1000); // cache for 10 minutes
         return instance;
     }
 

package/src/subsystems/LLMManager/models.ts

@@ -745,7 +745,7 @@ export const models = {
         llm: 'GoogleAI',
 
         label: 'Gemini 2.5 Flash Preview',
-        modelId: 'gemini-2.5-flash-preview-04-17',
+        modelId: 'gemini-2.5-flash',
         provider: 'GoogleAI',
         features: ['text', 'image', 'audio', 'video', 'document'],
         tags: ['New', 'Personal'],

package/src/subsystems/MemoryManager/Cache.service/connectors/RedisCache.class.ts

@@ -26,9 +26,27 @@ export class RedisCache extends CacheConnector {
         let host = sentinels.length === 1 ? sentinels[0].host : null;
         let port = sentinels.length === 1 ? sentinels[0].port : null;
 
+        const redisConfig = {
+            // HEAVILY OPTIMIZED: Aggressive storm prevention parameters
+            maxRetriesPerRequest: 1, // VERY LIMITED retries (official)
+            retryDelayOnFailover: 50, // Fast failover (official)
+            connectTimeout: 3000, // SHORT timeout (official)
+            lazyConnect: false,
+            enableReadyCheck: false, // Skip ready check for speed (official)
+            commandTimeout: 2000, // VERY SHORT command timeout (official)
+            keepAlive: 10000, // Shorter keepalive - 10sec (official)
+            family: 4, // Force IPv4 (official)
+            maxLoadingTimeout: 2000, // Short loading timeout (official)
+            // Additional aggressive settings
+            enableOfflineQueue: false, // Disable offline queue (official)
+            db: 0, // Explicit DB (official)
+            stringNumbers: false, // No string conversion (official)
+        };
+
         this.redis = new IORedis({
             ...(host ? { host, port } : { sentinels, name: _settings.name || process.env.REDIS_MASTER_NAME }),
             password: _settings.password || process.env.REDIS_PASSWORD,
+            ...redisConfig,
         });
 
         this.redis.on('error', (error) => {

package/src/subsystems/MemoryManager/RuntimeContext.ts

@@ -91,7 +91,7 @@ export class RuntimeContext extends EventEmitter {
         if (this._runtimeFileReady) return;
 
         const endpointDBGCall = this.runtime.xDebugId?.startsWith('dbg-'); //weak check for debug session, we need to improve this
-        console.debug('Init ctxFile', this.ctxFile);
+        console.debug('Init Agent Context', this.ctxFile, AccessCandidate.agent(this.runtime.agent.id));
         const agent = this.runtime.agent;
         let method = (agent.agentRequest.method || 'POST').toUpperCase();
         const endpoint = agent.endpoints?.[agent.agentRequest.path]?.[method];
@@ -177,10 +177,9 @@ export class RuntimeContext extends EventEmitter {
             const exists = await this._cacheConnector.requester(AccessCandidate.agent(this.runtime.agent.id)).exists(this.ctxFile);
 
             if (exists) {
-                if (this.runtime.debug)
-                    this._cacheConnector
-                        .requester(AccessCandidate.agent(this.runtime.agent.id))
-                        .updateTTL(this.ctxFile, 5 * 60); //expires in 5 minute
+                console.debug('Agent Context Delete', this.ctxFile, AccessCandidate.agent(this.runtime.agent.id));
+                if (this.runtime.debug) this._cacheConnector.requester(AccessCandidate.agent(this.runtime.agent.id)).updateTTL(this.ctxFile, 5 * 60);
+                //expires in 5 minute
                 else this._cacheConnector.requester(AccessCandidate.agent(this.runtime.agent.id)).delete(this.ctxFile);
                 //if (this.runtime.debug && fs.existsSync(this.ctxFile)) await delay(1000 * 60); //if we're in debug mode, we keep the file for a while to allow final state read
                 //if (fs.existsSync(this.ctxFile)) fs.unlinkSync(this.ctxFile);
@@ -188,10 +187,13 @@ export class RuntimeContext extends EventEmitter {
         } else {
             const data = this.serialize();
             //if (data) fs.writeFileSync(this.ctxFile, JSON.stringify(data, null, 2));
-            if (data)
+            if (data) {
+                const serializedData = JSON.stringify(data, null, 2);
+                console.debug('Agent Context Size', this.ctxFile, serializedData.length, AccessCandidate.agent(this.runtime.agent.id));
                 await this._cacheConnector
                     .requester(AccessCandidate.agent(this.runtime.agent.id))
-                    .set(this.ctxFile, JSON.stringify(data, null, 2), null, null, 6 * 60 * 60); //expires in 6 hours max
+                    .set(this.ctxFile, serializedData, null, null, 3 * 60 * 60); //expires in 3 hours max
+            }
         }
     }
 
@@ -206,9 +208,14 @@ export class RuntimeContext extends EventEmitter {
         const component = ctxData.components[componentId];
 
         if (!component) {
-            console.log('>>>>>>> updateComponent Component debug data not found', componentId, component);
-            console.log('>>> ctxFile', this.ctxFile);
-            console.log('>>> ctxData', ctxData);
+            console.debug(
+                '>>>>>>> updateComponent Component debug data not found',
+                componentId,
+                component,
+                AccessCandidate.agent(this.runtime.agent.id)
+            );
+            console.debug('>>> ctxFile', this.ctxFile, AccessCandidate.agent(this.runtime.agent.id));
+            console.debug('>>> ctxData', ctxData, AccessCandidate.agent(this.runtime.agent.id));
         }
         component.ctx = { ...component.ctx, ...data, step: this.step };
 
@@ -220,9 +227,14 @@ export class RuntimeContext extends EventEmitter {
         const ctxData = this;
         const component = ctxData.components[componentId];
         if (!component) {
-            console.log('>>>>>>> resetComponent Component debug data not found', componentId, component);
-            console.log('>>> ctxFile', this.ctxFile);
-            console.log('>>> ctxData', ctxData);
+            console.debug(
+                '>>>>>>> resetComponent Component debug data not found',
+                componentId,
+                component,
+                AccessCandidate.agent(this.runtime.agent.id)
+            );
+            console.debug('>>> ctxFile', this.ctxFile, AccessCandidate.agent(this.runtime.agent.id));
+            console.debug('>>> ctxData', ctxData, AccessCandidate.agent(this.runtime.agent.id));
         }
         //component.dbg.active = false;
         //component.dbg.runtimeData = {};
@@ -237,9 +249,14 @@ export class RuntimeContext extends EventEmitter {
         if (!ctxData) return null;
         const component = ctxData.components[componentId];
         if (!component) {
-            console.log('>>>>>>> getComponentData Component debug data not found', componentId, component);
-            console.log('>>> ctxFile', this.ctxFile);
-            console.log('>>> ctxData', ctxData);
+            console.debug(
+                '>>>>>>> getComponentData Component debug data not found',
+                componentId,
+                component,
+                AccessCandidate.agent(this.runtime.agent.id)
+            );
+            console.debug('>>> ctxFile', this.ctxFile, AccessCandidate.agent(this.runtime.agent.id));
+            console.debug('>>> ctxData', ctxData, AccessCandidate.agent(this.runtime.agent.id));
         }
         //const data = this.debug ? component.dbg : component.ctx;
         const data = component.ctx;

package/src/subsystems/Security/Vault.service/connectors/JSONFileVault.class.ts

@@ -13,6 +13,7 @@ import crypto from 'crypto';
 import fs from 'fs';
 import * as readlineSync from 'readline-sync';
 import path from 'path';
+import * as chokidar from 'chokidar';
 import { findSmythPath } from '../../../../helpers/Sysconfig.helper';
 
 const console = Logger('JSONFileVault');
@@ -28,6 +29,8 @@ export class JSONFileVault extends VaultConnector {
     private vaultData: any;
     private index: any;
     private shared: string;
+    private vaultFile: string;
+    private watcher: chokidar.FSWatcher | null = null;
 
     constructor(protected _settings: JSONFileVaultConfig) {
         super(_settings);
@@ -35,48 +38,9 @@ export class JSONFileVault extends VaultConnector {
 
         this.shared = _settings.shared || ''; //if config.shared, all keys are accessible to all teams, and they are set under the 'shared' teamId
 
-        let vaultFile = this.findVaultFile(_settings.file);
-        this.vaultData = {};
-        if (fs.existsSync(vaultFile)) {
-            try {
-                if (_settings.fileKey && fs.existsSync(_settings.fileKey)) {
-                    try {
-                        const privateKey = fs.readFileSync(_settings.fileKey, 'utf8');
-                        const encryptedVault = fs.readFileSync(vaultFile, 'utf8').toString();
-                        const decryptedBuffer = crypto.privateDecrypt(
-                            {
-                                key: privateKey,
-                                padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
-                            },
-                            Buffer.from(encryptedVault, 'base64')
-                        );
-                        this.vaultData = JSON.parse(decryptedBuffer.toString('utf8'));
-                    } catch (error) {
-                        throw new Error('Failed to decrypt vault');
-                    }
-                } else {
-                    this.vaultData = JSON.parse(fs.readFileSync(vaultFile).toString());
-                }
-            } catch (e) {
-                console.error('Error parsing vault file:', e);
-                console.error('!!! Vault features might not work properly !!!');
-                this.vaultData = {};
-            }
-
-            if (this.vaultData?.encrypted && this.vaultData?.algorithm && this.vaultData?.data) {
-                //this is an encrypted vault we need to request the master key
-                this.setInteraction(this.getMasterKeyInteractive.bind(this));
-            }
-
-            for (let teamId in this.vaultData) {
-                for (let resourceId in this.vaultData[teamId]) {
-                    if (!this.index) this.index = {};
-                    if (!this.index[resourceId]) this.index[resourceId] = {};
-                    const value = this.vaultData[teamId][resourceId];
-                    this.index[resourceId][teamId] = value;
-                }
-            }
-        }
+        this.vaultFile = this.findVaultFile(_settings.file);
+        this.fetchVaultData(this.vaultFile, _settings);
+        this.initFileWatcher();
     }
 
     private findVaultFile(vaultFile) {
@@ -192,4 +156,66 @@ export class JSONFileVault extends VaultConnector {
 
         return acl;
     }
+
+    private fetchVaultData(vaultFile: string, _settings: JSONFileVaultConfig) {
+        if (fs.existsSync(vaultFile)) {
+            try {
+                if (_settings.fileKey && fs.existsSync(_settings.fileKey)) {
+                    try {
+                        const privateKey = fs.readFileSync(_settings.fileKey, 'utf8');
+                        const encryptedVault = fs.readFileSync(vaultFile, 'utf8').toString();
+                        const decryptedBuffer = crypto.privateDecrypt(
+                            {
+                                key: privateKey,
+                                padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
+                            },
+                            Buffer.from(encryptedVault, 'base64')
+                        );
+                        this.vaultData = JSON.parse(decryptedBuffer.toString('utf8'));
+                    } catch (error) {
+                        throw new Error('Failed to decrypt vault');
+                    }
+                } else {
+                    this.vaultData = JSON.parse(fs.readFileSync(vaultFile).toString());
+                }
+            } catch (e) {
+                console.error('Error parsing vault file:', e);
+                console.error('!!! Vault features might not work properly !!!');
+                this.vaultData = {};
+            }
+
+            if (this.vaultData?.encrypted && this.vaultData?.algorithm && this.vaultData?.data) {
+                //this is an encrypted vault we need to request the master key
+                this.setInteraction(this.getMasterKeyInteractive.bind(this));
+            }
+
+            for (let teamId in this.vaultData) {
+                for (let resourceId in this.vaultData[teamId]) {
+                    if (!this.index) this.index = {};
+                    if (!this.index[resourceId]) this.index[resourceId] = {};
+                    const value = this.vaultData[teamId][resourceId];
+                    this.index[resourceId][teamId] = value;
+                }
+            }
+        }
+    }
+
+    private initFileWatcher() {
+        this.watcher = chokidar.watch(this.vaultFile, {
+            persistent: false, // Don't keep the process running
+            ignoreInitial: true,
+        });
+
+        this.watcher.on('change', () => {
+            this.fetchVaultData(this.vaultFile, this._settings);
+        });
+    }
+
+    public async stop() {
+        super.stop();
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+    }
 }

package/src/types/LLM.types.ts

@@ -45,10 +45,47 @@ export type ILLMConnectorCredentials = BasicCredentials | BedrockCredentials | V
 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; // for usage reporting
-    credentials?: ILLMConnectorCredentials;
 
     prompt?: string;
     messages?: any[]; // TODO [Forhad]: apply proper typing
@@ -84,14 +121,15 @@ export type TLLMParams = {
     maxThinkingTokens?: number;
 
     // #region Search
+    // Web search parameters (will be organized into toolsInfo.webSearch internally)
     useWebSearch?: boolean;
-    webSearchContextSize?: 'high' | 'medium' | 'low';
+    webSearchContextSize?: TSearchContextSize;
     webSearchCity?: string;
     webSearchCountry?: string;
     webSearchRegion?: string;
     webSearchTimezone?: string;
 
-    // xAI specific search parameters
+    // xAI specific search parameters (consider moving to toolsInfo.xaiSearch)
     useSearch?: boolean;
     searchMode?: 'auto' | 'on' | 'off';
     returnCitations?: boolean;
@@ -111,7 +149,14 @@ export type TLLMParams = {
     // #endregion
 
     useReasoning?: boolean;
+    max_output_tokens?: number;
+    abortSignal?: AbortSignal;
+};
 
+export type TLLMPreparedParams = TLLMParams & {
+    body: any;
+    modelEntryName?: string; // for usage reporting
+    credentials?: ILLMConnectorCredentials;
     isUserKey?: boolean;
     capabilities?: {
         search?: boolean;
@@ -119,43 +164,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[];
-
-    // #region Search
-    useWebSearch?: boolean;
-    webSearchContextSize?: 'high' | 'medium' | 'low';
-    webSearchCity?: string;
-    webSearchCountry?: string;
-    webSearchRegion?: string;
-    webSearchTimezone?: string;
-    // #endregion
+    toolsInfo?: TToolsInfo;
 };
 
 export type TLLMConnectorParams = Omit<TLLMParams, 'model'> & {
@@ -207,6 +216,12 @@ export type TLLMModel = {
     //models can come with predefined params
     //this can also be used to pass a preconfigured model object
     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';
 };
 
 // #region [ Handle extendable LLM Providers ] ================================================
@@ -245,6 +260,7 @@ export type TVertexAISettings = {
     projectId: string;
     credentialsName: string;
     jsonCredentialsName: string;
+    apiEndpoint?: string;
 };
 
 export type TCustomLLMModel = TLLMModel & {
@@ -269,16 +285,47 @@ export type ToolData = {
     error?: string; // for Bedrock
 };
 
-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 {
@@ -397,6 +444,7 @@ export interface ILLMRequestContext {
     hasFiles?: boolean;
     modelInfo: TCustomLLMModel | TLLMModel;
     credentials: ILLMConnectorCredentials;
+    toolsInfo?: TToolsInfo;
 }
 
 // Generic interface that can be extended by specific providers

package/src/utils/data.utils.ts

@@ -7,6 +7,7 @@ import { isBinaryFileSync } from 'isbinaryfile';
 import { fileTypeFromBuffer } from 'file-type';
 import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
 import { identifyMimetypeFromString } from './string.utils';
+import { IAccessCandidate } from '@sre/types/ACL.types';
 
 // Helper function to convert stream to buffer
 export async function streamToBuffer(stream: Readable): Promise<Buffer> {
@@ -250,7 +251,7 @@ export async function getMimeType(data: any): Promise<string> {
 
 // Mask data like Buffer, FormData, etc. in debug output
 // TODO [Forhad]: Need to get the size of FormData
-export async function formatDataForDebug(data: any) {
+export async function formatDataForDebug(data: any, candidate: IAccessCandidate) {
     let dataForDebug;
 
     if (!data) {
@@ -259,7 +260,7 @@ export async function formatDataForDebug(data: any) {
 
     try {
         if (data.constructor?.name === 'BinaryInput') {
-            const jsonData = await data.getJsonData();
+            const jsonData = await data.getJsonData(candidate);
             dataForDebug = `[BinaryInput size=${jsonData?.size}]`;
         } else if (isBuffer(data)) {
             dataForDebug = `[Buffer size=${data.byteLength}]`;