@smythos/sre 1.6.14 → 1.7.1

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

@@ -1,4 +1,4 @@
-import { Ollama, ChatResponse } from 'ollama';
+import { Ollama, ChatResponse, type ChatRequest } from 'ollama';
 import EventEmitter from 'events';
 
 import { JSON_RESPONSE_INSTRUCTION, BUILT_IN_MODEL_PREFIX } from '@sre/constants';
@@ -14,12 +14,14 @@ import {
     TLLMPreparedParams,
     TLLMToolResultMessageBlock,
     TLLMRequestBody,
+    BasicCredentials,
 } from '@sre/types/LLM.types';
 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('OllamaConnector');
 
@@ -44,33 +46,37 @@ export class OllamaConnector extends LLMConnector {
         // Extract baseURL and sanitize it for Ollama SDK
         let host = 'http://localhost:11434';
 
-        if (context.modelInfo.baseURL) {
-            // Handle baseURL that might include /api/ suffix
-            const baseURL = context.modelInfo.baseURL;
-            if (baseURL.endsWith('/api/')) {
-                // Remove /api/ suffix to get the root host
-                host = baseURL.replace(/\/api\/$/, '');
-            } else if (baseURL.endsWith('/api')) {
-                // Remove /api suffix
-                host = baseURL.replace(/\/api$/, '');
-            } else {
-                host = baseURL;
-            }
+        const apiKey = (context.credentials as BasicCredentials)?.apiKey;
+        const baseURL = context?.modelInfo?.baseURL;
+
+        if (baseURL) {
+            // Extract base URL (origin) using URL class
+            const url = new URL(baseURL);
+            host = url.origin;
+        }
+
+        const config: { host: string; headers?: { Authorization?: string } } = { host };
+
+        if (apiKey) {
+            config.headers = {
+                Authorization: `Bearer ${apiKey}`,
+            };
         }
 
         // No API key validation required for Ollama (local by default)
-        return new Ollama({ host });
+        return new Ollama(config);
     }
 
+    @hookAsync('LLMConnector.request')
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
             logger.debug(`request ${this.name}`, acRequest.candidate);
             const ollama = this.getClient(context);
 
-            const result = await ollama.chat({
+            const result = (await ollama.chat({
                 ...body,
                 stream: false,
-            }) as unknown as ChatResponse;
+            })) as unknown as ChatResponse;
 
             const message = result.message;
             const finishReason = result.done_reason || 'stop';
@@ -117,6 +123,7 @@ export class OllamaConnector extends LLMConnector {
         }
     }
 
+    @hookAsync('LLMConnector.streamRequest')
     protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
         try {
             logger.debug(`streamRequest ${this.name}`, acRequest.candidate);
@@ -124,10 +131,10 @@ export class OllamaConnector extends LLMConnector {
             const usage_data = [];
 
             const ollama = this.getClient(context);
-            const stream = await ollama.chat({
+            const stream = (await ollama.chat({
                 ...body,
                 stream: true,
-            }) as AsyncIterable<ChatResponse>;
+            })) as AsyncIterable<ChatResponse>;
 
             let toolsData: ToolData[] = [];
             let fullContent = '';
@@ -159,7 +166,7 @@ export class OllamaConnector extends LLMConnector {
                                     toolsData[index].arguments += toolCall.function.arguments;
                                 } else {
                                     // For object arguments, merge them properly
-                                    toolsData[index].arguments = { ...toolsData[index].arguments as any, ...toolCall.function?.arguments };
+                                    toolsData[index].arguments = { ...(toolsData[index].arguments as any), ...toolCall.function?.arguments };
                                 }
                             }
                         });
@@ -237,7 +244,7 @@ export class OllamaConnector extends LLMConnector {
 
         // Handle tools
         if (params.toolsConfig?.tools) {
-            body.tools = params.toolsConfig.tools.map(tool => ({
+            body.tools = params.toolsConfig.tools.map((tool) => ({
                 type: 'function',
                 function: {
                     name: tool.function.name,
@@ -359,4 +366,4 @@ export class OllamaConnector extends LLMConnector {
             return _message;
         });
     }
-}
+}

package/src/subsystems/LLMManager/LLM.service/connectors/Perplexity.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('PerplexityConnector');
 
@@ -58,6 +59,7 @@ export class PerplexityConnector extends LLMConnector {
         });
     }
 
+    @hookAsync('LLMConnector.request')
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
             logger.debug(`request ${this.name}`, acRequest.candidate);
@@ -89,6 +91,7 @@ export class PerplexityConnector extends LLMConnector {
         }
     }
 
+    @hookAsync('LLMConnector.streamRequest')
     protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
         //throw new Error('Multimodal request is not supported for Perplexity.');
         //fallback to chatRequest

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/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
@@ -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

@@ -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 || {},
                 };
             }