@smythos/sre 1.5.53 → 1.5.54

package/src/Components/MemoryWriteKeyVal.class.ts

@@ -1,62 +1,62 @@
-import Joi from 'joi';
-
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { Component } from './Component.class';
-import { ConnectorService } from '@sre/Core/ConnectorsService';
-import { TemplateString } from '@sre/helpers/TemplateString.helper';
-import { ICacheRequest } from '@sre/MemoryManager/Cache.service/CacheConnector';
-
-const memory = {};
-export class MemoryWriteKeyVal extends Component {
-    protected configSchema = Joi.object({
-        memoryName: Joi.string().max(255).allow('').label('Memory Name'),
-        key: Joi.string().max(255).allow('').label('Key'),
-        value: Joi.string().max(100000).allow('').label('Value'),
-        scope: Joi.string().max(20).allow('').label('Scope'),
-        ttl: Joi.number().min(300).max(604800).allow('').label('TTL'),
-    });
-    constructor() {
-        super();
-    }
-    init() {}
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-
-        const logger = this.createComponentLogger(agent, config);
-
-        try {
-            const cacheConnector = ConnectorService.getCacheConnector();
-            const connectorRequester: ICacheRequest = cacheConnector.agent(agent.id);
-            const teamId = agent.teamId;
-            const agentId = agent.id;
-
-            const memoryName = config.data.memoryName;
-            const key = TemplateString(config.data.key).parse(input).result;
-            const value = TemplateString(config.data.value).parse(input).result;
-            const scope = config.data.scope;
-            const ttl = scope === 'ttl' ? config?.data?.ttl : 3 * 60 * 60; // 3 hours default ttl
-
-            const sessionId = agent.sessionId;
-            const workflowId = agent.agentRuntime.workflowReqId;
-
-            let scopeKey = '';
-            if (scope === 'session') {
-                scopeKey = sessionId;
-            } else if (scope === 'request') {
-                scopeKey = workflowId;
-            } else if (scope === 'ttl') {
-                scopeKey = 'ttl';
-            }
-
-            const scopeKeyId = `${agentId}:${memoryName}:${key}_scope`;
-            await connectorRequester.set(scopeKeyId, JSON.stringify({ scope, value: scopeKey }), null, null, ttl);
-
-            const fullKey = `${agentId}:${scopeKey}:${memoryName}:${key}`;
-            await connectorRequester.set(fullKey, value, null, null, ttl);
-
-            return { Key: key, _debug: logger.output };
-        } catch (error: any) {
-            return { _error: error.message, _debug: logger.output };
-        }
-    }
-}
+import Joi from 'joi';
+
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+import { ICacheRequest } from '@sre/MemoryManager/Cache.service/CacheConnector';
+
+const memory = {};
+export class MemoryWriteKeyVal extends Component {
+    protected configSchema = Joi.object({
+        memoryName: Joi.string().max(255).allow('').label('Memory Name'),
+        key: Joi.string().max(255).allow('').label('Key'),
+        value: Joi.string().max(100000).allow('').label('Value'),
+        scope: Joi.string().max(20).allow('').label('Scope'),
+        ttl: Joi.number().min(300).max(604800).allow('').label('TTL'),
+    });
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+
+        const logger = this.createComponentLogger(agent, config);
+
+        try {
+            const cacheConnector = ConnectorService.getCacheConnector();
+            const connectorRequester: ICacheRequest = cacheConnector.agent(agent.id);
+            const teamId = agent.teamId;
+            const agentId = agent.id;
+
+            const memoryName = config.data.memoryName;
+            const key = TemplateString(config.data.key).parse(input).result;
+            const value = TemplateString(config.data.value).parse(input).result;
+            const scope = config.data.scope;
+            const ttl = scope === 'ttl' ? config?.data?.ttl : 3 * 60 * 60; // 3 hours default ttl
+
+            const sessionId = agent.sessionId;
+            const workflowId = agent.agentRuntime.workflowReqId;
+
+            let scopeKey = '';
+            if (scope === 'session') {
+                scopeKey = sessionId;
+            } else if (scope === 'request') {
+                scopeKey = workflowId;
+            } else if (scope === 'ttl') {
+                scopeKey = 'ttl';
+            }
+
+            const scopeKeyId = `${agentId}:${memoryName}:${key}_scope`;
+            await connectorRequester.set(scopeKeyId, JSON.stringify({ scope, value: scopeKey }), null, null, ttl);
+
+            const fullKey = `${agentId}:${scopeKey}:${memoryName}:${key}`;
+            await connectorRequester.set(fullKey, value, null, null, ttl);
+
+            return { Key: key, _debug: logger.output };
+        } catch (error: any) {
+            return { _error: error.message, _debug: logger.output };
+        }
+    }
+}

package/src/Components/MemoryWriteObject.class.ts

@@ -1,97 +1,97 @@
-import Joi from 'joi';
-
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { Component } from './Component.class';
-import { ConnectorService } from '@sre/Core/ConnectorsService';
-import { TemplateString } from '@sre/helpers/TemplateString.helper';
-import { ICacheRequest } from '@sre/MemoryManager/Cache.service/CacheConnector';
-
-export class MemoryWriteObject extends Component {
-    protected configSchema = Joi.object({
-        memoryName: Joi.string().max(255).allow('').label('Memory Name'),
-        scope: Joi.string().max(20).allow('').label('Scope'),
-        ttl: Joi.number().min(300).max(604800).allow('').label('TTL'),
-    });
-    constructor() {
-        super();
-    }
-    init() {}
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-
-        const logger = this.createComponentLogger(agent, config);
-
-        try {
-            const cacheConnector = ConnectorService.getCacheConnector();
-            const connectorRequester: ICacheRequest = cacheConnector.agent(agent.id);
-            const teamId = agent.teamId;
-            const agentId = agent.id;
-
-            const memoryName = config.data.memoryName;
-            const dataString = input.Data;
-            const scope = config.data.scope;
-            const ttl = scope === 'ttl' ? config?.data?.ttl : 3 * 60 * 60; // 3 hours default ttl
-
-            // Parse the JSON data
-            let dataObject;
-            try {
-                dataObject = JSON.parse(dataString);
-            } catch (parseError) {
-                return { _error: 'Invalid JSON data provided', _debug: logger.output };
-            }
-
-            // Validate that the parsed data is an object
-            if (typeof dataObject !== 'object' || dataObject === null || Array.isArray(dataObject)) {
-                return { _error: 'Data must be a valid JSON object', _debug: logger.output };
-            }
-
-            const sessionId = agent.sessionId;
-            const workflowId = agent.agentRuntime.workflowReqId;
-
-            let scopeKey = '';
-            if (scope === 'session') {
-                scopeKey = sessionId;
-            } else if (scope === 'request') {
-                scopeKey = workflowId;
-            } else if (scope === 'ttl') {
-                scopeKey = 'ttl';
-            }
-
-            // Get all keys from the data object
-            const keys = Object.keys(dataObject);
-            logger.debug(`Writing ${keys.length} key-value pairs to memory`);
-
-            // Create promises for parallel execution
-            const writePromises = keys.map(async (key) => {
-                const value = String(dataObject[key]); // Convert value to string
-
-                // Write scope metadata
-                const scopeKeyId = `${agentId}:${memoryName}:${key}_scope`;
-                const scopePromise = connectorRequester.set(scopeKeyId, JSON.stringify({ scope, value: scopeKey }), null, null, ttl);
-
-                // Write actual value
-                const fullKey = `${agentId}:${scopeKey}:${memoryName}:${key}`;
-                const valuePromise = connectorRequester.set(fullKey, value, null, null, ttl);
-
-                // Wait for both operations to complete for this key
-                await Promise.all([scopePromise, valuePromise]);
-
-                return { key, success: true };
-            });
-
-            // Execute all write operations in parallel
-            const results = await Promise.all(writePromises);
-            const successfulKeys = results.filter((result) => result.success).map((result) => result.key);
-
-            logger.debug(`Successfully wrote ${successfulKeys.length} keys to memory`);
-
-            return {
-                Keys: successfulKeys,
-                Count: successfulKeys.length,
-                _debug: logger.output,
-            };
-        } catch (error: any) {
-            return { _error: error.message, _debug: logger.output };
-        }
-    }
-}
+import Joi from 'joi';
+
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+import { ICacheRequest } from '@sre/MemoryManager/Cache.service/CacheConnector';
+
+export class MemoryWriteObject extends Component {
+    protected configSchema = Joi.object({
+        memoryName: Joi.string().max(255).allow('').label('Memory Name'),
+        scope: Joi.string().max(20).allow('').label('Scope'),
+        ttl: Joi.number().min(300).max(604800).allow('').label('TTL'),
+    });
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+
+        const logger = this.createComponentLogger(agent, config);
+
+        try {
+            const cacheConnector = ConnectorService.getCacheConnector();
+            const connectorRequester: ICacheRequest = cacheConnector.agent(agent.id);
+            const teamId = agent.teamId;
+            const agentId = agent.id;
+
+            const memoryName = config.data.memoryName;
+            const dataString = input.Data;
+            const scope = config.data.scope;
+            const ttl = scope === 'ttl' ? config?.data?.ttl : 3 * 60 * 60; // 3 hours default ttl
+
+            // Parse the JSON data
+            let dataObject;
+            try {
+                dataObject = JSON.parse(dataString);
+            } catch (parseError) {
+                return { _error: 'Invalid JSON data provided', _debug: logger.output };
+            }
+
+            // Validate that the parsed data is an object
+            if (typeof dataObject !== 'object' || dataObject === null || Array.isArray(dataObject)) {
+                return { _error: 'Data must be a valid JSON object', _debug: logger.output };
+            }
+
+            const sessionId = agent.sessionId;
+            const workflowId = agent.agentRuntime.workflowReqId;
+
+            let scopeKey = '';
+            if (scope === 'session') {
+                scopeKey = sessionId;
+            } else if (scope === 'request') {
+                scopeKey = workflowId;
+            } else if (scope === 'ttl') {
+                scopeKey = 'ttl';
+            }
+
+            // Get all keys from the data object
+            const keys = Object.keys(dataObject);
+            logger.debug(`Writing ${keys.length} key-value pairs to memory`);
+
+            // Create promises for parallel execution
+            const writePromises = keys.map(async (key) => {
+                const value = String(dataObject[key]); // Convert value to string
+
+                // Write scope metadata
+                const scopeKeyId = `${agentId}:${memoryName}:${key}_scope`;
+                const scopePromise = connectorRequester.set(scopeKeyId, JSON.stringify({ scope, value: scopeKey }), null, null, ttl);
+
+                // Write actual value
+                const fullKey = `${agentId}:${scopeKey}:${memoryName}:${key}`;
+                const valuePromise = connectorRequester.set(fullKey, value, null, null, ttl);
+
+                // Wait for both operations to complete for this key
+                await Promise.all([scopePromise, valuePromise]);
+
+                return { key, success: true };
+            });
+
+            // Execute all write operations in parallel
+            const results = await Promise.all(writePromises);
+            const successfulKeys = results.filter((result) => result.success).map((result) => result.key);
+
+            logger.debug(`Successfully wrote ${successfulKeys.length} keys to memory`);
+
+            return {
+                Keys: successfulKeys,
+                Count: successfulKeys.length,
+                _debug: logger.output,
+            };
+        } catch (error: any) {
+            return { _error: error.message, _debug: logger.output };
+        }
+    }
+}

package/src/Components/MultimodalLLM.class.ts

@@ -1,128 +1,128 @@
-import Joi from 'joi';
-import { Component } from './Component.class';
-import { LLMInference } from '@sre/LLMManager/LLM.inference';
-import { TemplateString } from '@sre/helpers/TemplateString.helper';
-
-import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-
-export class MultimodalLLM extends Component {
-    protected configSchema = Joi.object({
-        prompt: Joi.string().required().max(8_000_000).label('Prompt'), // 2M tokens is around 8M characters
-        maxTokens: Joi.number().min(1).label('Maximum Tokens'),
-        model: Joi.string().max(200).required(),
-        passthrough: Joi.boolean().optional().label('Passthrough'),
-    });
-
-    constructor() {
-        super();
-    }
-
-    init() {}
-
-    async process(input, config, agent) {
-        await super.process(input, config, agent);
-
-        const logger = this.createComponentLogger(agent, config);
-
-        logger.debug(`=== Multimodal LLM Log ===`);
-
-        try {
-            const passThrough: boolean = config.data.passthrough || false;
-            const model: string = config.data.model || 'gpt-4o-mini';
-            const llmInference: LLMInference = await LLMInference.getInstance(model, AccessCandidate.agent(agent.id));
-
-            if (!llmInference.connector) {
-                return {
-                    _error: `The model '${model}' is not available. Please try a different one.`,
-                    _debug: logger.output,
-                };
-            }
-
-            const modelId = await agent.modelsProvider.getModelId(model);
-            logger.debug(` Model : ${modelId || model}`);
-
-            let prompt: any = TemplateString(config.data.prompt).parse(input).result;
-
-            logger.debug(` Prompt\n`, prompt, '\n');
-
-            const outputs = {};
-            for (let con of config.outputs) {
-                if (con.default) continue;
-                outputs[con.name] = con?.description ? `<${con?.description}>` : '';
-            }
-
-            const excludedKeys = ['_debug', '_error'];
-            const outputKeys = Object.keys(outputs).filter((key) => !excludedKeys.includes(key));
-
-            if (outputKeys.length > 0) {
-                const outputFormat = {};
-                outputKeys.forEach((key) => (outputFormat[key] = '<value>'));
-
-                prompt +=
-                    '\n\nExpected output format = ' +
-                    JSON.stringify(outputFormat) +
-                    '\n\n The output JSON should only use the entries from the output format.';
-
-                logger.debug(`[Component enhanced prompt]\n${prompt}\n\n`);
-            }
-
-            const files = Array.isArray(input.Input) ? input.Input : [input.Input];
-
-            let response: any;
-            if (passThrough) {
-                const contentPromise = new Promise(async (resolve, reject) => {
-                    let _content = '';
-                    const eventEmitter: any = await llmInference.multimodalStreamRequestLegacy(prompt, files, config, agent).catch((error) => {
-                        console.error('Error on multimodalStreamRequest: ', error);
-                        reject(error);
-                    });
-                    eventEmitter.on('content', (content) => {
-                        if (typeof agent.callback === 'function') {
-                            agent.callback({ content });
-                        }
-                        agent.sse.send('llm/passthrough/content', content);
-                        _content += content;
-                    });
-                    eventEmitter.on('thinking', (thinking) => {
-                        if (typeof agent.callback === 'function') {
-                            agent.callback({ thinking });
-                        }
-                        agent.sse.send('llm/passthrough/thinking', thinking);
-                    });
-                    eventEmitter.on('end', () => {
-                        console.log('end');
-                        resolve(_content);
-                    });
-                });
-                response = await contentPromise;
-            } else {
-                response = await llmInference.prompt({ query: prompt, files, params: { ...config, agentId: agent.id } });
-            }
-
-            // in case we have the response but it's empty string, undefined or null
-            if (!response) {
-                return { _error: ' LLM Error = Empty Response!', _debug: logger.output };
-            }
-
-            if (response?.error) {
-                const error = response?.error + ' ' + (response?.details || '');
-                logger.error(` LLM Error=`, error);
-                return { Reply: response?.data, _error: error, _debug: logger.output };
-            }
-
-            logger.debug(' Response \n', response);
-
-            const result = { Reply: response };
-            result['_debug'] = logger.output;
-
-            return result;
-        } catch (error: any) {
-            const _error = `${error?.error || ''} ${error?.details || ''}`.trim() || error?.message || 'Something went wrong!';
-            logger.error(`Error processing File(s)!`, _error);
-            return {
-                _error,
-                _debug: logger.output,
-            };
-        }
-    }
-}
+import Joi from 'joi';
+import { Component } from './Component.class';
+import { LLMInference } from '@sre/LLMManager/LLM.inference';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+
+export class MultimodalLLM extends Component {
+    protected configSchema = Joi.object({
+        prompt: Joi.string().required().max(8_000_000).label('Prompt'), // 2M tokens is around 8M characters
+        maxTokens: Joi.number().min(1).label('Maximum Tokens'),
+        model: Joi.string().max(200).required(),
+        passthrough: Joi.boolean().optional().label('Passthrough'),
+    });
+
+    constructor() {
+        super();
+    }
+
+    init() {}
+
+    async process(input, config, agent) {
+        await super.process(input, config, agent);
+
+        const logger = this.createComponentLogger(agent, config);
+
+        logger.debug(`=== Multimodal LLM Log ===`);
+
+        try {
+            const passThrough: boolean = config.data.passthrough || false;
+            const model: string = config.data.model || 'gpt-4o-mini';
+            const llmInference: LLMInference = await LLMInference.getInstance(model, AccessCandidate.agent(agent.id));
+
+            if (!llmInference.connector) {
+                return {
+                    _error: `The model '${model}' is not available. Please try a different one.`,
+                    _debug: logger.output,
+                };
+            }
+
+            const modelId = await agent.modelsProvider.getModelId(model);
+            logger.debug(` Model : ${modelId || model}`);
+
+            let prompt: any = TemplateString(config.data.prompt).parse(input).result;
+
+            logger.debug(` Prompt\n`, prompt, '\n');
+
+            const outputs = {};
+            for (let con of config.outputs) {
+                if (con.default) continue;
+                outputs[con.name] = con?.description ? `<${con?.description}>` : '';
+            }
+
+            const excludedKeys = ['_debug', '_error'];
+            const outputKeys = Object.keys(outputs).filter((key) => !excludedKeys.includes(key));
+
+            if (outputKeys.length > 0) {
+                const outputFormat = {};
+                outputKeys.forEach((key) => (outputFormat[key] = '<value>'));
+
+                prompt +=
+                    '\n\nExpected output format = ' +
+                    JSON.stringify(outputFormat) +
+                    '\n\n The output JSON should only use the entries from the output format.';
+
+                logger.debug(`[Component enhanced prompt]\n${prompt}\n\n`);
+            }
+
+            const files = Array.isArray(input.Input) ? input.Input : [input.Input];
+
+            let response: any;
+            if (passThrough) {
+                const contentPromise = new Promise(async (resolve, reject) => {
+                    let _content = '';
+                    const eventEmitter: any = await llmInference.multimodalStreamRequestLegacy(prompt, files, config, agent).catch((error) => {
+                        console.error('Error on multimodalStreamRequest: ', error);
+                        reject(error);
+                    });
+                    eventEmitter.on('content', (content) => {
+                        if (typeof agent.callback === 'function') {
+                            agent.callback({ content });
+                        }
+                        agent.sse.send('llm/passthrough/content', content);
+                        _content += content;
+                    });
+                    eventEmitter.on('thinking', (thinking) => {
+                        if (typeof agent.callback === 'function') {
+                            agent.callback({ thinking });
+                        }
+                        agent.sse.send('llm/passthrough/thinking', thinking);
+                    });
+                    eventEmitter.on('end', () => {
+                        console.log('end');
+                        resolve(_content);
+                    });
+                });
+                response = await contentPromise;
+            } else {
+                response = await llmInference.prompt({ query: prompt, files, params: { ...config, agentId: agent.id } });
+            }
+
+            // in case we have the response but it's empty string, undefined or null
+            if (!response) {
+                return { _error: ' LLM Error = Empty Response!', _debug: logger.output };
+            }
+
+            if (response?.error) {
+                const error = response?.error + ' ' + (response?.details || '');
+                logger.error(` LLM Error=`, error);
+                return { Reply: response?.data, _error: error, _debug: logger.output };
+            }
+
+            logger.debug(' Response \n', response);
+
+            const result = { Reply: response };
+            result['_debug'] = logger.output;
+
+            return result;
+        } catch (error: any) {
+            const _error = `${error?.error || ''} ${error?.details || ''}`.trim() || error?.message || 'Something went wrong!';
+            logger.error(`Error processing File(s)!`, _error);
+            return {
+                _error,
+                _debug: logger.output,
+            };
+        }
+    }
+}