@smythos/sre 1.5.37 → 1.5.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smythos/sre",
-  "version": "1.5.37",
+  "version": "1.5.40",
   "description": "Smyth Runtime Environment",
   "author": "Alaa-eddine KADDOURI",
   "license": "MIT",
@@ -42,7 +42,7 @@
     "typescript": "^5.4.5"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.39.0",
+    "@anthropic-ai/sdk": "^0.56.0",
     "@aws-sdk/client-bedrock-runtime": "^3.826.0",
     "@aws-sdk/client-iam": "^3.835.0",
     "@aws-sdk/client-lambda": "^3.835.0",
@@ -50,8 +50,8 @@
     "@aws-sdk/client-secrets-manager": "^3.826.0",
     "@faker-js/faker": "^9.8.0",
     "@google-cloud/vertexai": "^1.7.0",
-    "@google/generative-ai": "^0.14.1",
     "@google/genai": "^1.10.0",
+    "@google/generative-ai": "^0.14.1",
     "@huggingface/inference": "^2.8.0",
     "@modelcontextprotocol/sdk": "^1.10.1",
     "@pinecone-database/pinecone": "^3.0.0",
@@ -83,6 +83,7 @@
     "p-limit": "^6.1.0",
     "qs": "^6.13.0",
     "readline-sync": "^1.4.10",
+    "ses": "^1.14.0",
     "socks-proxy-agent": "^8.0.4",
     "winston": "^3.13.0",
     "winston-transport": "^4.7.0",

package/src/Components/APICall/APICall.class.ts

@@ -11,6 +11,7 @@ import { parseArrayBufferResponse } from './ArrayBufferResponse.helper';
 import { extractAdditionalParamsForOAuth1, handleOAuthHeaders as generateOAuthHeaders } from './OAuth.helper';
 import { SocksProxyAgent } from 'socks-proxy-agent';
 import { formatDataForDebug } from '@sre/utils/data.utils';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
 
 export class APICall extends Component {
     protected schema = {
@@ -92,7 +93,7 @@ export class APICall extends Component {
             if (data) {
                 reqConfig.data = data;
 
-                dataForDebug = await formatDataForDebug(data);
+                dataForDebug = await formatDataForDebug(data, AccessCandidate.agent(agent.id));
             }
 
             reqConfig.headers = (await parseHeaders(input, config, agent)).concat({ ...headers });

package/src/Components/Component.class.ts

@@ -27,7 +27,7 @@ export class Component {
     init() {}
 
     createComponentLogger(agent: Agent, configuration: any) {
-        const logger = Logger(configuration.name || this.constructor.name, agent?.agentRuntime?.debug);
+        const logger = Logger((configuration.name || this.constructor.name) + `,agent<${agent.id}>`, agent?.agentRuntime?.debug);
 
         logger.on('logged', (info: { level: string; message: string }) => {
             if (agent.sse && configuration.eventId) {

package/src/Components/ECMASandbox.class.ts

@@ -0,0 +1,71 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+import Joi from 'joi';
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { CodeExecutionResult } from '@sre/ComputeManager/Code.service/CodeConnector';
+
+export class ECMASandbox extends Component {
+    protected configSchema = Joi.object({
+        code: Joi.string().max(500000).allow('').label('Code'),
+    });
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+
+        const logger = this.createComponentLogger(agent, config);
+        try {
+            let Output: any = {};
+            let _error = undefined;
+
+            let codeInputs = {};
+            for (let fieldName in input) {
+                const _type = typeof input[fieldName];
+                switch (_type) {
+                    case 'string':
+                        const b64encoded = Buffer.from(input[fieldName]).toString('base64');
+                        codeInputs[fieldName] = `___internal.b64decode('${b64encoded}')`;
+                        break;
+                    case 'number':
+                    case 'boolean':
+                        codeInputs[fieldName] = input[fieldName];
+                        break;
+                    default:
+                        codeInputs[fieldName] = input[fieldName];
+                        break;
+                }
+            }
+
+            const inputVarsCode = this.generateInputVarCode(codeInputs);
+            const code = inputVarsCode + '\n' + config.data.code;
+
+            logger.debug(`Running code: \n${code}\n`);
+
+            const ecmaCodeConnector = ConnectorService.getCodeConnector('ECMASandbox');
+
+            const executionResponse: CodeExecutionResult = await ecmaCodeConnector.agent(agent.id).execute(config.id, { code });
+            if (executionResponse.success) {
+                Output = executionResponse.output;
+            } else {
+                Output = undefined;
+                _error = executionResponse.errors;
+            }
+
+            return { Output, _error, _debug: logger.output };
+        } catch (err: any) {
+            const _error = err?.response?.data || err?.message || err.toString();
+            logger.error(`Error running code: \n${_error}\n`);
+            return { Output: undefined, _error, _debug: logger.output };
+        }
+    }
+
+    private generateInputVarCode(input: Record<string, any>) {
+        let input_vars = '';
+        for (const key in input) {
+            input_vars += `var ${key} = ${input[key]};\n`;
+        }
+        return input_vars;
+    }
+}

package/src/Components/GenAILLM.class.ts

@@ -390,7 +390,7 @@ export class GenAILLM extends Component {
             logger.debug(` Prompt\n`, prompt, '\n');
 
             if (!isEcho) {
-                logger.debug(' Files\n', await Promise.all(files.map((file) => formatDataForDebug(file))));
+                logger.debug(' Files\n', await Promise.all(files.map((file) => formatDataForDebug(file, AccessCandidate.agent(agent.id)))));
             }
 
             // default to json response format

package/src/Components/MemoryDeleteKeyVal.class.ts

@@ -0,0 +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 };
+        }
+    }
+}

package/src/Components/MemoryReadKeyVal.class.ts

@@ -0,0 +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 };
+        }
+    }
+}

package/src/Components/MemoryWriteKeyVal.class.ts

@@ -0,0 +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 };
+        }
+    }
+}

package/src/Components/MemoryWriteObject.class.ts

@@ -0,0 +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 };
+        }
+    }
+}

package/src/Components/index.ts

@@ -37,6 +37,11 @@ import { ServerlessCode } from './ServerlessCode.class';
 import { ImageGenerator } from './ImageGenerator.class'; // Legacy
 import { MCPClient } from './MCPClient.class';
 import { OpenAPI } from './OpenAPI.class';
+import { ECMASandbox } from './ECMASandbox.class';
+import { MemoryWriteKeyVal } from './MemoryWriteKeyVal.class';
+import { MemoryReadKeyVal } from './MemoryReadKeyVal.class';
+import { MemoryDeleteKeyVal } from './MemoryDeleteKeyVal.class';
+import { MemoryWriteObject } from './MemoryWriteObject.class';
 
 const components = {
     Component: new Component(),
@@ -82,6 +87,11 @@ const components = {
     ImageGenerator: new ImageGenerator(),
     MCPClient: new MCPClient(),
     OpenAPI: new OpenAPI(),
+    ECMASandbox: new ECMASandbox(),
+    MemoryWriteKeyVal: new MemoryWriteKeyVal(),
+    MemoryReadKeyVal: new MemoryReadKeyVal(),
+    MemoryDeleteKeyVal: new MemoryDeleteKeyVal(),
+    MemoryWriteObject: new MemoryWriteObject(),
 };
 
 export const ComponentInstances = components;

package/src/Core/ConnectorsService.ts

@@ -18,6 +18,7 @@ import { ManagedVaultConnector } from '@sre/Security/ManagedVault.service/Manage
 import { LogConnector } from '@sre/IO/Log.service/LogConnector';
 import { ComponentConnector } from '@sre/AgentManager/Component.service/ComponentConnector';
 import { ModelsProviderConnector } from '@sre/LLMManager/ModelsProvider.service/ModelsProviderConnector';
+import { CodeConnector } from '@sre/ComputeManager/Code.service/CodeConnector';
 const console = Logger('ConnectorService');
 
 let ServiceRegistry: TServiceRegistry = {};
@@ -182,9 +183,8 @@ export class ConnectorService {
         return ConnectorService.getInstance<RouterConnector>(TConnectorService.Router, name);
     }
 
-
-    static getCodeConnector(name?: string): RouterConnector {
-        return ConnectorService.getInstance<RouterConnector>(TConnectorService.Code, name);
+    static getCodeConnector(name?: string): CodeConnector {
+        return ConnectorService.getInstance<CodeConnector>(TConnectorService.Code, name);
     }
 }
 

package/src/helpers/Conversation.helper.ts

@@ -130,8 +130,14 @@ export class Conversation extends EventEmitter {
             this._lastError = error;
             console.warn('Conversation Error: ', error?.message);
         });
-        if (_settings?.maxContextSize) this._maxContextSize = _settings.maxContextSize;
-        if (_settings?.maxOutputTokens) this._maxOutputTokens = _settings.maxOutputTokens;
+        this._maxContextSize =
+            _settings.maxContextSize || (this._model as TLLMModel).tokens || (this._model as TLLMModel).keyOptions?.tokens || this._maxContextSize;
+        this._maxOutputTokens =
+            _settings.maxOutputTokens ||
+            (this._model as TLLMModel).completionTokens ||
+            (this._model as TLLMModel).keyOptions?.completionTokens ||
+            this._maxOutputTokens;
+
         if (_settings?.systemPrompt) {
             this.userDefinedSystemPrompt = _settings.systemPrompt;
         }
@@ -490,9 +496,11 @@ export class Conversation extends EventEmitter {
                     //this._context.addAssistantMessage(passThroughContent, message_id);
                     llmMessage.content += '\n' + passThroughContent;
                     this._context.addToolMessage(llmMessage, processedToolsData, message_id);
+
+                    //this._context.addAssistantMessage(passThroughContent, message_id, { passthrough: true });
                     //this should not be stored in the persistent conversation store
                     //it's just a workaround to avoid generating more content after passthrough content
-                    this._context.addUserMessage(passThroughtContinueMessage, message_id, { internal: true });
+                    //this._context.addUserMessage(passThroughtContinueMessage, message_id, { internal: true });
                     //toolHeaders['x-passthrough'] = 'true';
                 }
 

package/src/helpers/ECMASandbox.helper.ts

@@ -0,0 +1,54 @@
+import 'ses';
+
+
+
+
+export function runJs(code: string) {
+    // Call lockdown to secure the environment
+    lockdown();
+    try {
+        // Endow the compartment with necessary APIs
+        const compartment = new Compartment({
+            globals: {
+                // add necessary globals here
+                setTimeout: harden(setTimeout),
+                clearTimeout: harden(clearTimeout),
+                setInterval: harden(setInterval),
+                clearInterval: harden(clearInterval),
+                console: harden(console),
+                Promise: harden(Promise),
+                fetch: harden(fetch),
+            },
+            __options__: true, // temporary migration affordance
+        });
+        const result = compartment.evaluate(code);
+        return result;
+    } catch (error) {
+        console.error(error);
+        throw error;
+    }
+
+}
+
+function getParametersString(parameters: string[], inputs: Record<string, any>) {
+    let params = [];
+    for (const parameter of parameters) {
+        if (typeof inputs[parameter] === 'string') {
+            params.push(`'${inputs[parameter]}'`);
+        } else {
+            params.push(`${inputs[parameter]}`);
+        }
+    }
+    return params.join(',');
+}
+
+export function generateExecutableCode(code: string, parameters: string[], inputs: Record<string, any>) {
+    const executableCode = `
+    (async () => {
+        ${code}
+        const result = await main(${getParametersString(parameters, inputs)});
+        return result;
+    })();
+    `
+    return executableCode;
+}