@smythos/sre 1.5.43 → 1.5.45

package/src/Components/APIOutput.class.ts

@@ -1,58 +1,58 @@
-import { Component } from './Component.class';
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import Joi from 'joi';
-
-export class APIOutput extends Component {
-    protected configSchema = Joi.object({
-        format: Joi.string().valid('full', 'minimal', 'raw').label('Output Format').required(),
-        contentType: Joi.string().valid('application/json', 'text/plain', 'text/html', 'application/xml').optional().allow('').label('Content Type'),
-    });
-    public hasPostProcess = true;
-    constructor() {
-        super();
-    }
-    init() {}
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-        const logger = this.createComponentLogger(agent, config);
-        const _error = undefined;
-        let Output = {};
-        logger.debug(` Processing outputs `);
-        for (let key in input) {
-            if (!config.inputs.find((i) => i.name == key)) continue; //exclude global variables
-            Output[key] = input[key];
-        }
-
-        if (config.data.format === 'raw') {
-            let rawOutput = '';
-            for (let key in input) {
-                if (!config.inputs.find((i) => i.name == key)) continue; //exclude global variables
-                rawOutput += input[key];
-            }
-            Output = rawOutput;
-        }
-        return { Output, _error, _debug: logger.output };
-    }
-    async postProcess(output, config, agent: Agent): Promise<any> {
-        let contentType = config.data.contentType || 'application/json';
-
-        for (let agentVar in agent.agentVariables) {
-            delete output?.result?.Output?.[agentVar]; //clean up agent variables from output
-        }
-
-        if (config?.data?.format == 'minimal' || contentType !== 'application/json') {
-            if (output?.result?.Output) {
-                return output?.result?.Output;
-            }
-
-            if (output?.result?._error) {
-                return output?.result?._error;
-            }
-
-            delete output.id;
-            delete output.name;
-        }
-
-        return output;
-    }
-}
+import { Component } from './Component.class';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import Joi from 'joi';
+
+export class APIOutput extends Component {
+    protected configSchema = Joi.object({
+        format: Joi.string().valid('full', 'minimal', 'raw').label('Output Format').required(),
+        contentType: Joi.string().valid('application/json', 'text/plain', 'text/html', 'application/xml').optional().allow('').label('Content Type'),
+    });
+    public hasPostProcess = true;
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+        const logger = this.createComponentLogger(agent, config);
+        const _error = undefined;
+        let Output = {};
+        logger.debug(` Processing outputs `);
+        for (let key in input) {
+            if (!config.inputs.find((i) => i.name == key)) continue; //exclude global variables
+            Output[key] = input[key];
+        }
+
+        if (config.data.format === 'raw') {
+            let rawOutput = '';
+            for (let key in input) {
+                if (!config.inputs.find((i) => i.name == key)) continue; //exclude global variables
+                rawOutput += input[key];
+            }
+            Output = rawOutput;
+        }
+        return { Output, _error, _debug: logger.output };
+    }
+    async postProcess(output, config, agent: Agent): Promise<any> {
+        let contentType = config.data.contentType || 'application/json';
+
+        for (let agentVar in agent.agentVariables) {
+            delete output?.result?.Output?.[agentVar]; //clean up agent variables from output
+        }
+
+        if (config?.data?.format == 'minimal' || contentType !== 'application/json') {
+            if (output?.result?.Output) {
+                return output?.result?.Output;
+            }
+
+            if (output?.result?._error) {
+                return output?.result?._error;
+            }
+
+            delete output.id;
+            delete output.name;
+        }
+
+        return output;
+    }
+}

package/src/Components/AgentPlugin.class.ts

@@ -1,102 +1,102 @@
-import Joi from 'joi';
-
-import { ConnectorService } from '@sre/Core/ConnectorsService';
-import { TemplateString } from '@sre/helpers/TemplateString.helper';
-
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { Conversation } from '@sre/helpers/Conversation.helper';
-import { Component } from './Component.class';
-
-export class AgentPlugin extends Component {
-    protected configSchema = Joi.object({
-        agentId: Joi.string().max(200).required(),
-        openAiModel: Joi.string().max(200).optional(), // for backward compatibility
-        model: Joi.string().max(200).optional(),
-        descForModel: Joi.string().max(5000).allow('').label('Description for Model'),
-        id: Joi.string().max(200),
-        name: Joi.string().max(500),
-        desc: Joi.string().max(5000).allow('').label('Description'),
-        logoUrl: Joi.string().max(8192).allow(''),
-        version: Joi.string().max(100).allow(''),
-        domain: Joi.string().max(253).allow(''),
-    });
-
-    constructor() {
-        super();
-    }
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-        const logger = this.createComponentLogger(agent, config);
-
-        logger.debug(`=== Agent Plugin Log ===`);
-
-        try {
-            const subAgentId = config.data?.agentId;
-
-            if (!subAgentId) {
-                return { _error: 'Agent Component ID is required!', _debug: logger.output };
-            }
-
-            //tag this request to tell the nested agent that the call comes from internal agent
-            const reqTag = agent.agentRuntime?.reqTag;
-
-            const model = config?.data?.model || config?.data?.openAiModel;
-            const descForModel = TemplateString(config?.data?.descForModel).parse(input).result;
-            const prompt = typeof input?.Prompt === 'string' ? input?.Prompt : JSON.stringify(input?.Prompt);
-
-            const agentDataConnector = ConnectorService.getAgentDataConnector();
-
-            //let subAgentDomain = await isDeployed(subAgentId);
-            // when domain found for sub agent, that means it's deployed
-            const isSubAgentDeployed = await agentDataConnector.isDeployed(subAgentId);
-
-            let version = config.data?.version || '';
-
-            logger.debug('Version: ', version);
-
-            if (version === 'same-as-parent') {
-                const isParentAgentDeployed = await agentDataConnector.isDeployed(agent?.id);
-
-                if (isParentAgentDeployed) {
-                    if (isSubAgentDeployed) {
-                        version = 'latest';
-                    } else {
-                        return {
-                            _error: `Call failed, Agent '${config.data?.name}' (${subAgentId}) is not deployed. Please deploy the agent and try again.`,
-                            _debug: logger.output,
-                        };
-                    }
-                } else {
-                    version = ''; // empty string ('') means latest dev version
-                }
-            } else if (version === 'dev-latest') {
-                version = '';
-            } else if (version === 'prod-latest') {
-                if (isSubAgentDeployed) {
-                    version = 'latest';
-                } else {
-                    return {
-                        _error: `Call failed, Agent '${config.data?.name}' (${subAgentId}) is not deployed. Please deploy the agent and try again.`,
-                        _debug: logger.output,
-                    };
-                }
-            }
-
-            const conv = new Conversation(model, subAgentId, { systemPrompt: descForModel, agentVersion: version });
-
-            const result = await conv.prompt(prompt, {
-                'X-AGENT-ID': subAgentId,
-                'X-AGENT-VERSION': version,
-                'X-REQUEST-TAG': reqTag, //request Tag identifies the request and tells the called agent that the call comes from internal agent
-                'x-caller-session-id': agent.callerSessionId,
-            });
-
-            logger.debug(`Response:\n`, result, '\n');
-
-            return { Response: result, _debug: logger.output };
-        } catch (error: any) {
-            console.error('Error on running Agent Component: ', error);
-            return { _error: `Error on running Agent Component!\n${error?.message || JSON.stringify(error)}`, _debug: logger.output };
-        }
-    }
-}
+import Joi from 'joi';
+
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Conversation } from '@sre/helpers/Conversation.helper';
+import { Component } from './Component.class';
+
+export class AgentPlugin extends Component {
+    protected configSchema = Joi.object({
+        agentId: Joi.string().max(200).required(),
+        openAiModel: Joi.string().max(200).optional(), // for backward compatibility
+        model: Joi.string().max(200).optional(),
+        descForModel: Joi.string().max(5000).allow('').label('Description for Model'),
+        id: Joi.string().max(200),
+        name: Joi.string().max(500),
+        desc: Joi.string().max(5000).allow('').label('Description'),
+        logoUrl: Joi.string().max(8192).allow(''),
+        version: Joi.string().max(100).allow(''),
+        domain: Joi.string().max(253).allow(''),
+    });
+
+    constructor() {
+        super();
+    }
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+        const logger = this.createComponentLogger(agent, config);
+
+        logger.debug(`=== Agent Plugin Log ===`);
+
+        try {
+            const subAgentId = config.data?.agentId;
+
+            if (!subAgentId) {
+                return { _error: 'Agent Component ID is required!', _debug: logger.output };
+            }
+
+            //tag this request to tell the nested agent that the call comes from internal agent
+            const reqTag = agent.agentRuntime?.reqTag;
+
+            const model = config?.data?.model || config?.data?.openAiModel;
+            const descForModel = TemplateString(config?.data?.descForModel).parse(input).result;
+            const prompt = typeof input?.Prompt === 'string' ? input?.Prompt : JSON.stringify(input?.Prompt);
+
+            const agentDataConnector = ConnectorService.getAgentDataConnector();
+
+            //let subAgentDomain = await isDeployed(subAgentId);
+            // when domain found for sub agent, that means it's deployed
+            const isSubAgentDeployed = await agentDataConnector.isDeployed(subAgentId);
+
+            let version = config.data?.version || '';
+
+            logger.debug('Version: ', version);
+
+            if (version === 'same-as-parent') {
+                const isParentAgentDeployed = await agentDataConnector.isDeployed(agent?.id);
+
+                if (isParentAgentDeployed) {
+                    if (isSubAgentDeployed) {
+                        version = 'latest';
+                    } else {
+                        return {
+                            _error: `Call failed, Agent '${config.data?.name}' (${subAgentId}) is not deployed. Please deploy the agent and try again.`,
+                            _debug: logger.output,
+                        };
+                    }
+                } else {
+                    version = ''; // empty string ('') means latest dev version
+                }
+            } else if (version === 'dev-latest') {
+                version = '';
+            } else if (version === 'prod-latest') {
+                if (isSubAgentDeployed) {
+                    version = 'latest';
+                } else {
+                    return {
+                        _error: `Call failed, Agent '${config.data?.name}' (${subAgentId}) is not deployed. Please deploy the agent and try again.`,
+                        _debug: logger.output,
+                    };
+                }
+            }
+
+            const conv = new Conversation(model, subAgentId, { systemPrompt: descForModel, agentVersion: version });
+
+            const result = await conv.prompt(prompt, {
+                'X-AGENT-ID': subAgentId,
+                'X-AGENT-VERSION': version,
+                'X-REQUEST-TAG': reqTag, //request Tag identifies the request and tells the called agent that the call comes from internal agent
+                'x-caller-session-id': agent.callerSessionId,
+            });
+
+            logger.debug(`Response:\n`, result, '\n');
+
+            return { Response: result, _debug: logger.output };
+        } catch (error: any) {
+            console.error('Error on running Agent Component: ', error);
+            return { _error: `Error on running Agent Component!\n${error?.message || JSON.stringify(error)}`, _debug: logger.output };
+        }
+    }
+}

package/src/Components/Async.class.ts

@@ -1,155 +1,155 @@
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { ForkedAgent } from '@sre/AgentManager/ForkedAgent.class';
-import { Component } from './Component.class';
-import Joi from 'joi';
-import { delay } from '../utils';
-
-export class Async extends Component {
-    static JOBS = {};
-    protected configSchema = null;
-    static ForkedAgent;
-    constructor() {
-        super();
-        // import('../ForkedAgent.class').then((ForkedAgent) => {
-        //     Async.ForkedAgent = ForkedAgent.default;
-        // });
-    }
-    init() {}
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-        const logger = this.createComponentLogger(agent, config);
-        //we set data.forked to true in the forked component in order to refork it again.
-        const forked = config.data.forked;
-        let _error = null;
-
-        try {
-            //const runtimeData = agent.agentRuntime.getRuntimeData(config.id);
-
-            if (!forked) {
-                const forkedAgent: ForkedAgent = new ForkedAgent(agent, config.id);
-                const JobID = forkedAgent.jobID;
-
-                forkedAgent.agent.async = true;
-                forkedAgent.agent.jobID = JobID;
-                //clean JobID branch
-                this.cleanJobIDBranch(forkedAgent.agent);
-
-                const componentData = forkedAgent.components[config.id];
-                componentData.data.forked = true;
-
-                forkedAgent.agentRequest.body = { ...input };
-
-                if (!Async.JOBS[agent.id]) Async.JOBS[agent.id] = {};
-                Async.JOBS[agent.id][JobID] = {
-                    //forkedAgent,
-                    status: 'pending',
-                };
-
-                //We use this to inform the debugger about the list of components used by this job
-                //this is only used to provide a visual feedback in the debugger UI
-                if (agent.debugSessionEnabled) {
-                    const _job_components = Object.keys(forkedAgent.components);
-                    agent.agentRuntime.updateComponent(config.id, { _job_components });
-                }
-
-                forkedAgent
-                    .process(`/api/${config.id}`, input)
-                    .then((result) => {
-                        Async.JOBS[agent.id][JobID].result = result;
-                        Async.JOBS[agent.id][JobID].status = 'done';
-                    })
-                    .finally(async () => {
-                        if (Async.JOBS[agent.id][JobID].status !== 'done') {
-                            Async.JOBS[agent.id][JobID].status = 'failed';
-                        }
-                        if (agent.debugSessionEnabled) {
-                            await delay(1000); //wait for the debugger to update the UI
-                            //ctxData in agentRuntime might have been updated by the main component
-                            //we need to reload it in order to ensure that we're updating the latest version
-                            agent.agentRuntime.reloadCtxData();
-                            agent.agentRuntime.updateComponent(config.id, { _job_components: [] });
-                        }
-                    });
-
-                return { JobID };
-            } else {
-                //const Input = input.Input;
-                let result = { JobID: agent.jobID };
-                for (let key in input) {
-                    result[key] = input[key];
-                }
-
-                return result;
-            }
-        } catch (error: any) {
-            _error = error;
-        }
-
-        return {};
-    }
-
-    // private recursiveTagAsyncComponents(component, agent: Agent) {
-    //     for (let output of component.outputs) {
-    //         if (component.name == 'Async' && output.name === 'JobID') continue; //'JobID' is a special output
-    //         const connected = agent.connections.filter((c) => c.sourceId === component.id && c.sourceIndex === output.index);
-    //         if (!connected) continue;
-    //         for (let con of connected) {
-    //             const targetComponent = agent.components[con.targetId];
-    //             if (!targetComponent) continue;
-    //             targetComponent.async = true;
-    //             this.recursiveTagAsyncComponents(targetComponent, agent);
-    //         }
-    //     }
-    // }
-    // private tagAsyncComponents(agent: Agent) {
-    //     const componentsList: any[] = Object.values(agent.components);
-    //     const AsyncComponent = componentsList.find((c) => c.name === 'Async');
-    //     if (!AsyncComponent) return;
-    //     AsyncComponent.async = true;
-
-    //     this.recursiveTagAsyncComponents(AsyncComponent, agent);
-    // }
-    private cleanJobIDBranch(agent: Agent) {
-        //this.tagAsyncComponents(agent);
-
-        const componentsList: any[] = Object.values(agent.components);
-        const AsyncComponent = componentsList.find((c) => c.name === 'Async');
-        //const endpointComponent = componentsList.find((c) => c.name === 'APIEndpoint');
-        if (!AsyncComponent) return;
-        const jobIDOutputIndex = AsyncComponent.outputs.findIndex((o) => o.name === 'JobID');
-        if (jobIDOutputIndex === -1) return;
-        //delete connections where sourceId = AsyncComponent.id and sourceOutputIndex = jobIDOutputIndex and the component is not tagged as async
-        agent.connections = agent.connections.filter((c) => {
-            const toDelete = c.sourceId === AsyncComponent.id && c.sourceIndex === jobIDOutputIndex && !agent.components[c.targetId].async;
-            return !toDelete;
-        });
-
-        //TODO : remove orphaned branches
-        this.removeOrphanedBranches(agent);
-    }
-
-    private removeOrphanedBranches(agent: Agent) {
-        const toDelete: any[] = [];
-        for (let componentId in agent.components) {
-            const component = agent.components[componentId];
-            if (component.name === 'APIEndpoint') continue;
-            const connected = agent.connections.some((c) => c.targetId === component.id);
-            if (!connected) {
-                //this.removeComponent(agent, component.id);
-                toDelete.push(component.id);
-            }
-        }
-        for (let id of toDelete) {
-            this.removeComponent(agent, id);
-        }
-    }
-
-    private removeComponent(agent: Agent, componentId: string) {
-        const component = agent.components[componentId];
-        delete agent.components[componentId];
-
-        //delete connections where sourceId = componentId
-        agent.connections = agent.connections.filter((c) => c.sourceId !== componentId);
-        this.removeOrphanedBranches(agent);
-    }
-}
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { ForkedAgent } from '@sre/AgentManager/ForkedAgent.class';
+import { Component } from './Component.class';
+import Joi from 'joi';
+import { delay } from '../utils';
+
+export class Async extends Component {
+    static JOBS = {};
+    protected configSchema = null;
+    static ForkedAgent;
+    constructor() {
+        super();
+        // import('../ForkedAgent.class').then((ForkedAgent) => {
+        //     Async.ForkedAgent = ForkedAgent.default;
+        // });
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+        const logger = this.createComponentLogger(agent, config);
+        //we set data.forked to true in the forked component in order to refork it again.
+        const forked = config.data.forked;
+        let _error = null;
+
+        try {
+            //const runtimeData = agent.agentRuntime.getRuntimeData(config.id);
+
+            if (!forked) {
+                const forkedAgent: ForkedAgent = new ForkedAgent(agent, config.id);
+                const JobID = forkedAgent.jobID;
+
+                forkedAgent.agent.async = true;
+                forkedAgent.agent.jobID = JobID;
+                //clean JobID branch
+                this.cleanJobIDBranch(forkedAgent.agent);
+
+                const componentData = forkedAgent.components[config.id];
+                componentData.data.forked = true;
+
+                forkedAgent.agentRequest.body = { ...input };
+
+                if (!Async.JOBS[agent.id]) Async.JOBS[agent.id] = {};
+                Async.JOBS[agent.id][JobID] = {
+                    //forkedAgent,
+                    status: 'pending',
+                };
+
+                //We use this to inform the debugger about the list of components used by this job
+                //this is only used to provide a visual feedback in the debugger UI
+                if (agent.debugSessionEnabled) {
+                    const _job_components = Object.keys(forkedAgent.components);
+                    agent.agentRuntime.updateComponent(config.id, { _job_components });
+                }
+
+                forkedAgent
+                    .process(`/api/${config.id}`, input)
+                    .then((result) => {
+                        Async.JOBS[agent.id][JobID].result = result;
+                        Async.JOBS[agent.id][JobID].status = 'done';
+                    })
+                    .finally(async () => {
+                        if (Async.JOBS[agent.id][JobID].status !== 'done') {
+                            Async.JOBS[agent.id][JobID].status = 'failed';
+                        }
+                        if (agent.debugSessionEnabled) {
+                            await delay(1000); //wait for the debugger to update the UI
+                            //ctxData in agentRuntime might have been updated by the main component
+                            //we need to reload it in order to ensure that we're updating the latest version
+                            agent.agentRuntime.reloadCtxData();
+                            agent.agentRuntime.updateComponent(config.id, { _job_components: [] });
+                        }
+                    });
+
+                return { JobID };
+            } else {
+                //const Input = input.Input;
+                let result = { JobID: agent.jobID };
+                for (let key in input) {
+                    result[key] = input[key];
+                }
+
+                return result;
+            }
+        } catch (error: any) {
+            _error = error;
+        }
+
+        return {};
+    }
+
+    // private recursiveTagAsyncComponents(component, agent: Agent) {
+    //     for (let output of component.outputs) {
+    //         if (component.name == 'Async' && output.name === 'JobID') continue; //'JobID' is a special output
+    //         const connected = agent.connections.filter((c) => c.sourceId === component.id && c.sourceIndex === output.index);
+    //         if (!connected) continue;
+    //         for (let con of connected) {
+    //             const targetComponent = agent.components[con.targetId];
+    //             if (!targetComponent) continue;
+    //             targetComponent.async = true;
+    //             this.recursiveTagAsyncComponents(targetComponent, agent);
+    //         }
+    //     }
+    // }
+    // private tagAsyncComponents(agent: Agent) {
+    //     const componentsList: any[] = Object.values(agent.components);
+    //     const AsyncComponent = componentsList.find((c) => c.name === 'Async');
+    //     if (!AsyncComponent) return;
+    //     AsyncComponent.async = true;
+
+    //     this.recursiveTagAsyncComponents(AsyncComponent, agent);
+    // }
+    private cleanJobIDBranch(agent: Agent) {
+        //this.tagAsyncComponents(agent);
+
+        const componentsList: any[] = Object.values(agent.components);
+        const AsyncComponent = componentsList.find((c) => c.name === 'Async');
+        //const endpointComponent = componentsList.find((c) => c.name === 'APIEndpoint');
+        if (!AsyncComponent) return;
+        const jobIDOutputIndex = AsyncComponent.outputs.findIndex((o) => o.name === 'JobID');
+        if (jobIDOutputIndex === -1) return;
+        //delete connections where sourceId = AsyncComponent.id and sourceOutputIndex = jobIDOutputIndex and the component is not tagged as async
+        agent.connections = agent.connections.filter((c) => {
+            const toDelete = c.sourceId === AsyncComponent.id && c.sourceIndex === jobIDOutputIndex && !agent.components[c.targetId].async;
+            return !toDelete;
+        });
+
+        //TODO : remove orphaned branches
+        this.removeOrphanedBranches(agent);
+    }
+
+    private removeOrphanedBranches(agent: Agent) {
+        const toDelete: any[] = [];
+        for (let componentId in agent.components) {
+            const component = agent.components[componentId];
+            if (component.name === 'APIEndpoint') continue;
+            const connected = agent.connections.some((c) => c.targetId === component.id);
+            if (!connected) {
+                //this.removeComponent(agent, component.id);
+                toDelete.push(component.id);
+            }
+        }
+        for (let id of toDelete) {
+            this.removeComponent(agent, id);
+        }
+    }
+
+    private removeComponent(agent: Agent, componentId: string) {
+        const component = agent.components[componentId];
+        delete agent.components[componentId];
+
+        //delete connections where sourceId = componentId
+        agent.connections = agent.connections.filter((c) => c.sourceId !== componentId);
+        this.removeOrphanedBranches(agent);
+    }
+}