@smythos/sre 1.6.14 → 1.7.5

package/src/subsystems/LLMManager/LLM.service/connectors/VertexAI.class.ts

@@ -24,6 +24,7 @@ import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.cla
 import { LLMConnector } from '../LLMConnector';
 import { SystemEvents } from '@sre/Core/SystemEvents';
 import { Logger } from '@sre/helpers/Log.helper';
+import { hookAsync } from '@sre/Core/HookService';
 
 const logger = Logger('VertexAIConnector');
 
@@ -49,6 +50,7 @@ export class VertexAIConnector extends LLMConnector {
         });
     }
 
+    @hookAsync('LLMConnector.request')
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
             logger.debug(`request ${this.name}`, acRequest.candidate);
@@ -110,6 +112,7 @@ export class VertexAIConnector extends LLMConnector {
         }
     }
 
+    @hookAsync('LLMConnector.streamRequest')
     protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
         const emitter = new EventEmitter();
 
@@ -380,51 +383,136 @@ export class VertexAIConnector extends LLMConnector {
     }): TLLMToolResultMessageBlock[] {
         const messageBlocks: TLLMToolResultMessageBlock[] = [];
 
+        const parseFunctionArgs = (args: unknown) => {
+            if (typeof args === 'string') {
+                try {
+                    return JSON.parse(args);
+                } catch {
+                    return args;
+                }
+            }
+            return args ?? {};
+        };
+
+        const parseFunctionResponse = (response: unknown): any => {
+            if (typeof response === 'string') {
+                try {
+                    const parsed = JSON.parse(response);
+                    if (typeof parsed === 'string' && parsed !== response) {
+                        return parseFunctionResponse(parsed);
+                    }
+                    return parsed;
+                } catch {
+                    return response;
+                }
+            }
+            return response ?? {};
+        };
+
         if (messageBlock) {
-            const parts = [];
+            const parts: any[] = [];
 
-            if (typeof messageBlock.content === 'string') {
-                parts.push({ text: messageBlock.content });
-            } else if (Array.isArray(messageBlock.content)) {
-                parts.push(...messageBlock.content);
+            if (Array.isArray(messageBlock.parts) && messageBlock.parts.length > 0) {
+                for (const part of messageBlock.parts) {
+                    if (!part) continue;
+
+                    if (typeof part.text === 'string' && part.text.trim()) {
+                        parts.push({ text: part.text.trim() });
+                        continue;
+                    }
+
+                    if (part.functionCall) {
+                        parts.push({
+                            functionCall: {
+                                name: part.functionCall.name,
+                                args: parseFunctionArgs(part.functionCall.args),
+                            },
+                        });
+                        continue;
+                    }
+
+                    if (part.functionResponse) {
+                        parts.push({
+                            functionResponse: {
+                                name: part.functionResponse.name,
+                                response: parseFunctionResponse(part.functionResponse.response),
+                            },
+                        });
+                        continue;
+                    }
+
+                    if ((part as any).inlineData) {
+                        parts.push({ inlineData: (part as any).inlineData });
+                    }
+                }
+            } else {
+                if (typeof messageBlock.content === 'string' && messageBlock.content.trim()) {
+                    parts.push({ text: messageBlock.content.trim() });
+                } else if (Array.isArray(messageBlock.content) && messageBlock.content.length > 0) {
+                    parts.push(...messageBlock.content);
+                }
             }
 
-            if (messageBlock.tool_calls) {
-                const functionCalls = messageBlock.tool_calls.map((toolCall: any) => ({
-                    functionCall: {
-                        name: toolCall?.function?.name,
-                        args:
-                            typeof toolCall?.function?.arguments === 'string'
-                                ? JSON.parse(toolCall.function.arguments)
-                                : toolCall?.function?.arguments || {},
-                    },
-                }));
+            if (Array.isArray(messageBlock.tool_calls) && messageBlock.tool_calls.length > 0) {
+                const functionCalls = messageBlock.tool_calls
+                    .map((toolCall: any) => {
+                        if (!toolCall?.function?.name) return undefined;
+                        return {
+                            functionCall: {
+                                name: toolCall.function.name,
+                                args: parseFunctionArgs(toolCall.function.arguments),
+                            },
+                        };
+                    })
+                    .filter(Boolean);
+
                 parts.push(...functionCalls);
             }
 
-            messageBlocks.push({
-                role: messageBlock.role,
-                parts,
-            });
+            const hasFunctionCall = parts.some((part) => part.functionCall);
+            if (!hasFunctionCall && toolsData.length > 0) {
+                toolsData.forEach((toolCall) => {
+                    parts.push({
+                        functionCall: {
+                            name: toolCall.name,
+                            args: parseFunctionArgs(toolCall.arguments),
+                        },
+                    });
+                });
+            }
+
+            if (parts.length > 0) {
+                let role = messageBlock.role;
+                if (role === TLLMMessageRole.Assistant) {
+                    role = TLLMMessageRole.Model;
+                } else if (role === TLLMMessageRole.Tool) {
+                    role = TLLMMessageRole.Function;
+                }
+
+                messageBlocks.push({
+                    role,
+                    parts,
+                });
+            }
         }
 
         // Transform tool results
-        const toolResults = toolsData.map((toolData) => ({
-            role: TLLMMessageRole.User,
-            parts: [
-                {
-                    functionResponse: {
-                        name: toolData.name,
-                        response: {
-                            name: toolData.name,
-                            content: toolData.result,
-                        },
-                    },
+        const functionResponseParts = toolsData
+            .filter((toolData) => toolData.result !== undefined)
+            .map((toolData) => ({
+                functionResponse: {
+                    name: toolData.name,
+                    response: parseFunctionResponse(toolData.result),
                 },
-            ],
-        }));
+            }));
+
+        if (functionResponseParts.length > 0) {
+            messageBlocks.push({
+                role: TLLMMessageRole.Function,
+                parts: functionResponseParts,
+            });
+        }
 
-        messageBlocks.push(...toolResults);
         return messageBlocks;
     }
 }

package/src/subsystems/LLMManager/LLM.service/connectors/openai/OpenAIConnector.class.ts

@@ -28,6 +28,7 @@ import { Logger } from '@sre/helpers/Log.helper';
 import { LLMConnector } from '../../LLMConnector';
 import { OpenAIApiInterface, OpenAIApiInterfaceFactory } from './apiInterfaces';
 import { HandlerDependencies } from './types';
+import { hookAsync } from '@sre/Core/HookService';
 
 const logger = Logger('OpenAIConnector');
 
@@ -69,31 +70,38 @@ export class OpenAIConnector extends LLMConnector {
         return responseInterface;
     }
 
-    protected async getClient(params: ILLMRequestContext): Promise<OpenAI> {
-        const apiKey = (params.credentials as BasicCredentials)?.apiKey;
-        const baseURL = params?.modelInfo?.baseURL;
+    protected async getClient(context: ILLMRequestContext): Promise<OpenAI> {
+        const apiKey = (context.credentials as BasicCredentials)?.apiKey || '';
+        const baseURL = context?.modelInfo?.baseURL;
 
-        const openai = new OpenAI({ baseURL, apiKey });
+        try {
+            const openai = new OpenAI({ baseURL, apiKey });
 
-        return openai;
+            return openai;
+        } catch (error) {
+            console.error('Error: on OpenAI client initialization', error);
+            throw error;
+        }
     }
 
+    @hookAsync('LLMConnector.request')
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
             logger.debug(`request ${this.name}`, acRequest.candidate);
             const _body = body as OpenAI.ChatCompletionCreateParams;
 
-            // #region Validate token limit
-            const messages = _body?.messages || [];
-            const lastMessage = messages[messages.length - 1];
-            const promptTokens = await this.computePromptTokens(messages, context);
-
-            await this.validateTokenLimit({
-                acRequest,
-                promptTokens,
-                context,
-                maxTokens: _body.max_completion_tokens,
-            });
+            // #region Validate the token limit only if it's a legacy model.
+            if (context?.modelEntryName?.startsWith('legacy/')) {
+                const messages = _body?.messages || [];
+                const promptTokens = await this.computePromptTokens(messages, context);
+
+                await this.validateTokenLimit({
+                    acRequest,
+                    promptTokens,
+                    context,
+                    maxTokens: _body.max_completion_tokens,
+                });
+            }
             // #endregion Validate token limit
 
             const responseInterface = this.getInterfaceType(context);
@@ -143,20 +151,23 @@ export class OpenAIConnector extends LLMConnector {
         }
     }
 
+    @hookAsync('LLMConnector.streamRequest')
     protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
         try {
             logger.debug(`streamRequest ${this.name}`, acRequest.candidate);
-            // #region Validate token limit
-            const messages = body?.messages || body?.input || [];
-            const lastMessage = messages[messages.length - 1];
-            const promptTokens = await this.computePromptTokens(messages, context);
-
-            await this.validateTokenLimit({
-                acRequest,
-                promptTokens,
-                context,
-                maxTokens: body.max_completion_tokens,
-            });
+
+            // #region Validate the token limit only if it's a legacy model.
+            if (context?.modelEntryName?.startsWith('legacy/')) {
+                const messages = body?.messages || body?.input || [];
+                const promptTokens = await this.computePromptTokens(messages, context);
+
+                await this.validateTokenLimit({
+                    acRequest,
+                    promptTokens,
+                    context,
+                    maxTokens: body.max_completion_tokens,
+                });
+            }
             // #endregion Validate token limit
 
             const responseInterface = this.getInterfaceType(context);

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

@@ -389,9 +389,10 @@ export class ChatCompletionsApiInterface extends OpenAIApiInterface {
      * Upload files to storage
      */
     private async uploadFiles(files: BinaryInput[], agentId: string): Promise<BinaryInput[]> {
+        const candidate = AccessCandidate.agent(agentId);
         const promises = files.map((file) => {
-            const binaryInput = BinaryInput.from(file);
-            return binaryInput.upload(AccessCandidate.agent(agentId)).then(() => binaryInput);
+            const binaryInput = BinaryInput.from(file, null, null, candidate);
+            return binaryInput.upload(candidate).then(() => binaryInput);
         });
 
         return Promise.all(promises);

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

@@ -1,6 +1,9 @@
 import EventEmitter from 'events';
 import OpenAI from 'openai';
 import type { Stream } from 'openai/streaming';
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
 
 import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
@@ -10,6 +13,7 @@ import { HandlerDependencies, TToolType } from '../types';
 import { SUPPORTED_MIME_TYPES_MAP } from '@sre/constants';
 import { SEARCH_TOOL_COSTS } from './constants';
 import { isValidOpenAIReasoningEffort } from './utils';
+import { uid } from '@sre/utils';
 
 // File size limits in bytes
 const MAX_IMAGE_SIZE = 20 * 1024 * 1024; // 20MB
@@ -30,6 +34,7 @@ const EVENT_TYPES = {
     FUNCTION_CALL_ARGUMENTS_DELTA: 'response.function_call_arguments.delta',
     FUNCTION_CALL_ARGUMENTS_DONE: 'response.function_call_arguments.done',
     OUTPUT_ITEM_DONE: 'response.output_item.done',
+    INCOMPLETE: 'response.incomplete',
 } as const;
 
 // Type definitions for web search events (augmenting SDK types locally)
@@ -176,6 +181,14 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
                             break;
                         }
 
+                        case EVENT_TYPES.INCOMPLETE:
+                            finishReason = 'incomplete';
+                            const responseData = (part as any)?.response;
+                            if (responseData?.usage) {
+                                usageData.push(responseData.usage);
+                            }
+                            break;
+
                         default: {
                             const eventType = String(part.type);
                             // Handle legacy started event if ever emitted
@@ -257,12 +270,12 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
 
         // Emit interrupted event if finishReason is not 'stop'
         if (finishReason !== 'stop') {
-            emitter.emit('interrupted', finishReason);
+            emitter.emit(TLLMEvent.Interrupted, finishReason);
         }
 
         // Emit end event with setImmediate to ensure proper event ordering
         setImmediate(() => {
-            emitter.emit('end', toolsData, reportedUsage, finishReason);
+            emitter.emit(TLLMEvent.End, toolsData, reportedUsage, finishReason);
         });
     }
 
@@ -790,8 +803,62 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
         return Promise.all(promises);
     }
 
+    /**
+     * Upload file to OpenAI Files API
+     * Similar to GoogleAI's uploadFile implementation
+     */
+    private async uploadFile({
+        file,
+        agentId,
+        purpose = 'user_data',
+    }: {
+        file: BinaryInput;
+        agentId: string;
+        purpose?: 'user_data' | 'assistants' | 'batch' | 'fine-tune' | 'vision';
+    }): Promise<{ fileId: string; filename: string }> {
+        try {
+            if (!file?.mimetype) {
+                throw new Error('Missing required parameters to upload file to OpenAI!');
+            }
+
+            const tempDir = os.tmpdir();
+            const fileName = await file.getName();
+            const tempFilePath = path.join(tempDir, `${uid()}_${fileName}`);
+
+            // Write file to temporary location
+            const bufferData = await file.readData(AccessCandidate.agent(agentId));
+            await fs.promises.writeFile(tempFilePath, new Uint8Array(bufferData));
+
+            const openai = await this.deps.getClient(this.context);
+
+            // Upload file to OpenAI Files API
+            const uploadResponse = await openai.files.create({
+                file: fs.createReadStream(tempFilePath),
+                purpose: purpose,
+            });
+
+            const fileId = uploadResponse.id;
+            if (!fileId) {
+                throw new Error('File upload did not return a file ID.');
+            }
+
+            // Clean up temporary file
+            await fs.promises.unlink(tempFilePath).catch(() => {
+                // Ignore cleanup errors
+            });
+
+            return {
+                fileId,
+                filename: fileName,
+            };
+        } catch (error: any) {
+            throw new Error(`Error uploading file to OpenAI: ${error.message}`);
+        }
+    }
+
     /**
      * Process image files with Responses API specific formatting
+     * Uses OpenAI Files API for uploading images
      */
     private async processImageData(files: BinaryInput[], agentId: string): Promise<any[]> {
         if (files.length === 0) return [];
@@ -800,14 +867,30 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
         for (const file of files) {
             await this.validateFileSize(file, MAX_IMAGE_SIZE, 'Image');
 
-            const bufferData = await file.readData(AccessCandidate.agent(agentId));
-            const base64Data = bufferData.toString('base64');
-            const url = `data:${file.mimetype};base64,${base64Data}`;
+            try {
+                // Upload file to OpenAI Files API with 'vision' purpose
+                const { fileId } = await this.uploadFile({
+                    file,
+                    agentId,
+                    purpose: 'vision',
+                });
 
-            imageData.push({
-                type: 'input_image',
-                image_url: url,
-            });
+                imageData.push({
+                    type: 'input_image',
+                    file_id: fileId,
+                });
+            } catch (error) {
+                // If Files API upload fails, fall back to base64 inline data
+                console.warn('Failed to upload image via Files API, falling back to base64:', error);
+                const bufferData = await file.readData(AccessCandidate.agent(agentId));
+                const base64Data = bufferData.toString('base64');
+                const url = `data:${file.mimetype};base64,${base64Data}`;
+
+                imageData.push({
+                    type: 'input_image',
+                    image_url: url,
+                });
+            }
         }
 
         return imageData;
@@ -815,6 +898,7 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
 
     /**
      * Process document files with Responses API specific formatting
+     * Uses OpenAI Files API for uploading documents
      */
     private async processDocumentData(files: BinaryInput[], agentId: string): Promise<any[]> {
         if (files.length === 0) return [];
@@ -823,18 +907,31 @@ export class ResponsesApiInterface extends OpenAIApiInterface {
         for (const file of files) {
             await this.validateFileSize(file, MAX_DOCUMENT_SIZE, 'Document');
 
-            const bufferData = await file.readData(AccessCandidate.agent(agentId));
-            const base64Data = bufferData.toString('base64');
-            const fileData = `data:${file.mimetype};base64,${base64Data}`;
-            const filename = await file.getName();
-
-            documentData.push({
-                type: 'input_file',
-                file: {
-                    file_data: fileData,
+            try {
+                // Upload file to OpenAI Files API with 'user_data' purpose
+                const { fileId, filename } = await this.uploadFile({
+                    file,
+                    agentId,
+                    purpose: 'user_data',
+                });
+
+                documentData.push({
+                    type: 'input_file',
+                    file_id: fileId,
+                });
+            } catch (error) {
+                // If Files API upload fails, fall back to base64 inline data
+                console.warn('Failed to upload document via Files API, falling back to base64:', error);
+                const bufferData = await file.readData(AccessCandidate.agent(agentId));
+                const base64Data = bufferData.toString('base64');
+                const filename = await file.getName();
+
+                documentData.push({
+                    type: 'input_file',
                     filename,
-                },
-            });
+                    file_data: `data:${file.mimetype};base64,${base64Data}`,
+                });
+            }
         }
 
         return documentData;

package/src/subsystems/LLMManager/LLM.service/connectors/xAI.class.ts

@@ -20,6 +20,7 @@ import { LLMHelper } from '@sre/LLMManager/LLM.helper';
 import { LLMConnector } from '../LLMConnector';
 import { SystemEvents } from '@sre/Core/SystemEvents';
 import { Logger } from '@sre/helpers/Log.helper';
+import { hookAsync } from '@sre/Core/HookService';
 
 const logger = Logger('xAIConnector');
 
@@ -97,6 +98,7 @@ export class xAIConnector extends LLMConnector {
         });
     }
 
+    @hookAsync('LLMConnector.request')
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
             logger.debug(`request ${this.name}`, acRequest.candidate);
@@ -153,6 +155,7 @@ export class xAIConnector extends LLMConnector {
         }
     }
 
+    @hookAsync('LLMConnector.streamRequest')
     protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
         const emitter = new EventEmitter();
 

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

@@ -193,11 +193,11 @@ export abstract class ModelsProviderConnector extends SecureConnector {
             modelInfo = models?.[model as string];
         }
 
+        // TODO: We will clean up `keyOptions` in the future but keep it for legacy users.
         const aliasKeyOptions = aliasModelInfo && hasAPIKey ? aliasModelInfo?.keyOptions : null;
-
         const modelKeyOptions = modelInfo?.keyOptions || aliasKeyOptions;
 
-        return { ...aliasModelInfo, ...modelInfo, ...aliasKeyOptions, ...modelKeyOptions, modelId };
+        return { ...modelInfo, ...aliasModelInfo, ...aliasKeyOptions, ...modelKeyOptions, modelId };
     }
 
     protected async getModelId(acRequest: AccessRequest, models: TLLMModelsList, model: string | TLLMModel | TCustomLLMModel): Promise<string> {
@@ -394,12 +394,7 @@ export abstract class ModelsProviderConnector extends SecureConnector {
                     baseURL: entry.baseURL,
                     fallbackLLM: entry.fallbackLLM,
                     isUserCustomLLM: true,
-
-                    // TODO: Credentials will usually look like { apiKey: 'api-key-goes-here' }.
-                    //       However, for fallback models we also need to handle ['vault', 'internal']
-                    //       using the same credentials format, since fallback models can be either
-                    //       personal or built-in.
-                    credentials: entry?.credentials || ['vault', 'internal'],
+                    credentials: entry?.credentials || {},
                 };
             }
 

package/src/subsystems/LLMManager/ModelsProvider.service/connectors/JSONModelsProvider.class.ts

@@ -170,11 +170,13 @@ export class JSONModelsProvider extends ModelsProviderConnector {
                 }
             } else if (typeof modelData === 'object' && !Array.isArray(modelData)) {
                 // Object of models case
+                let models = '';
                 for (const [modelId, model] of Object.entries(modelData)) {
                     try {
                         if (this.isValidSingleModel(model)) {
                             validModels[modelId] = model as TLLMModel;
-                            console.debug(`Loaded model: ${modelId}`);
+                            //console.debug(`Loaded model: ${modelId}`);
+                            models += `${modelId} `;
                         } else {
                             console.warn(`Invalid model format for model "${modelId}"`);
                         }
@@ -183,6 +185,7 @@ export class JSONModelsProvider extends ModelsProviderConnector {
                         // Continue processing other models instead of failing the whole file
                     }
                 }
+                console.debug(`Loaded models: ${models}`);
             } else {
                 console.warn(`Invalid format (not a model or object of models)`);
             }

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

@@ -111,6 +111,18 @@ export class RedisCache extends CacheConnector {
 
     @SecureConnector.AccessControl
     public async setMetadata(acRequest: AccessRequest, key: string, metadata: CacheMetadata): Promise<void> {
+        if (metadata.acl) {
+            //preserve the ownership of the metadata
+            const newACL = ACL.from(metadata.acl).addAccess(acRequest.candidate.role, acRequest.candidate.id, TAccessLevel.Owner).ACL;
+            metadata.acl = newACL;
+        }
+
+        //no ACL present ==> preserve the existing ACL
+        if (!metadata.acl) {
+            const curACL = await this.getACL(acRequest, key);
+            metadata.acl = curACL;
+        }
+
         await this.setMetadataWithTTL(acRequest, key, metadata);
     }
     private async setMetadataWithTTL(acRequest: AccessRequest, key: string, metadata: CacheMetadata, ttl?: number): Promise<void> {

package/src/subsystems/MemoryManager/LLMContext.ts

@@ -25,7 +25,7 @@ export class LLMContext {
     public contextLength: number;
 
     private _messages: any[] = [];
-    public get messages() {        
+    public get messages() {
         return this._messages;
     }
 
@@ -36,16 +36,11 @@ export class LLMContext {
      *
      * @param source a messages[] object, or smyth file system uri (smythfs://...)
      */
-    constructor(
-        private llmInference,
-        _systemPrompt: string = '',
-        llmContextStore?: ILLMContextStore,
-    ) {
+    constructor(private llmInference, _systemPrompt: string = '', llmContextStore?: ILLMContextStore) {
         this._llmCache = new LLMCache(AccessCandidate.team(this.llmInference.teamId));
         //this._systemPrompt = _systemPrompt;
         this.systemPrompt = _systemPrompt;
 
-        
         if (llmContextStore) {
             this._llmContextStore = llmContextStore;
             this._llmContextStore.load().then((messages) => {
@@ -57,7 +52,7 @@ export class LLMContext {
 
     private push(...message: any[]) {
         this._messages.push(...message);
-        
+
         if (this._llmContextStore) {
             this._llmContextStore.save(this._messages);
         }