@smythos/sre 1.6.14 → 1.7.5

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

@@ -3,12 +3,7 @@ import path from 'path';
 import EventEmitter from 'events';
 import fs from 'fs';
 
-import {
-    GoogleGenAI,
-    FunctionCallingConfigMode,
-    FileState,
-    type GenerateContentResponseUsageMetadata,
-} from '@google/genai/node';
+import { GoogleGenAI, FunctionCallingConfigMode, FileState, type GenerateContentResponseUsageMetadata } from '@google/genai/node';
 
 import { JSON_RESPONSE_INSTRUCTION, BUILT_IN_MODEL_PREFIX } from '@sre/constants';
 import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
@@ -40,6 +35,7 @@ import { SUPPORTED_MIME_TYPES_MAP } from '@sre/constants';
 import { Logger } from '@sre/helpers/Log.helper';
 
 import { LLMConnector } from '../LLMConnector';
+import { hookAsync } from '@sre/Core/HookService';
 
 const logger = Logger('GoogleAIConnector');
 
@@ -90,6 +86,7 @@ export class GoogleAIConnector extends LLMConnector {
         return new GoogleGenAI({ apiKey });
     }
 
+    @hookAsync('LLMConnector.request')
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
             logger.debug(`request ${this.name}`, acRequest.candidate);
@@ -160,6 +157,7 @@ export class GoogleAIConnector extends LLMConnector {
         }
     }
 
+    @hookAsync('LLMConnector.streamRequest')
     protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
         logger.debug(`streamRequest ${this.name}`, acRequest.candidate);
         const emitter = new EventEmitter();
@@ -436,9 +434,10 @@ export class GoogleAIConnector extends LLMConnector {
         return body;
     }
 
-    private normalizePrompt(
-        prompt: TGoogleAIRequestBody['messages'] | TGoogleAIRequestBody['contents']
-    ): { contents: any; config?: Record<string, any> } {
+    private normalizePrompt(prompt: TGoogleAIRequestBody['messages'] | TGoogleAIRequestBody['contents']): {
+        contents: any;
+        config?: Record<string, any>;
+    } {
         if (prompt == null) {
             return { contents: '' };
         }
@@ -627,87 +626,279 @@ export class GoogleAIConnector extends LLMConnector {
     }): TLLMToolResultMessageBlock[] {
         const messageBlocks: TLLMToolResultMessageBlock[] = [];
 
-        if (messageBlock) {
-            const content = [];
-            if (typeof messageBlock.content === 'string') {
-                content.push({ text: messageBlock.content });
-            } else if (Array.isArray(messageBlock.content)) {
-                content.push(...messageBlock.content);
+        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.parts) {
-                const functionCalls = messageBlock.parts.filter((part) => part.functionCall);
-                if (functionCalls.length > 0) {
-                    content.push(
-                        ...functionCalls.map((call) => ({
+        if (messageBlock) {
+            const content: any[] = [];
+
+            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()) {
+                        content.push({ text: part.text.trim() });
+                        continue;
+                    }
+
+                    if (part.functionCall) {
+                        content.push({
                             functionCall: {
-                                name: call.functionCall.name,
-                                args: JSON.parse(call.functionCall.args),
+                                name: part.functionCall.name,
+                                args: parseFunctionArgs(part.functionCall.args),
                             },
-                        }))
-                    );
+                        });
+                        continue;
+                    }
+
+                    if (part.functionResponse) {
+                        content.push({
+                            functionResponse: {
+                                name: part.functionResponse.name,
+                                response: parseFunctionResponse(part.functionResponse.response),
+                            },
+                        });
+                        continue;
+                    }
+
+                    if ((part as any).inlineData) {
+                        content.push({ inlineData: (part as any).inlineData });
+                    }
+                }
+            } else {
+                if (typeof messageBlock.content === 'string' && messageBlock.content.trim()) {
+                    content.push({ text: messageBlock.content.trim() });
+                } else if (Array.isArray(messageBlock.content) && messageBlock.content.length > 0) {
+                    content.push(...messageBlock.content);
+                }
+            }
+
+            const hasFunctionCall = content.some((part) => part.functionCall);
+            if (!hasFunctionCall && toolsData.length > 0) {
+                toolsData.forEach((toolCall) => {
+                    content.push({
+                        functionCall: {
+                            name: toolCall.name,
+                            args: parseFunctionArgs(toolCall.arguments),
+                        },
+                    });
+                });
+            }
+
+            if (content.length > 0) {
+                let role = messageBlock.role;
+                if (role === TLLMMessageRole.Assistant) {
+                    role = TLLMMessageRole.Model;
                 }
+
+                messageBlocks.push({
+                    role,
+                    parts: content,
+                });
             }
+        }
+
+        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: messageBlock.role,
-                parts: content,
+                role: TLLMMessageRole.Function,
+                parts: functionResponseParts,
             });
         }
 
-        const transformedToolsData = toolsData.map(
-            (toolData): TLLMToolResultMessageBlock => ({
-                role: TLLMMessageRole.User,
-                parts: [
-                    {
-                        functionResponse: {
-                            name: toolData.name,
-                            response: {
-                                name: toolData.name,
-                                content: typeof toolData.result === 'string' ? toolData.result : JSON.stringify(toolData.result),
-                            },
-                        },
-                    },
-                ],
-            })
-        );
-
-        return [...messageBlocks, ...transformedToolsData];
+        return messageBlocks;
     }
 
     public getConsistentMessages(messages: TLLMMessageBlock[]): TLLMMessageBlock[] {
         const _messages = LLMHelper.removeDuplicateUserMessages(messages);
 
         return _messages.map((message) => {
-            const _message = { ...message };
-            let textContent = '';
+            const _message: TLLMMessageBlock = { ...message };
+
+            const parseFunctionArgs = (args: unknown) => {
+                if (typeof args === 'string') {
+                    try {
+                        return JSON.parse(args);
+                    } catch {
+                        return args;
+                    }
+                }
+
+                return args ?? {};
+            };
+
+            const parseFunctionResponse = (response: unknown) => {
+                if (typeof response === 'string') {
+                    try {
+                        return JSON.parse(response);
+                    } catch {
+                        return response;
+                    }
+                }
+
+                return response;
+            };
+
+            const pushTextPart = (parts: any[], text?: string) => {
+                const value = typeof text === 'string' && text.trim() ? text : undefined;
+                if (value) {
+                    parts.push({ text: value });
+                }
+            };
+
+            const normalizedParts: any[] = [];
 
             // Map roles to valid Google AI roles
             switch (_message.role) {
                 case TLLMMessageRole.Assistant:
                 case TLLMMessageRole.System:
+                case TLLMMessageRole.Model:
                     _message.role = TLLMMessageRole.Model;
                     break;
+                case TLLMMessageRole.Function:
+                case TLLMMessageRole.Tool:
+                    _message.role = TLLMMessageRole.Function;
+                    break;
                 case TLLMMessageRole.User:
-                    // User role is already valid
                     break;
                 default:
-                    _message.role = TLLMMessageRole.User; // Default to user for unknown roles
+                    _message.role = TLLMMessageRole.User;
             }
 
-            // * empty text causes error that's why we added '...'
+            if (Array.isArray(message?.parts)) {
+                for (const part of message.parts) {
+                    if (!part) continue;
+
+                    const normalizedPart: any = { ...part };
+
+                    if (typeof normalizedPart.text === 'string') {
+                        normalizedPart.text = normalizedPart.text.trim() || '...';
+                    }
+
+                    if (part.functionCall) {
+                        normalizedPart.functionCall = {
+                            name: part.functionCall.name,
+                            args: parseFunctionArgs(part.functionCall.args),
+                        };
+                    }
+
+                    if (part.functionResponse) {
+                        normalizedPart.functionResponse = {
+                            name: part.functionResponse.name,
+                            response: parseFunctionResponse(part.functionResponse.response),
+                        };
+                    }
+
+                    const hasMeaningfulContent = Object.values(normalizedPart).some((value) => value !== undefined && value !== null && value !== '');
+
+                    if (hasMeaningfulContent) {
+                        normalizedParts.push(normalizedPart);
+                    }
+                }
+            }
+
+            if (!normalizedParts.length && Array.isArray(message?.content)) {
+                for (const contentPart of message.content) {
+                    if (!contentPart) continue;
+
+                    if (typeof contentPart === 'string') {
+                        pushTextPart(normalizedParts, contentPart);
+                    } else if (typeof contentPart === 'object') {
+                        if ('text' in contentPart && typeof contentPart.text === 'string') {
+                            pushTextPart(normalizedParts, contentPart.text);
+                        } else if ('functionCall' in contentPart && (contentPart as any).functionCall) {
+                            const functionCallPart = (contentPart as any).functionCall;
+                            normalizedParts.push({
+                                functionCall: {
+                                    name: functionCallPart.name,
+                                    args: parseFunctionArgs(functionCallPart.args),
+                                },
+                            });
+                        } else if ('functionResponse' in contentPart && (contentPart as any).functionResponse) {
+                            const functionResponsePart = (contentPart as any).functionResponse;
+                            normalizedParts.push({
+                                functionResponse: {
+                                    name: functionResponsePart.name,
+                                    response: parseFunctionResponse(functionResponsePart.response),
+                                },
+                            });
+                        } else {
+                            const fallbackText = typeof (contentPart as any)?.toString === 'function' ? (contentPart as any).toString() : '';
+                            if (fallbackText && fallbackText !== '[object Object]') {
+                                pushTextPart(normalizedParts, fallbackText);
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (!normalizedParts.length) {
+                if (typeof message?.content === 'string') {
+                    pushTextPart(normalizedParts, message.content);
+                } else if (message?.content && typeof message.content === 'object') {
+                    if ('text' in (message.content as any)) {
+                        pushTextPart(normalizedParts, (message.content as any).text);
+                    } else {
+                        const fallbackText = typeof (message.content as any)?.toString === 'function' ? (message.content as any).toString() : '';
+                        if (fallbackText && fallbackText !== '[object Object]') {
+                            pushTextPart(normalizedParts, fallbackText);
+                        }
+                    }
+                }
+            }
+
+            if (Array.isArray(message?.tool_calls) && message.tool_calls.length > 0) {
+                for (const toolCall of message.tool_calls) {
+                    if (!toolCall?.function?.name) continue;
+
+                    normalizedParts.push({
+                        functionCall: {
+                            name: toolCall.function.name,
+                            args: parseFunctionArgs(toolCall.function.arguments),
+                        },
+                    });
+                }
+            }
 
-            if (_message?.parts) {
-                textContent = _message.parts.map((textBlock) => textBlock?.text || '...').join(' ');
-            } else if (Array.isArray(_message?.content)) {
-                textContent = _message.content.map((textBlock) => textBlock?.text || '...').join(' ');
-            } else if (_message?.content) {
-                textContent = (_message.content as string) || '...';
+            if (!normalizedParts.length) {
+                normalizedParts.push({ text: '...' });
             }
 
-            _message.parts = [{ text: textContent || '...' }];
+            _message.parts = normalizedParts as any;
 
             delete _message.content; // Remove content to avoid error
+            delete (_message as any).tool_calls;
 
             return _message;
         });

package/src/subsystems/LLMManager/LLM.service/connectors/Groq.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('GroqConnector');
 
@@ -50,6 +51,7 @@ export class GroqConnector extends LLMConnector {
         return new Groq({ apiKey });
     }
 
+    @hookAsync('LLMConnector.request')
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
             logger.debug(`request ${this.name}`, acRequest.candidate);
@@ -95,6 +97,7 @@ export class GroqConnector extends LLMConnector {
         }
     }
 
+    @hookAsync('LLMConnector.streamRequest')
     protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
         try {
             logger.debug(`streamRequest ${this.name}`, acRequest.candidate);

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