@smythos/sre 1.5.53 → 1.5.54

package/src/Components/MCPClient.class.ts

@@ -1,138 +1,138 @@
-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';
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.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 { client } = await this.connectMCP(mcpUrl);
-
-            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 };
-        }
-    }
-    private async connectMCP(mcpUrl: string) {
-        const client = new Client({ name: 'auto-client', version: '1.0.0' });
-      
-        // 1) Try Streamable HTTP first
-        try {
-          const st = new StreamableHTTPClientTransport(new URL(mcpUrl));
-          await client.connect(st);
-          console.debug('Connected to MCP using Streamable HTTP');
-          return { client, transport: 'streamable' as const };
-        } catch (e: any) {
-          console.debug('Failed to connect to MCP using Streamable HTTP, falling back to SSE');
-          // 2) If clearly unsupported, fall back to SSE
-          const msg = String(e?.message || e);
-          const isUnsupported =
-            /404|405|ENOTFOUND|ECONNREFUSED|CORS/i.test(msg);
-      
-          // 406 means wrong/missing Accept for Streamable → retry Streamable with proper header
-          const isAcceptProblem = /406|Not Acceptable|text\/event-stream/i.test(msg);
-          if (isAcceptProblem) {
-            throw new Error('Server is Streamable; include Accept: application/json, text/event-stream');
-          }
-      
-          if (!isUnsupported) throw e;
-      
-          // SSE fallback
-          const sse = new SSEClientTransport(new URL(mcpUrl));
-          await client.connect(sse);
-          return { client, transport: 'sse' as const };
-        }
-      }
-}
+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';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.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 { client } = await this.connectMCP(mcpUrl);
+
+            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 };
+        }
+    }
+    private async connectMCP(mcpUrl: string) {
+        const client = new Client({ name: 'auto-client', version: '1.0.0' });
+      
+        // 1) Try Streamable HTTP first
+        try {
+          const st = new StreamableHTTPClientTransport(new URL(mcpUrl));
+          await client.connect(st);
+          console.debug('Connected to MCP using Streamable HTTP');
+          return { client, transport: 'streamable' as const };
+        } catch (e: any) {
+          console.debug('Failed to connect to MCP using Streamable HTTP, falling back to SSE');
+          // 2) If clearly unsupported, fall back to SSE
+          const msg = String(e?.message || e);
+          const isUnsupported =
+            /404|405|ENOTFOUND|ECONNREFUSED|CORS/i.test(msg);
+      
+          // 406 means wrong/missing Accept for Streamable → retry Streamable with proper header
+          const isAcceptProblem = /406|Not Acceptable|text\/event-stream/i.test(msg);
+          if (isAcceptProblem) {
+            throw new Error('Server is Streamable; include Accept: application/json, text/event-stream');
+          }
+      
+          if (!isUnsupported) throw e;
+      
+          // SSE fallback
+          const sse = new SSEClientTransport(new URL(mcpUrl));
+          await client.connect(sse);
+          return { client, transport: 'sse' as const };
+        }
+      }
+}

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