@smythos/sre 1.6.14 → 1.7.1

package/src/subsystems/AgentManager/Scheduler.service/index.ts

@@ -0,0 +1,11 @@
+//==[ SRE: Scheduler ]======================
+
+import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
+import { TConnectorService } from '@sre/types/SRE.types';
+import { LocalScheduler } from './connectors/LocalScheduler.class';
+
+export class SchedulerService extends ConnectorServiceProvider {
+    public register() {
+        ConnectorService.register(TConnectorService.Scheduler, 'LocalScheduler', LocalScheduler);
+    }
+}

package/src/subsystems/IO/VectorDB.service/connectors/MilvusVectorDB.class.ts

@@ -205,7 +205,7 @@ export class MilvusVectorDB extends VectorDBConnector {
         }
 
         const result = await this.client.search({
-            vector: _vector as number[],
+            data: _vector as number[],
             collection_name: preparedNs,
             output_fields: ['id', 'text', this.USER_METADATA_KEY, 'namespaceId', 'datasourceId', 'datasourceLabel', 'vector'],
             limit: options.topK || 10,

package/src/subsystems/LLMManager/LLM.service/LLMCredentials.helper.ts

@@ -1,6 +1,7 @@
 import { ConnectorService } from '@sre/Core/ConnectorsService';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
 import { TBedrockSettings, TCustomLLMModel, TLLMCredentials, TLLMModel, TVertexAISettings } from '@sre/types/LLM.types';
+import { TemplateString, Match } from '@sre/helpers/TemplateString.helper';
 
 export async function getLLMCredentials(candidate: AccessCandidate, modelInfo: TLLMModel | TCustomLLMModel) {
     //create a credentials list that we can iterate over
@@ -11,8 +12,16 @@ export async function getLLMCredentials(candidate: AccessCandidate, modelInfo: T
 
     for (let credentialsMode of credentialsList) {
         if (typeof credentialsMode === 'object') {
-            //credentials passed directly
-            return credentialsMode;
+            // Resolve key templates for each property in the credentials object
+            const resolvedCredentials: any = {};
+
+            for (const [key, value] of Object.entries(credentialsMode)) {
+                // Resolve {{KEY(...)}} templates from vault (supports nested objects)
+                resolvedCredentials[key] = await resolveKeyTemplate(value, candidate);
+            }
+
+            //credentials passed directly (resolved from vault templates if any)
+            return resolvedCredentials;
         }
 
         switch (credentialsMode) {
@@ -169,3 +178,53 @@ async function getVertexAICredentials(candidate: AccessCandidate, modelInfo: TCu
     if (!credentials) return null;
     return { ...credentials, isUserKey: true };
 }
+
+/**
+ * Creates a vault key processor for the TemplateString helper that works with AccessCandidate
+ * @param candidate - The access candidate requesting the credentials
+ * @returns A processor function that resolves vault keys using the candidate's permissions
+ * @private
+ */
+function createVaultKeyProcessor(candidate: AccessCandidate): (token: string) => Promise<string> {
+    return async (token: string) => {
+        try {
+            const vaultConnector = ConnectorService.getVaultConnector();
+            return await vaultConnector.requester(candidate).get(token);
+        } catch (error) {
+            return '';
+        }
+    };
+}
+
+/**
+ * Resolves a vault key template by fetching the value from the vault
+ * Uses the TemplateString helper to parse {{KEY(...)}} templates
+ * Recursively handles nested objects and arrays
+ * @param value - The value to resolve (can be a template string, object, array, or primitive)
+ * @param candidate - The access candidate requesting the credentials
+ * @returns Promise resolving to the vault value or the original value if not a template
+ * @private
+ */
+async function resolveKeyTemplate(value: any, candidate: AccessCandidate): Promise<any> {
+    // Handle strings with templates
+    if (typeof value === 'string') {
+        return await TemplateString(value).process(createVaultKeyProcessor(candidate), Match.fn('KEY')).asyncResult;
+    }
+
+    // Handle arrays recursively
+    if (Array.isArray(value)) {
+        return await Promise.all(value.map((item) => resolveKeyTemplate(item, candidate)));
+    }
+
+    // Handle nested objects recursively
+    if (typeof value === 'object' && value !== null) {
+        const resolvedObject: any = {};
+        for (const [key, val] of Object.entries(value)) {
+            resolvedObject[key] = await resolveKeyTemplate(val, candidate);
+        }
+        return resolvedObject;
+    }
+
+    // Return primitives as-is
+    return value;
+}

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

@@ -26,6 +26,7 @@ import { LLMConnector } from '../LLMConnector';
 import { SystemEvents } from '@sre/Core/SystemEvents';
 import { SUPPORTED_MIME_TYPES_MAP } from '@sre/constants';
 import { Logger } from '@sre/helpers/Log.helper';
+import { hookAsync } from '@sre/Core/HookService';
 
 const logger = Logger('AnthropicConnector');
 
@@ -50,6 +51,7 @@ export class AnthropicConnector extends LLMConnector {
         return new Anthropic({ apiKey });
     }
 
+    @hookAsync('LLMConnector.request')
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
             logger.debug(`request ${this.name}`, acRequest.candidate);
@@ -113,6 +115,7 @@ export class AnthropicConnector 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/Bedrock.class.ts

@@ -31,6 +31,7 @@ import { LLMConnector } from '../LLMConnector';
 import { JSONContent } from '@sre/helpers/JsonContent.helper';
 import { SystemEvents } from '@sre/Core/SystemEvents';
 import { Logger } from '@sre/helpers/Log.helper';
+import { hookAsync } from '@sre/Core/HookService';
 
 const logger = Logger('BedrockConnector');
 
@@ -51,6 +52,7 @@ export class BedrockConnector extends LLMConnector {
         });
     }
 
+    @hookAsync('LLMConnector.request')
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
             logger.debug(`request ${this.name}`, acRequest.candidate);
@@ -99,7 +101,7 @@ export class BedrockConnector extends LLMConnector {
             throw error?.error || error;
         }
     }
-
+    @hookAsync('LLMConnector.streamRequest')
     protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
         const emitter = new EventEmitter();
 

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

@@ -3,12 +3,15 @@ import { LLMConnector } from '../LLMConnector';
 import EventEmitter from 'events';
 import { APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMPreparedParams } from '@sre/types/LLM.types';
 import { Logger } from '@sre/helpers/Log.helper';
+import { delay } from '@sre/utils/index';
+import { hookAsync } from '@sre/Core/HookService';
 
 const logger = Logger('EchoConnector');
 
 export class EchoConnector extends LLMConnector {
     public name = 'LLM:Echo';
 
+    @hookAsync('LLMConnector.request')
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
             logger.debug(`request ${this.name}`, acRequest.candidate);
@@ -27,6 +30,7 @@ export class EchoConnector extends LLMConnector {
         }
     }
 
+    @hookAsync('LLMConnector.streamRequest')
     protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
         try {
             logger.debug(`streamRequest ${this.name}`, acRequest.candidate);
@@ -45,7 +49,7 @@ export class EchoConnector extends LLMConnector {
 
                 for (let i = 0; i < chunks.length; i++) {
                     // Simulate network delay
-                    await new Promise((resolve) => setTimeout(resolve, 50));
+                    await delay(10);
 
                     const isLastChunk = i === chunks.length - 1;
                     // Add space between chunks except for the last one to avoid trailing space in file URLs

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);