@smythos/sre 1.5.53 → 1.5.54

package/src/Components/Await.class.ts

@@ -1,90 +1,90 @@
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { Component } from './Component.class';
-import axios from 'axios';
-import Joi from 'joi';
-import { Async } from './Async.class';
-
-export class Await extends Component {
-    static WAITS = {};
-
-    protected configSchema = Joi.object({
-        jobs_count: Joi.number().min(1).max(100).default(1).label('Jobs Count'),
-        max_time: Joi.number().min(1).max(21600).default(1).label('Max time'),
-    });
-    constructor() {
-        super();
-    }
-    init() {}
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-
-        const logger = this.createComponentLogger(agent, config);
-        try {
-            let Results: any = {};
-            const _error = null;
-            let jobs_count = parseInt(config.data.jobs_count || 1);
-            let max_time = parseInt(config.data.max_time || 1);
-
-            const jobs = Array.isArray(input.Jobs) ? input.Jobs : [input.Jobs];
-
-            if (!Await.WAITS[agent.id]) Await.WAITS[agent.id] = {};
-            if (!Await.WAITS[agent.id][config.id]) Await.WAITS[agent.id][config.id] = {};
-            if (!Await.WAITS[agent.id][config.id][agent.agentRuntime.workflowReqId])
-                Await.WAITS[agent.id][config.id][agent.agentRuntime.workflowReqId] = [];
-
-            //add jobs to the list
-            for (let jobID of jobs) Await.WAITS[agent.id][config.id][agent.agentRuntime.workflowReqId].push(jobID);
-
-            logger.debug('Jobs', jobs);
-            logger.debug('Waiting for jobs to finish');
-
-            let promise = new Promise((resolve, reject) => {
-                let interval = setInterval(() => {
-                    if (max_time < 0) {
-                        clearInterval(interval);
-                        return resolve(true);
-                    }
-                    let done = true;
-                    let completed = 0;
-                    for (let jobID of jobs) {
-                        if (Async.JOBS?.[agent.id]?.[jobID]?.status == 'pending') {
-                            done = false;
-                            break;
-                        } else {
-                            completed++;
-                        }
-                    }
-                    if (completed >= jobs_count) {
-                        done = true;
-                    }
-
-                    if (done) {
-                        clearInterval(interval);
-                        return resolve(true);
-                    }
-
-                    max_time -= 1;
-                }, 1000);
-            });
-
-            await promise;
-            logger.debug('Jobs finished, collecting results');
-            for (let jobID of jobs) {
-                Results[jobID] = {
-                    output: Async.JOBS?.[agent.id]?.[jobID]?.result,
-                    status: Async.JOBS?.[agent.id]?.[jobID]?.status || 'unknown_job',
-                };
-            }
-            delete Await.WAITS[agent.id][config.id][agent.agentRuntime.workflowReqId];
-
-            logger.debug('Results', Results);
-            return { Results, _error, _debug: logger.output, _debug_time: logger.elapsedTime };
-        } catch (err: any) {
-            const _error = err?.response?.data || err?.message || err.toString();
-            logger.error(` Error running code \n${_error}\n`);
-            delete Await.WAITS[agent.id][config.id][agent.agentRuntime.workflowReqId];
-
-            return { Output: undefined, _error, _debug: logger.output, _debug_time: logger.elapsedTime };
-        }
-    }
-}
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+import axios from 'axios';
+import Joi from 'joi';
+import { Async } from './Async.class';
+
+export class Await extends Component {
+    static WAITS = {};
+
+    protected configSchema = Joi.object({
+        jobs_count: Joi.number().min(1).max(100).default(1).label('Jobs Count'),
+        max_time: Joi.number().min(1).max(21600).default(1).label('Max time'),
+    });
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+
+        const logger = this.createComponentLogger(agent, config);
+        try {
+            let Results: any = {};
+            const _error = null;
+            let jobs_count = parseInt(config.data.jobs_count || 1);
+            let max_time = parseInt(config.data.max_time || 1);
+
+            const jobs = Array.isArray(input.Jobs) ? input.Jobs : [input.Jobs];
+
+            if (!Await.WAITS[agent.id]) Await.WAITS[agent.id] = {};
+            if (!Await.WAITS[agent.id][config.id]) Await.WAITS[agent.id][config.id] = {};
+            if (!Await.WAITS[agent.id][config.id][agent.agentRuntime.workflowReqId])
+                Await.WAITS[agent.id][config.id][agent.agentRuntime.workflowReqId] = [];
+
+            //add jobs to the list
+            for (let jobID of jobs) Await.WAITS[agent.id][config.id][agent.agentRuntime.workflowReqId].push(jobID);
+
+            logger.debug('Jobs', jobs);
+            logger.debug('Waiting for jobs to finish');
+
+            let promise = new Promise((resolve, reject) => {
+                let interval = setInterval(() => {
+                    if (max_time < 0) {
+                        clearInterval(interval);
+                        return resolve(true);
+                    }
+                    let done = true;
+                    let completed = 0;
+                    for (let jobID of jobs) {
+                        if (Async.JOBS?.[agent.id]?.[jobID]?.status == 'pending') {
+                            done = false;
+                            break;
+                        } else {
+                            completed++;
+                        }
+                    }
+                    if (completed >= jobs_count) {
+                        done = true;
+                    }
+
+                    if (done) {
+                        clearInterval(interval);
+                        return resolve(true);
+                    }
+
+                    max_time -= 1;
+                }, 1000);
+            });
+
+            await promise;
+            logger.debug('Jobs finished, collecting results');
+            for (let jobID of jobs) {
+                Results[jobID] = {
+                    output: Async.JOBS?.[agent.id]?.[jobID]?.result,
+                    status: Async.JOBS?.[agent.id]?.[jobID]?.status || 'unknown_job',
+                };
+            }
+            delete Await.WAITS[agent.id][config.id][agent.agentRuntime.workflowReqId];
+
+            logger.debug('Results', Results);
+            return { Results, _error, _debug: logger.output, _debug_time: logger.elapsedTime };
+        } catch (err: any) {
+            const _error = err?.response?.data || err?.message || err.toString();
+            logger.error(` Error running code \n${_error}\n`);
+            delete Await.WAITS[agent.id][config.id][agent.agentRuntime.workflowReqId];
+
+            return { Output: undefined, _error, _debug: logger.output, _debug_time: logger.elapsedTime };
+        }
+    }
+}

package/src/Components/Classifier.class.ts

@@ -1,158 +1,158 @@
-import Joi from 'joi';
-
-import { JSONContentHelper } from '@sre/helpers/JsonContent.helper';
-import { Component } from './Component.class';
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { TemplateString } from '@sre/helpers/TemplateString.helper';
-import { LLMInference } from '@sre/LLMManager/LLM.inference';
-import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-
-export class Classifier extends Component {
-    protected schema = {
-        name: 'Classifier',
-        settings: {
-            model: {
-                type: 'string',
-                max: 200,
-                required: true,
-            },
-            prompt: {
-                type: 'string',
-                max: 30000,
-                allow: '',
-                label: 'Prompt',
-            },
-        },
-
-        inputs: {
-            Input: {
-                type: 'Any',
-                default: true,
-            },
-        },
-    };
-    protected configSchema = Joi.object({
-        model: Joi.string().max(200).required(),
-        prompt: Joi.string().max(30000).allow('').label('Prompt'),
-    });
-    constructor() {
-        super();
-    }
-    init() {}
-    escapeJSONString(str: string) {
-        return str.replace(/\{/g, '<[<(').replace(/\}/g, ')>]>').replace(/"/g, '`');
-    }
-    unescapeJSONString(str: string) {
-        return str
-            .replace(/<\[<\(/g, '{')
-            .replace(/\)>]>/g, '}')
-            .replace(/`/g, '"');
-    }
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-        //let debugLog = agent.agentRuntime?.debug ? [] : undefined;
-        const logger = this.createComponentLogger(agent, config);
-
-        const inputCopy = JSON.parse(JSON.stringify(input));
-        for (let key in inputCopy) {
-            if (typeof inputCopy[key] === 'string') {
-                inputCopy[key] = this.escapeJSONString(inputCopy[key]);
-            } else if (typeof inputCopy[key] === 'object') {
-                inputCopy[key] = JSON.stringify(inputCopy[key]);
-                inputCopy[key] = this.escapeJSONString(inputCopy[key]);
-            }
-        }
-
-        const _input = typeof input === 'string' ? input : JSON.stringify(inputCopy, null, 2);
-        //const categories = config.outputs.map((output) => (output.name[0] != '[' ? output.name : null)).filter((e) => e);
-        const categories = {};
-        for (let con of config.outputs) categories[con.name] = con.description || '';
-
-        const outputs = {};
-        for (let con of config.outputs) {
-            outputs[con.name] = '<Boolean|String>';
-        }
-
-        const model: string = config.data.model;
-        const modelId = await agent.modelsProvider.getModelId(model);
-        //const isStandardLLM = await agent.modelsProvider.isStandardLLM(model);
-
-        logger.log(` Selected model : ${modelId || model}`);
-
-        let prompt = '';
-        const excludedKeys = ['_debug', '_error'];
-        const outputKeys = Object.keys(outputs).filter((key) => !excludedKeys.includes(key));
-
-        if (outputKeys.length > 0) {
-            const outputFormat = {};
-            outputKeys.forEach((key) => (outputFormat[key] = outputs[key]));
-
-            prompt = `${config.data.prompt}
-${_input}
-
----
-Categories: 
-${JSON.stringify(categories, null, 2)}`;
-
-            prompt = TemplateString(prompt).parse(input).result;
-        }
-
-        logger.log(` Enhanced prompt \n${prompt}\n`);
-
-        if (!prompt) {
-            logger.error(` Missing information, Cannot run classifier`);
-
-            return { _error: 'Missing information, Cannot run classifier', _debug: logger.output };
-        }
-
-        const llmInference: LLMInference = await LLMInference.getInstance(model || 'echo', AccessCandidate.agent(agent.id));
-        if (!llmInference.connector) {
-            return {
-                _error: `The model '${model}' is not available. Please try a different one.`,
-                _debug: logger.output,
-            };
-        }
-
-        try {
-            let response = await llmInference
-                .prompt({ query: prompt, params: { ...config, agentId: agent.id } })
-                .catch((error) => ({ error: error }));
-
-            if (response?.error) {
-                const error = response?.error + ' ' + (response?.details || '');
-                logger.error(` LLM Error=`, error);
-
-                return { _error: error, _debug: logger.output };
-            }
-
-            // let parsed = parseJson(response);
-            let parsed = typeof response === 'string' ? JSONContentHelper.create(response).tryParse() : response;
-
-            for (let entry in parsed) {
-                if (!parsed[entry]) delete parsed[entry];
-                else {
-                    if (typeof parsed[entry] === 'string') {
-                        parsed[entry] = this.unescapeJSONString(parsed[entry]);
-                        // const parsedValue = parseJson(parsed[entry]);
-                        const parsedValue = JSONContentHelper.create(parsed[entry]).tryParse();
-                        if (typeof parsedValue === 'object' && !parsedValue.error) parsed[entry] = parsedValue;
-                    }
-                }
-            }
-
-            if (parsed.error) {
-                parsed._error = parsed.error;
-                logger.warn(` Post process error=${parsed.error}`);
-                delete parsed.error;
-            }
-
-            logger.log(' Classifier result\n', parsed);
-
-            parsed['_debug'] = logger.output;
-
-            return parsed;
-        } catch (error) {
-            return { _error: error.message, _debug: logger.output };
-        }
-    }
-}
+import Joi from 'joi';
+
+import { JSONContentHelper } from '@sre/helpers/JsonContent.helper';
+import { Component } from './Component.class';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+import { LLMInference } from '@sre/LLMManager/LLM.inference';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+
+export class Classifier extends Component {
+    protected schema = {
+        name: 'Classifier',
+        settings: {
+            model: {
+                type: 'string',
+                max: 200,
+                required: true,
+            },
+            prompt: {
+                type: 'string',
+                max: 30000,
+                allow: '',
+                label: 'Prompt',
+            },
+        },
+
+        inputs: {
+            Input: {
+                type: 'Any',
+                default: true,
+            },
+        },
+    };
+    protected configSchema = Joi.object({
+        model: Joi.string().max(200).required(),
+        prompt: Joi.string().max(30000).allow('').label('Prompt'),
+    });
+    constructor() {
+        super();
+    }
+    init() {}
+    escapeJSONString(str: string) {
+        return str.replace(/\{/g, '<[<(').replace(/\}/g, ')>]>').replace(/"/g, '`');
+    }
+    unescapeJSONString(str: string) {
+        return str
+            .replace(/<\[<\(/g, '{')
+            .replace(/\)>]>/g, '}')
+            .replace(/`/g, '"');
+    }
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+        //let debugLog = agent.agentRuntime?.debug ? [] : undefined;
+        const logger = this.createComponentLogger(agent, config);
+
+        const inputCopy = JSON.parse(JSON.stringify(input));
+        for (let key in inputCopy) {
+            if (typeof inputCopy[key] === 'string') {
+                inputCopy[key] = this.escapeJSONString(inputCopy[key]);
+            } else if (typeof inputCopy[key] === 'object') {
+                inputCopy[key] = JSON.stringify(inputCopy[key]);
+                inputCopy[key] = this.escapeJSONString(inputCopy[key]);
+            }
+        }
+
+        const _input = typeof input === 'string' ? input : JSON.stringify(inputCopy, null, 2);
+        //const categories = config.outputs.map((output) => (output.name[0] != '[' ? output.name : null)).filter((e) => e);
+        const categories = {};
+        for (let con of config.outputs) categories[con.name] = con.description || '';
+
+        const outputs = {};
+        for (let con of config.outputs) {
+            outputs[con.name] = '<Boolean|String>';
+        }
+
+        const model: string = config.data.model;
+        const modelId = await agent.modelsProvider.getModelId(model);
+        //const isStandardLLM = await agent.modelsProvider.isStandardLLM(model);
+
+        logger.log(` Selected model : ${modelId || model}`);
+
+        let prompt = '';
+        const excludedKeys = ['_debug', '_error'];
+        const outputKeys = Object.keys(outputs).filter((key) => !excludedKeys.includes(key));
+
+        if (outputKeys.length > 0) {
+            const outputFormat = {};
+            outputKeys.forEach((key) => (outputFormat[key] = outputs[key]));
+
+            prompt = `${config.data.prompt}
+${_input}
+
+---
+Categories: 
+${JSON.stringify(categories, null, 2)}`;
+
+            prompt = TemplateString(prompt).parse(input).result;
+        }
+
+        logger.log(` Enhanced prompt \n${prompt}\n`);
+
+        if (!prompt) {
+            logger.error(` Missing information, Cannot run classifier`);
+
+            return { _error: 'Missing information, Cannot run classifier', _debug: logger.output };
+        }
+
+        const llmInference: LLMInference = await LLMInference.getInstance(model || 'echo', AccessCandidate.agent(agent.id));
+        if (!llmInference.connector) {
+            return {
+                _error: `The model '${model}' is not available. Please try a different one.`,
+                _debug: logger.output,
+            };
+        }
+
+        try {
+            let response = await llmInference
+                .prompt({ query: prompt, params: { ...config, agentId: agent.id } })
+                .catch((error) => ({ error: error }));
+
+            if (response?.error) {
+                const error = response?.error + ' ' + (response?.details || '');
+                logger.error(` LLM Error=`, error);
+
+                return { _error: error, _debug: logger.output };
+            }
+
+            // let parsed = parseJson(response);
+            let parsed = typeof response === 'string' ? JSONContentHelper.create(response).tryParse() : response;
+
+            for (let entry in parsed) {
+                if (!parsed[entry]) delete parsed[entry];
+                else {
+                    if (typeof parsed[entry] === 'string') {
+                        parsed[entry] = this.unescapeJSONString(parsed[entry]);
+                        // const parsedValue = parseJson(parsed[entry]);
+                        const parsedValue = JSONContentHelper.create(parsed[entry]).tryParse();
+                        if (typeof parsedValue === 'object' && !parsedValue.error) parsed[entry] = parsedValue;
+                    }
+                }
+            }
+
+            if (parsed.error) {
+                parsed._error = parsed.error;
+                logger.warn(` Post process error=${parsed.error}`);
+                delete parsed.error;
+            }
+
+            logger.log(' Classifier result\n', parsed);
+
+            parsed['_debug'] = logger.output;
+
+            return parsed;
+        } catch (error) {
+            return { _error: error.message, _debug: logger.output };
+        }
+    }
+}