@smythos/sre 1.5.43 → 1.5.45

package/src/Components/ServerlessCode.class.ts

@@ -1,123 +1,123 @@
-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 { AWSCredentials, AWSRegionConfig } from '@sre/types/AWS.types';
-import { calculateExecutionCost, generateCodeFromLegacyComponent, getLambdaCredentials, reportUsage } from '@sre/helpers/AWSLambdaCode.helper';
-import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-
-export class ServerlessCode extends Component {
-
-    protected configSchema = Joi.object({
-        code_imports: Joi.string().max(1000).allow('').label('Imports'),
-        code_body: Joi.string().max(500000).allow('').label('Code'),
-        code: Joi.string().max(500000).allow('').label('Code').optional(),
-        deploy_btn: Joi.string().max(500000).allow('').label('Deploy').optional(),
-        accessKeyId: Joi.string().max(100).allow('').label('AWS Access Key ID').optional(),
-        secretAccessKey: Joi.string().max(200).allow('').label('AWS Secret Access Key').optional(),
-        region: Joi.string().label('AWS Region').optional(),
-        _templateSettings: Joi.object().allow(null).label('Template Settings'),
-        _templateVars: Joi.object().allow(null).label('Template Variables'),
-        function_label: Joi.string().max(100).allow('').label('Function Label').optional(),
-        function_label_end: Joi.string().allow(null).label('Function Label End').optional(),
-        use_own_keys: Joi.boolean().label('Use Own Keys').optional(),
-        pricing_note: Joi.string().allow(null).label('Pricing Note').optional(),
-    });
-    constructor() {
-        super();
-    }
-    init() { }
-
-    async process(input, config, agent: Agent) {
-        await new Promise(resolve => setTimeout(resolve, 10000));
-        await super.process(input, config, agent);
-        const logger = this.createComponentLogger(agent, config);
-        try {
-            logger.debug(`=== Serverless Code Log ===`);
-            let Output: any = {};
-            let _error = undefined;
-            const componentInputs = agent.components[config.id]?.inputs || {};
-
-            let codeInputs = {};
-            for (let field of componentInputs) {
-                const _type = typeof input[field.name];
-                switch (_type) {
-                    case 'string':
-                        try {
-                            codeInputs[field.name] = JSON.parse(input[field.name].replace(/\\"/g, '"'));
-                        } catch (error) {
-                            codeInputs[field.name] = `${input[field.name]}`;
-                        }
-                        break;
-                    case 'number':
-                    case 'boolean':
-                        codeInputs[field.name] = input[field.name];
-                        break;
-                    default:
-                        codeInputs[field.name] = input[field.name];
-                        break;
-                }
-            }
-
-            logger.debug(`\nInput Variables: \n${JSON.stringify(codeInputs, null, 2)}\n`);
-
-            let codeConnector = ConnectorService.getCodeConnector();
-            let codeCredentials: AWSCredentials & AWSRegionConfig & { isUserProvidedKeys: boolean } =
-                await getLambdaCredentials(agent, config);
-
-            if (codeCredentials.isUserProvidedKeys) {
-                codeConnector = codeConnector.instance({
-                    region: codeCredentials.region,
-                    accessKeyId: codeCredentials.accessKeyId,
-                    secretAccessKey: codeCredentials.secretAccessKey,
-                })
-            }
-            let code = config?.data?.code;
-            if (!code) {
-                code = generateCodeFromLegacyComponent(config.data.code_body, config.data.code_imports, Object.keys(codeInputs))
-            }
-            // Deploy lambda function if it doesn't exist or the code hash is different
-            await codeConnector.agent(agent.id)
-                .deploy(config.id, {
-                    code,
-                    inputs: codeInputs,
-                }, {
-                    runtime: 'nodejs',
-                });
-
-            try {
-                const executionResponse = await codeConnector.agent(agent.id).execute(config.id, codeInputs);
-                const executionTime = executionResponse.executionTime;
-                logger.debug(
-                    `Code result:\n ${typeof executionResponse.output === 'object' ? JSON.stringify(executionResponse.output, null, 2) : executionResponse.output
-                    }\n`,
-                );
-                logger.debug(`Execution time: ${executionTime}ms\n`);
-
-                const cost = calculateExecutionCost(executionTime);
-                if (!codeCredentials.isUserProvidedKeys) {
-                    const accountConnector = ConnectorService.getAccountConnector();
-                    const agentTeam = await accountConnector.getCandidateTeam(AccessCandidate.agent(agent.id));
-                    reportUsage({ cost, agentId: agent.id, teamId: agentTeam });
-                }
-
-                if (executionResponse.success) {
-                    Output = executionResponse.output;
-                } else {
-                    Output = undefined;
-                    _error = executionResponse.errors;
-                }
-            } catch (error: any) {
-                logger.error(`Error running code \n${error}\n`);
-                _error = error?.response?.data || error?.message || error.toString();
-                Output = undefined; //prevents running next component if the code execution failed
-            }
-
-            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 };
-        }
-    }
-}
+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 { AWSCredentials, AWSRegionConfig } from '@sre/types/AWS.types';
+import { calculateExecutionCost, generateCodeFromLegacyComponent, getLambdaCredentials, reportUsage } from '@sre/helpers/AWSLambdaCode.helper';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+
+export class ServerlessCode extends Component {
+
+    protected configSchema = Joi.object({
+        code_imports: Joi.string().max(1000).allow('').label('Imports'),
+        code_body: Joi.string().max(500000).allow('').label('Code'),
+        code: Joi.string().max(500000).allow('').label('Code').optional(),
+        deploy_btn: Joi.string().max(500000).allow('').label('Deploy').optional(),
+        accessKeyId: Joi.string().max(100).allow('').label('AWS Access Key ID').optional(),
+        secretAccessKey: Joi.string().max(200).allow('').label('AWS Secret Access Key').optional(),
+        region: Joi.string().label('AWS Region').optional(),
+        _templateSettings: Joi.object().allow(null).label('Template Settings'),
+        _templateVars: Joi.object().allow(null).label('Template Variables'),
+        function_label: Joi.string().max(100).allow('').label('Function Label').optional(),
+        function_label_end: Joi.string().allow(null).label('Function Label End').optional(),
+        use_own_keys: Joi.boolean().label('Use Own Keys').optional(),
+        pricing_note: Joi.string().allow(null).label('Pricing Note').optional(),
+    });
+    constructor() {
+        super();
+    }
+    init() { }
+
+    async process(input, config, agent: Agent) {
+        await new Promise(resolve => setTimeout(resolve, 10000));
+        await super.process(input, config, agent);
+        const logger = this.createComponentLogger(agent, config);
+        try {
+            logger.debug(`=== Serverless Code Log ===`);
+            let Output: any = {};
+            let _error = undefined;
+            const componentInputs = agent.components[config.id]?.inputs || {};
+
+            let codeInputs = {};
+            for (let field of componentInputs) {
+                const _type = typeof input[field.name];
+                switch (_type) {
+                    case 'string':
+                        try {
+                            codeInputs[field.name] = JSON.parse(input[field.name].replace(/\\"/g, '"'));
+                        } catch (error) {
+                            codeInputs[field.name] = `${input[field.name]}`;
+                        }
+                        break;
+                    case 'number':
+                    case 'boolean':
+                        codeInputs[field.name] = input[field.name];
+                        break;
+                    default:
+                        codeInputs[field.name] = input[field.name];
+                        break;
+                }
+            }
+
+            logger.debug(`\nInput Variables: \n${JSON.stringify(codeInputs, null, 2)}\n`);
+
+            let codeConnector = ConnectorService.getCodeConnector();
+            let codeCredentials: AWSCredentials & AWSRegionConfig & { isUserProvidedKeys: boolean } =
+                await getLambdaCredentials(agent, config);
+
+            if (codeCredentials.isUserProvidedKeys) {
+                codeConnector = codeConnector.instance({
+                    region: codeCredentials.region,
+                    accessKeyId: codeCredentials.accessKeyId,
+                    secretAccessKey: codeCredentials.secretAccessKey,
+                })
+            }
+            let code = config?.data?.code;
+            if (!code) {
+                code = generateCodeFromLegacyComponent(config.data.code_body, config.data.code_imports, Object.keys(codeInputs))
+            }
+            // Deploy lambda function if it doesn't exist or the code hash is different
+            await codeConnector.agent(agent.id)
+                .deploy(config.id, {
+                    code,
+                    inputs: codeInputs,
+                }, {
+                    runtime: 'nodejs',
+                });
+
+            try {
+                const executionResponse = await codeConnector.agent(agent.id).execute(config.id, codeInputs);
+                const executionTime = executionResponse.executionTime;
+                logger.debug(
+                    `Code result:\n ${typeof executionResponse.output === 'object' ? JSON.stringify(executionResponse.output, null, 2) : executionResponse.output
+                    }\n`,
+                );
+                logger.debug(`Execution time: ${executionTime}ms\n`);
+
+                const cost = calculateExecutionCost(executionTime);
+                if (!codeCredentials.isUserProvidedKeys) {
+                    const accountConnector = ConnectorService.getAccountConnector();
+                    const agentTeam = await accountConnector.getCandidateTeam(AccessCandidate.agent(agent.id));
+                    reportUsage({ cost, agentId: agent.id, teamId: agentTeam });
+                }
+
+                if (executionResponse.success) {
+                    Output = executionResponse.output;
+                } else {
+                    Output = undefined;
+                    _error = executionResponse.errors;
+                }
+            } catch (error: any) {
+                logger.error(`Error running code \n${error}\n`);
+                _error = error?.response?.data || error?.message || error.toString();
+                Output = undefined; //prevents running next component if the code execution failed
+            }
+
+            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 };
+        }
+    }
+}

package/src/Components/TavilyWebSearch.class.ts

@@ -1,98 +1,98 @@
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { Component } from './Component.class';
-import Joi from 'joi';
-import SREConfig from '@sre/config';
-import axios from 'axios';
-import { SystemEvents } from '@sre/Core/SystemEvents';
-import { getCredentials } from '../subsystems/Security/Credentials.helper';
-import { AccessCandidate } from '../subsystems/Security/AccessControl/AccessCandidate.class';
-
-export class TavilyWebSearch extends Component {
-    protected schema = {
-        name: 'TavilyWebSearch',
-        description: 'Use this component to generate a responses from an LLM',
-
-        inputs: {
-            SearchQuery: {
-                type: 'Text',
-                description: 'The search query to get the web search results of',
-                default: true,
-            },
-        },
-        outputs: {
-            Results: {
-                type: 'Array',
-                description: 'The web search results',
-                default: true,
-            },
-        },
-    };
-
-    protected configSchema = Joi.object({
-        includeImages: Joi.boolean().default(false).label('Include Image Results'),
-        sourcesLimit: Joi.number().integer().default(10).label('Sources Limit'),
-        searchTopic: Joi.string().valid('general', 'news').label('Search Topic'),
-        includeQAs: Joi.boolean().default(false).label('Include QAs'),
-        timeRange: Joi.string().valid('None', 'day', 'week', 'month', 'year').label('Time Range'),
-        includeRawContent: Joi.boolean().default(false).label('Include Raw Content'),
-        excludeDomains: Joi.string().allow('').label('Exclude Domains'),
-    });
-    constructor() {
-        super();
-    }
-    init() {}
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-
-        const logger = this.createComponentLogger(agent, config);
-        try {
-            logger.debug(`=== Web Scrape Log ===`);
-            let Output: any = {};
-            let _error = undefined;
-            let searchQuery = input['SearchQuery'];
-
-            const teamId = agent.teamId;
-            const api_key = await getCredentials(AccessCandidate.team(teamId), 'tavily');
-
-            logger.debug('Payload:', JSON.stringify(config.data));
-            const response = await axios({
-                method: 'post',
-                url: 'https://api.tavily.com/search',
-                data: {
-                    api_key,
-                    query: searchQuery,
-                    topic: config.data.searchTopic,
-                    exclude_domains: config.data.excludeDomains?.length ? config.data.excludeDomains.split(',') : [],
-                    max_results: config.data.sourcesLimit,
-                    ...(config.data.timeRange !== 'None' ? { time_range: config.data.timeRange } : {}),
-                    ...(config.data.includeImages ? { include_images: true } : {}),
-                    ...(config.data.includeQAs ? { include_answer: true } : {}),
-                    ...(config.data.includeRawContent ? { include_raw_content: true } : {}),
-                },
-            });
-            Output = {
-                Results: response.data.results,
-                ...(config.data.includeImages ? { Images: response.data.images } : {}),
-                ...(config.data.includeQAs ? { Answer: response.data.answer } : {}),
-            };
-            this.reportUsage({
-                agentId: agent.id,
-                teamId: agent.teamId,
-            });
-            return { ...Output, _error, _debug: logger.output };
-        } catch (err: any) {
-            const _error = err?.message || err?.response?.data || err.toString();
-            logger.error(` Error scraping web \n${JSON.stringify(_error)}\n`);
-            return { Output: undefined, _error, _debug: logger.output };
-        }
-    }
-
-    protected reportUsage({ agentId, teamId }: { agentId: string; teamId: string }) {
-        SystemEvents.emit('USAGE:API', {
-            sourceId: 'api:websearch.smyth',
-            credits: 1,
-            agentId,
-            teamId,
-        });
-    }
-}
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+import Joi from 'joi';
+import SREConfig from '@sre/config';
+import axios from 'axios';
+import { SystemEvents } from '@sre/Core/SystemEvents';
+import { getCredentials } from '../subsystems/Security/Credentials.helper';
+import { AccessCandidate } from '../subsystems/Security/AccessControl/AccessCandidate.class';
+
+export class TavilyWebSearch extends Component {
+    protected schema = {
+        name: 'TavilyWebSearch',
+        description: 'Use this component to generate a responses from an LLM',
+
+        inputs: {
+            SearchQuery: {
+                type: 'Text',
+                description: 'The search query to get the web search results of',
+                default: true,
+            },
+        },
+        outputs: {
+            Results: {
+                type: 'Array',
+                description: 'The web search results',
+                default: true,
+            },
+        },
+    };
+
+    protected configSchema = Joi.object({
+        includeImages: Joi.boolean().default(false).label('Include Image Results'),
+        sourcesLimit: Joi.number().integer().default(10).label('Sources Limit'),
+        searchTopic: Joi.string().valid('general', 'news').label('Search Topic'),
+        includeQAs: Joi.boolean().default(false).label('Include QAs'),
+        timeRange: Joi.string().valid('None', 'day', 'week', 'month', 'year').label('Time Range'),
+        includeRawContent: Joi.boolean().default(false).label('Include Raw Content'),
+        excludeDomains: Joi.string().allow('').label('Exclude Domains'),
+    });
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+
+        const logger = this.createComponentLogger(agent, config);
+        try {
+            logger.debug(`=== Web Scrape Log ===`);
+            let Output: any = {};
+            let _error = undefined;
+            let searchQuery = input['SearchQuery'];
+
+            const teamId = agent.teamId;
+            const api_key = await getCredentials(AccessCandidate.team(teamId), 'tavily');
+
+            logger.debug('Payload:', JSON.stringify(config.data));
+            const response = await axios({
+                method: 'post',
+                url: 'https://api.tavily.com/search',
+                data: {
+                    api_key,
+                    query: searchQuery,
+                    topic: config.data.searchTopic,
+                    exclude_domains: config.data.excludeDomains?.length ? config.data.excludeDomains.split(',') : [],
+                    max_results: config.data.sourcesLimit,
+                    ...(config.data.timeRange !== 'None' ? { time_range: config.data.timeRange } : {}),
+                    ...(config.data.includeImages ? { include_images: true } : {}),
+                    ...(config.data.includeQAs ? { include_answer: true } : {}),
+                    ...(config.data.includeRawContent ? { include_raw_content: true } : {}),
+                },
+            });
+            Output = {
+                Results: response.data.results,
+                ...(config.data.includeImages ? { Images: response.data.images } : {}),
+                ...(config.data.includeQAs ? { Answer: response.data.answer } : {}),
+            };
+            this.reportUsage({
+                agentId: agent.id,
+                teamId: agent.teamId,
+            });
+            return { ...Output, _error, _debug: logger.output };
+        } catch (err: any) {
+            const _error = err?.message || err?.response?.data || err.toString();
+            logger.error(` Error scraping web \n${JSON.stringify(_error)}\n`);
+            return { Output: undefined, _error, _debug: logger.output };
+        }
+    }
+
+    protected reportUsage({ agentId, teamId }: { agentId: string; teamId: string }) {
+        SystemEvents.emit('USAGE:API', {
+            sourceId: 'api:websearch.smyth',
+            credits: 1,
+            agentId,
+            teamId,
+        });
+    }
+}

package/src/Components/VisionLLM.class.ts

@@ -1,104 +1,104 @@
-import Joi from 'joi';
-
-import { TemplateString } from '@sre/helpers/TemplateString.helper';
-import { Component } from './Component.class';
-import { LLMInference } from '@sre/LLMManager/LLM.inference';
-import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-
-export class VisionLLM extends Component {
-    protected configSchema = Joi.object({
-        prompt: Joi.string().required().max(8_000_000).label('Prompt'), // 2M tokens is around 8M characters
-        maxTokens: Joi.number().min(1).label('Maximum Tokens'),
-        model: Joi.string().max(200).required(),
-        passthrough: Joi.boolean().optional().label('Passthrough'),
-    });
-
-    constructor() {
-        super();
-    }
-
-    init() {}
-
-    async process(input, config, agent) {
-        await super.process(input, config, agent);
-
-        const logger = this.createComponentLogger(agent, config);
-        try {
-            logger.debug(`=== Vision LLM Log ===`);
-
-            const passThrough: boolean = config.data.passthrough || false;
-            const model: string = config.data?.model;
-
-            const llmInference: LLMInference = await LLMInference.getInstance(model, AccessCandidate.agent(agent.id));
-            // if the llm is undefined, then it means we removed the model from our system
-            if (!llmInference.connector) {
-                return {
-                    _error: `The model '${model}' is not available. Please try a different one.`,
-                    _debug: logger.output,
-                };
-            }
-
-            const modelId = await agent.modelsProvider.getModelId(model);
-            logger.debug(` Model : ${modelId || model}`);
-
-            let prompt: any = TemplateString(config.data.prompt).parse(input).result;
-
-            logger.debug(` Prompt\n`, prompt, '\n');
-
-            const files = Array.isArray(input.Images) ? input.Images : [input.Images];
-
-            let response: any;
-            if (passThrough) {
-                const contentPromise = new Promise(async (resolve, reject) => {
-                    let _content = '';
-                    const eventEmitter: any = await llmInference.multimodalStreamRequestLegacy(prompt, files, config, agent).catch((error) => {
-                        console.error('Error on multimodalStreamRequest: ', error);
-                        reject(error);
-                    });
-                    eventEmitter.on('content', (content) => {
-                        if (typeof agent.callback === 'function') {
-                            agent.callback({ content });
-                        }
-                        agent.sse.send('llm/passthrough/content', content);
-                        _content += content;
-                    });
-                    eventEmitter.on('thinking', (thinking) => {
-                        if (typeof agent.callback === 'function') {
-                            agent.callback({ thinking });
-                        }
-                        agent.sse.send('llm/passthrough/thinking', thinking);
-                    });
-                    eventEmitter.on('end', () => {
-                        console.log('end');
-                        resolve(_content);
-                    });
-                });
-                response = await contentPromise;
-            } else {
-                response = await llmInference.prompt({ query: prompt, files, params: { ...config, agentId: agent.id } });
-            }
-
-            // in case we have the response but it's empty string, undefined or null
-            if (!response) {
-                return { _error: ' LLM Error = Empty Response!', _debug: logger.output };
-            }
-
-            if (response?.error) {
-                const error = response?.error + ' ' + (response?.details || '');
-                logger.error(` LLM Error=`, error);
-
-                return { Reply: response?.data, _error: error, _debug: logger.output };
-            }
-
-            logger.debug(' Response \n', response);
-
-            const result = { Reply: response };
-
-            result['_debug'] = logger.output;
-
-            return result;
-        } catch (error: any) {
-            return { _error: error.message, _debug: logger.output };
-        }
-    }
-}
+import Joi from 'joi';
+
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+import { Component } from './Component.class';
+import { LLMInference } from '@sre/LLMManager/LLM.inference';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+
+export class VisionLLM extends Component {
+    protected configSchema = Joi.object({
+        prompt: Joi.string().required().max(8_000_000).label('Prompt'), // 2M tokens is around 8M characters
+        maxTokens: Joi.number().min(1).label('Maximum Tokens'),
+        model: Joi.string().max(200).required(),
+        passthrough: Joi.boolean().optional().label('Passthrough'),
+    });
+
+    constructor() {
+        super();
+    }
+
+    init() {}
+
+    async process(input, config, agent) {
+        await super.process(input, config, agent);
+
+        const logger = this.createComponentLogger(agent, config);
+        try {
+            logger.debug(`=== Vision LLM Log ===`);
+
+            const passThrough: boolean = config.data.passthrough || false;
+            const model: string = config.data?.model;
+
+            const llmInference: LLMInference = await LLMInference.getInstance(model, AccessCandidate.agent(agent.id));
+            // if the llm is undefined, then it means we removed the model from our system
+            if (!llmInference.connector) {
+                return {
+                    _error: `The model '${model}' is not available. Please try a different one.`,
+                    _debug: logger.output,
+                };
+            }
+
+            const modelId = await agent.modelsProvider.getModelId(model);
+            logger.debug(` Model : ${modelId || model}`);
+
+            let prompt: any = TemplateString(config.data.prompt).parse(input).result;
+
+            logger.debug(` Prompt\n`, prompt, '\n');
+
+            const files = Array.isArray(input.Images) ? input.Images : [input.Images];
+
+            let response: any;
+            if (passThrough) {
+                const contentPromise = new Promise(async (resolve, reject) => {
+                    let _content = '';
+                    const eventEmitter: any = await llmInference.multimodalStreamRequestLegacy(prompt, files, config, agent).catch((error) => {
+                        console.error('Error on multimodalStreamRequest: ', error);
+                        reject(error);
+                    });
+                    eventEmitter.on('content', (content) => {
+                        if (typeof agent.callback === 'function') {
+                            agent.callback({ content });
+                        }
+                        agent.sse.send('llm/passthrough/content', content);
+                        _content += content;
+                    });
+                    eventEmitter.on('thinking', (thinking) => {
+                        if (typeof agent.callback === 'function') {
+                            agent.callback({ thinking });
+                        }
+                        agent.sse.send('llm/passthrough/thinking', thinking);
+                    });
+                    eventEmitter.on('end', () => {
+                        console.log('end');
+                        resolve(_content);
+                    });
+                });
+                response = await contentPromise;
+            } else {
+                response = await llmInference.prompt({ query: prompt, files, params: { ...config, agentId: agent.id } });
+            }
+
+            // in case we have the response but it's empty string, undefined or null
+            if (!response) {
+                return { _error: ' LLM Error = Empty Response!', _debug: logger.output };
+            }
+
+            if (response?.error) {
+                const error = response?.error + ' ' + (response?.details || '');
+                logger.error(` LLM Error=`, error);
+
+                return { Reply: response?.data, _error: error, _debug: logger.output };
+            }
+
+            logger.debug(' Response \n', response);
+
+            const result = { Reply: response };
+
+            result['_debug'] = logger.output;
+
+            return result;
+        } catch (error: any) {
+            return { _error: error.message, _debug: logger.output };
+        }
+    }
+}