@smythos/sre 1.5.43 → 1.5.45

package/src/Components/MCPClient.class.ts

@@ -1,112 +1,112 @@
-import Joi from 'joi';
-
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { Conversation } from '@sre/helpers/Conversation.helper';
-import { TemplateString } from '@sre/helpers/TemplateString.helper';
-
-import { Component } from './Component.class';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
-
-export class MCPClient extends Component {
-    protected configSchema = Joi.object({
-        model: Joi.string().optional(),
-        openAiModel: Joi.string().optional(), // for backward compatibility
-        mcpUrl: Joi.string().max(2048).uri().required().description('URL of the MCP'),
-        descForModel: Joi.string().max(5000).required().allow('').label('Description for Model'),
-        name: Joi.string().max(500).required().allow(''),
-        desc: Joi.string().max(5000).required().allow('').label('Description'),
-        logoUrl: Joi.string().max(8192).allow(''),
-        id: Joi.string().max(200),
-        version: Joi.string().max(100).allow(''),
-        domain: Joi.string().max(253).allow(''),
-        prompt: Joi.string().max(5000).optional().allow('').label('Prompt'),
-    });
-
-    constructor() {
-        super();
-    }
-
-    init() {}
-
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-        const logger = this.createComponentLogger(agent, config);
-
-        logger.debug(`=== MCP Client Log ===`);
-
-        try {
-            const mcpUrl = config?.data?.mcpUrl;
-            if (!mcpUrl) {
-                return { _error: 'Please provide a MCP URL!', _debug: logger.output };
-            }
-
-            const model = config?.data?.model || config?.data?.openAiModel;
-            const descForModel = TemplateString(config?.data?.descForModel).parse(input).result;
-            let prompt = TemplateString(config?.data?.prompt).parse(input).result;
-
-            if (!prompt) {
-                return { _error: 'Please provide a prompt', _debug: logger.output };
-            }
-
-            // TODO [Forhad]: Need to check and validate input prompt token
-            const baseUrl = new URL(mcpUrl);
-            const transport = new SSEClientTransport(baseUrl);
-            const client = new Client({
-                name: 'sse-client',
-                version: '1.0.0',
-            });
-            await client.connect(transport);
-            const toolsData = await client.listTools();
-            const conv = new Conversation(
-                model,
-                {
-                    openapi: '3.0.1',
-                    info: {
-                        title: `${agent?.name}`,
-                        version: `${agent?.version}`,
-                        description: descForModel,
-                    },
-                    servers: [
-                        {
-                            url: agent?.domain,
-                        },
-                    ],
-                    paths: {},
-                },
-                { agentId: agent?.id },
-            );
-
-            for (const tool of toolsData.tools) {
-                let toolArgs = {};
-                Object.entries(tool.inputSchema.properties).forEach(([propName, propDetails]) => {
-                    toolArgs[propName] = {
-                        description: '',
-                        required: ((tool.inputSchema.required as string[]) || []).includes(propName) || false,
-                        type: (propDetails as any).type,
-                        ...((propDetails as any).type === 'array' ? { items: { type: 'string' } } : {}),
-                    };
-                });
-                await conv.addTool({
-                    name: tool.name,
-                    description: tool.description,
-                    arguments: toolArgs,
-                    handler: async (input) => {
-                        const result = await client.callTool({
-                            name: tool.name,
-                            arguments: input,
-                        });
-                        return result;
-                    },
-                });
-            }
-            const result = await conv.prompt(prompt);
-
-            logger.debug(`Response:\n`, result, '\n');
-
-            return { Output: result, _debug: logger.output };
-        } catch (error: any) {
-            return { _error: `Error on running MCP Client!\n${error?.message || JSON.stringify(error)}`, _debug: logger.output };
-        }
-    }
-}
+import Joi from 'joi';
+
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Conversation } from '@sre/helpers/Conversation.helper';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+
+import { Component } from './Component.class';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+
+export class MCPClient extends Component {
+    protected configSchema = Joi.object({
+        model: Joi.string().optional(),
+        openAiModel: Joi.string().optional(), // for backward compatibility
+        mcpUrl: Joi.string().max(2048).uri().required().description('URL of the MCP'),
+        descForModel: Joi.string().max(5000).required().allow('').label('Description for Model'),
+        name: Joi.string().max(500).required().allow(''),
+        desc: Joi.string().max(5000).required().allow('').label('Description'),
+        logoUrl: Joi.string().max(8192).allow(''),
+        id: Joi.string().max(200),
+        version: Joi.string().max(100).allow(''),
+        domain: Joi.string().max(253).allow(''),
+        prompt: Joi.string().max(5000).optional().allow('').label('Prompt'),
+    });
+
+    constructor() {
+        super();
+    }
+
+    init() {}
+
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+        const logger = this.createComponentLogger(agent, config);
+
+        logger.debug(`=== MCP Client Log ===`);
+
+        try {
+            const mcpUrl = config?.data?.mcpUrl;
+            if (!mcpUrl) {
+                return { _error: 'Please provide a MCP URL!', _debug: logger.output };
+            }
+
+            const model = config?.data?.model || config?.data?.openAiModel;
+            const descForModel = TemplateString(config?.data?.descForModel).parse(input).result;
+            let prompt = TemplateString(config?.data?.prompt).parse(input).result;
+
+            if (!prompt) {
+                return { _error: 'Please provide a prompt', _debug: logger.output };
+            }
+
+            // TODO [Forhad]: Need to check and validate input prompt token
+            const baseUrl = new URL(mcpUrl);
+            const transport = new SSEClientTransport(baseUrl);
+            const client = new Client({
+                name: 'sse-client',
+                version: '1.0.0',
+            });
+            await client.connect(transport);
+            const toolsData = await client.listTools();
+            const conv = new Conversation(
+                model,
+                {
+                    openapi: '3.0.1',
+                    info: {
+                        title: `${agent?.name}`,
+                        version: `${agent?.version}`,
+                        description: descForModel,
+                    },
+                    servers: [
+                        {
+                            url: agent?.domain,
+                        },
+                    ],
+                    paths: {},
+                },
+                { agentId: agent?.id },
+            );
+
+            for (const tool of toolsData.tools) {
+                let toolArgs = {};
+                Object.entries(tool.inputSchema.properties).forEach(([propName, propDetails]) => {
+                    toolArgs[propName] = {
+                        description: '',
+                        required: ((tool.inputSchema.required as string[]) || []).includes(propName) || false,
+                        type: (propDetails as any).type,
+                        ...((propDetails as any).type === 'array' ? { items: { type: 'string' } } : {}),
+                    };
+                });
+                await conv.addTool({
+                    name: tool.name,
+                    description: tool.description,
+                    arguments: toolArgs,
+                    handler: async (input) => {
+                        const result = await client.callTool({
+                            name: tool.name,
+                            arguments: input,
+                        });
+                        return result;
+                    },
+                });
+            }
+            const result = await conv.prompt(prompt);
+
+            logger.debug(`Response:\n`, result, '\n');
+
+            return { Output: result, _debug: logger.output };
+        } catch (error: any) {
+            return { _error: `Error on running MCP Client!\n${error?.message || JSON.stringify(error)}`, _debug: logger.output };
+        }
+    }
+}

package/src/Components/MemoryDeleteKeyVal.class.ts

@@ -1,70 +1,70 @@
-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 MemoryDeleteKeyVal extends Component {
-    protected configSchema = Joi.object({
-        memoryName: Joi.string().max(255).allow('').label('Memory Name'),
-        key: Joi.string().max(255).allow('').label('Key'),
-    });
-    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 sessionId = agent.sessionId;
-            const workflowId = agent.agentRuntime.workflowReqId;
-
-            logger.debug(`Reading Scope Data for deletion`);
-            const scopeKeyId = `${agentId}:${memoryName}:${key}_scope`;
-            const scopeStrData = await connectorRequester.get(scopeKeyId);
-
-            if (!scopeStrData) {
-                return { _error: 'key not found', _debug: logger.output };
-            }
-
-            logger.debug(`Checking Scope for deletion`);
-            const scopeData = JSON.parse(scopeStrData);
-            const scopeKey = scopeData.value;
-
-            // Validate scope access like in MemoryReadKeyVal
-            if (scopeData.scope === 'session' && scopeKey !== sessionId) {
-                return { _error: 'key not found', _debug: logger.output };
-            }
-
-            if (scopeData.scope === 'request' && scopeKey !== workflowId) {
-                return { _error: 'key not found', _debug: logger.output };
-            }
-
-            logger.debug(`Deleting memory value and scope data`);
-
-            // Delete the actual value
-            const fullKey = `${agentId}:${scopeKey}:${memoryName}:${key}`;
-            await connectorRequester.delete(fullKey);
-
-            // Delete the scope metadata
-            await connectorRequester.delete(scopeKeyId);
-
-            return { Key: key, deleted: true, _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 MemoryDeleteKeyVal extends Component {
+    protected configSchema = Joi.object({
+        memoryName: Joi.string().max(255).allow('').label('Memory Name'),
+        key: Joi.string().max(255).allow('').label('Key'),
+    });
+    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 sessionId = agent.sessionId;
+            const workflowId = agent.agentRuntime.workflowReqId;
+
+            logger.debug(`Reading Scope Data for deletion`);
+            const scopeKeyId = `${agentId}:${memoryName}:${key}_scope`;
+            const scopeStrData = await connectorRequester.get(scopeKeyId);
+
+            if (!scopeStrData) {
+                return { _error: 'key not found', _debug: logger.output };
+            }
+
+            logger.debug(`Checking Scope for deletion`);
+            const scopeData = JSON.parse(scopeStrData);
+            const scopeKey = scopeData.value;
+
+            // Validate scope access like in MemoryReadKeyVal
+            if (scopeData.scope === 'session' && scopeKey !== sessionId) {
+                return { _error: 'key not found', _debug: logger.output };
+            }
+
+            if (scopeData.scope === 'request' && scopeKey !== workflowId) {
+                return { _error: 'key not found', _debug: logger.output };
+            }
+
+            logger.debug(`Deleting memory value and scope data`);
+
+            // Delete the actual value
+            const fullKey = `${agentId}:${scopeKey}:${memoryName}:${key}`;
+            await connectorRequester.delete(fullKey);
+
+            // Delete the scope metadata
+            await connectorRequester.delete(scopeKeyId);
+
+            return { Key: key, deleted: true, _debug: logger.output };
+        } catch (error: any) {
+            return { _error: error.message, _debug: logger.output };
+        }
+    }
+}

package/src/Components/MemoryReadKeyVal.class.ts

@@ -1,66 +1,66 @@
-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 MemoryReadKeyVal extends Component {
-    protected configSchema = Joi.object({
-        memoryName: Joi.string().max(255).allow('').label('Memory Name'),
-    });
-    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 = input.Key;
-
-            const sessionId = agent.sessionId;
-            const workflowId = agent.agentRuntime.workflowReqId;
-
-            logger.debug(`Reading Scope Data`);
-            const scopeKeyId = `${agentId}:${memoryName}:${key}_scope`;
-            const scopeStrData = await connectorRequester.get(scopeKeyId);
-
-            if (!scopeStrData) {
-                return { _error: 'key not found', _debug: logger.output };
-            }
-
-            logger.debug(`Checking Scope`);
-            const scopeData = JSON.parse(scopeStrData);
-            const scopeKey = scopeData.value;
-            if (scopeData.scope === 'session' && scopeKey !== sessionId) {
-                return { _error: 'key not found', _debug: logger.output };
-            }
-
-            if (scopeData.scope === 'request' && scopeKey !== workflowId) {
-                return { _error: 'key not found', _debug: logger.output };
-            }
-
-            logger.debug(`Reading Value`);
-
-            const fullKey = `${agentId}:${scopeKey}:${memoryName}:${key}`;
-
-            const value = await connectorRequester.get(fullKey);
-
-            return { Value: value, _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 MemoryReadKeyVal extends Component {
+    protected configSchema = Joi.object({
+        memoryName: Joi.string().max(255).allow('').label('Memory Name'),
+    });
+    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 = input.Key;
+
+            const sessionId = agent.sessionId;
+            const workflowId = agent.agentRuntime.workflowReqId;
+
+            logger.debug(`Reading Scope Data`);
+            const scopeKeyId = `${agentId}:${memoryName}:${key}_scope`;
+            const scopeStrData = await connectorRequester.get(scopeKeyId);
+
+            if (!scopeStrData) {
+                return { _error: 'key not found', _debug: logger.output };
+            }
+
+            logger.debug(`Checking Scope`);
+            const scopeData = JSON.parse(scopeStrData);
+            const scopeKey = scopeData.value;
+            if (scopeData.scope === 'session' && scopeKey !== sessionId) {
+                return { _error: 'key not found', _debug: logger.output };
+            }
+
+            if (scopeData.scope === 'request' && scopeKey !== workflowId) {
+                return { _error: 'key not found', _debug: logger.output };
+            }
+
+            logger.debug(`Reading Value`);
+
+            const fullKey = `${agentId}:${scopeKey}:${memoryName}:${key}`;
+
+            const value = await connectorRequester.get(fullKey);
+
+            return { Value: value, _debug: logger.output };
+        } catch (error: any) {
+            return { _error: error.message, _debug: logger.output };
+        }
+    }
+}

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 };
+        }
+    }
+}