@smythos/sre 1.5.43 → 1.5.45

package/src/Components/Component.class.ts

@@ -1,132 +1,132 @@
-import Joi from 'joi';
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { Logger } from '@sre/helpers/Log.helper';
-import { performTypeInference } from '@sre/helpers/TypeChecker.helper';
-import { hookAsync } from '@sre/Core/HookService';
-
-export type ComponentSchema = {
-    name: string;
-    settings?: Record<string, any>;
-    inputs?: Record<string, any>;
-    outputs?: Record<string, any>;
-};
-
-export class Component {
-    public hasReadOutput = false;
-    public hasPostProcess = true;
-    public alwaysActive = false; //for components like readable memories
-    public exclusive = false; //for components like writable memories : when exclusive components are active, they are processed in a run cycle bofore other components
-    protected schema: ComponentSchema = {
-        name: 'Component',
-        settings: {},
-        inputs: {},
-        //outputs: {},
-    };
-    protected configSchema;
-    constructor() {}
-    init() {}
-
-    createComponentLogger(agent: Agent, configuration: any) {
-        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) {
-                agent.sse.send('component', {
-                    eventId: configuration.eventId,
-                    action: 'log',
-                    name: configuration.name || this.constructor.name,
-                    title: configuration.title,
-                    logs: [{ level: info.level, message: info.message }],
-                });
-            }
-        });
-        return logger;
-    }
-
-    /**
-     * Filters config data to only include properties that are defined in the schema
-     */
-    private filterConfigBySchema(data: any, schema: any): any {
-        if (!schema || !data) return data;
-
-        const schemaDescription = schema.describe();
-
-        // If it's not an object schema, return data as-is
-        if (schemaDescription.type !== 'object' || !schemaDescription.keys) {
-            return data;
-        }
-
-        const allowedKeys = Object.keys(schemaDescription.keys);
-        const filteredData: any = {};
-
-        // Only include properties that are defined in the schema
-        for (const key of allowedKeys) {
-            if (key in data) {
-                filteredData[key] = data[key];
-            }
-        }
-
-        // Preserve _templateVars if it exists (special case)
-        if (data._templateVars) {
-            filteredData._templateVars = data._templateVars;
-        }
-
-        return filteredData;
-    }
-
-    async validateConfig(config) {
-        if (!this.configSchema) return {};
-
-        let workingSchema = this.configSchema;
-
-        if (config.data._templateVars) {
-            //Accept dynamically added template data
-            for (let tplVar in config.data._templateVars) {
-                workingSchema = workingSchema.append({ [tplVar]: Joi.any() });
-            }
-        }
-
-        // Filter config.data to only include properties defined in the schema
-        const filteredData = this.filterConfigBySchema(config.data, workingSchema);
-
-        const valid = await workingSchema.validate(filteredData);
-        if (valid.error) {
-            return {
-                id: config.id,
-                name: config.name,
-                _error: `Schema Validation error: ${valid?.error?.message} on component ${config.displayName}:${config.title}`,
-                _debug: `Schema Validation error: ${valid?.error?.message} on component ${config.displayName}:${config.title}`,
-            };
-        }
-
-        return {};
-    }
-
-    @hookAsync('Component.process')
-    async process(input, config, agent: Agent): Promise<any> {
-        if (agent.isKilled()) {
-            throw new Error('Agent killed');
-        }
-        const _input = await performTypeInference(input, config?.inputs, agent);
-
-        // modify the input object for component's process method
-        for (const [key, value] of Object.entries(_input)) {
-            input[key] = value;
-        }
-    }
-    async postProcess(output, config, agent: Agent): Promise<any> {
-        if (output?.result) {
-            delete output?.result?._debug;
-            if (!output?.result?._error) delete output?.result?._error;
-        }
-        return output;
-    }
-    async enable(config, agent: Agent): Promise<any> {}
-    async disable(config, agent: Agent): Promise<any> {}
-    readOutput(id, config, agent: Agent): any {
-        return null;
-    }
-    hasOutput(id, config, agent: Agent): any {
-        return false;
-    }
-}
+import Joi from 'joi';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Logger } from '@sre/helpers/Log.helper';
+import { performTypeInference } from '@sre/helpers/TypeChecker.helper';
+import { hookAsync } from '@sre/Core/HookService';
+
+export type ComponentSchema = {
+    name: string;
+    settings?: Record<string, any>;
+    inputs?: Record<string, any>;
+    outputs?: Record<string, any>;
+};
+
+export class Component {
+    public hasReadOutput = false;
+    public hasPostProcess = true;
+    public alwaysActive = false; //for components like readable memories
+    public exclusive = false; //for components like writable memories : when exclusive components are active, they are processed in a run cycle bofore other components
+    protected schema: ComponentSchema = {
+        name: 'Component',
+        settings: {},
+        inputs: {},
+        //outputs: {},
+    };
+    protected configSchema;
+    constructor() {}
+    init() {}
+
+    createComponentLogger(agent: Agent, configuration: any) {
+        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) {
+                agent.sse.send('component', {
+                    eventId: configuration.eventId,
+                    action: 'log',
+                    name: configuration.name || this.constructor.name,
+                    title: configuration.title,
+                    logs: [{ level: info.level, message: info.message }],
+                });
+            }
+        });
+        return logger;
+    }
+
+    /**
+     * Filters config data to only include properties that are defined in the schema
+     */
+    private filterConfigBySchema(data: any, schema: any): any {
+        if (!schema || !data) return data;
+
+        const schemaDescription = schema.describe();
+
+        // If it's not an object schema, return data as-is
+        if (schemaDescription.type !== 'object' || !schemaDescription.keys) {
+            return data;
+        }
+
+        const allowedKeys = Object.keys(schemaDescription.keys);
+        const filteredData: any = {};
+
+        // Only include properties that are defined in the schema
+        for (const key of allowedKeys) {
+            if (key in data) {
+                filteredData[key] = data[key];
+            }
+        }
+
+        // Preserve _templateVars if it exists (special case)
+        if (data._templateVars) {
+            filteredData._templateVars = data._templateVars;
+        }
+
+        return filteredData;
+    }
+
+    async validateConfig(config) {
+        if (!this.configSchema) return {};
+
+        let workingSchema = this.configSchema;
+
+        if (config.data._templateVars) {
+            //Accept dynamically added template data
+            for (let tplVar in config.data._templateVars) {
+                workingSchema = workingSchema.append({ [tplVar]: Joi.any() });
+            }
+        }
+
+        // Filter config.data to only include properties defined in the schema
+        const filteredData = this.filterConfigBySchema(config.data, workingSchema);
+
+        const valid = await workingSchema.validate(filteredData);
+        if (valid.error) {
+            return {
+                id: config.id,
+                name: config.name,
+                _error: `Schema Validation error: ${valid?.error?.message} on component ${config.displayName}:${config.title}`,
+                _debug: `Schema Validation error: ${valid?.error?.message} on component ${config.displayName}:${config.title}`,
+            };
+        }
+
+        return {};
+    }
+
+    @hookAsync('Component.process')
+    async process(input, config, agent: Agent): Promise<any> {
+        if (agent.isKilled()) {
+            throw new Error('Agent killed');
+        }
+        const _input = await performTypeInference(input, config?.inputs, agent);
+
+        // modify the input object for component's process method
+        for (const [key, value] of Object.entries(_input)) {
+            input[key] = value;
+        }
+    }
+    async postProcess(output, config, agent: Agent): Promise<any> {
+        if (output?.result) {
+            delete output?.result?._debug;
+            if (!output?.result?._error) delete output?.result?._error;
+        }
+        return output;
+    }
+    async enable(config, agent: Agent): Promise<any> {}
+    async disable(config, agent: Agent): Promise<any> {}
+    readOutput(id, config, agent: Agent): any {
+        return null;
+    }
+    hasOutput(id, config, agent: Agent): any {
+        return false;
+    }
+}

package/src/Components/ComponentHost.class.ts

@@ -1,38 +1,38 @@
-import { Component } from './Component.class';
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { ConnectorService } from '@sre/Core/ConnectorsService';
-import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-
-/**
- * This component allows running components that are not natively shiped with SRE
- * it can be used to extend SRE components by registering custom component using ComponentService
- */
-export class ComponentHost extends Component {
-    protected configSchema = null;
-    constructor() {
-        super();
-    }
-    init() {}
-
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-        //let debugLog = agent.agentRuntime?.debug ? [] : undefined;
-        const logger = this.createComponentLogger(agent, config);
-
-        try {
-            const componentName = config.data._component;
-            const componentConnector = ConnectorService.getComponentConnector();
-
-            const component = await componentConnector.requester(AccessCandidate.agent(agent.id)).get(componentName);
-
-            if (!component) {
-                logger.debug(`Component ${componentName} not found`);
-                return { _error: `Component ${componentName} not found`, _debug: logger.output };
-            }
-
-            return await component.process(input, config, agent);
-        } catch (error) {
-            return { _error: error.message, _debug: logger.output };
-        }
-    }
-}
+import { Component } from './Component.class';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+
+/**
+ * This component allows running components that are not natively shiped with SRE
+ * it can be used to extend SRE components by registering custom component using ComponentService
+ */
+export class ComponentHost extends Component {
+    protected configSchema = null;
+    constructor() {
+        super();
+    }
+    init() {}
+
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+        //let debugLog = agent.agentRuntime?.debug ? [] : undefined;
+        const logger = this.createComponentLogger(agent, config);
+
+        try {
+            const componentName = config.data._component;
+            const componentConnector = ConnectorService.getComponentConnector();
+
+            const component = await componentConnector.requester(AccessCandidate.agent(agent.id)).get(componentName);
+
+            if (!component) {
+                logger.debug(`Component ${componentName} not found`);
+                return { _error: `Component ${componentName} not found`, _debug: logger.output };
+            }
+
+            return await component.process(input, config, agent);
+        } catch (error) {
+            return { _error: error.message, _debug: logger.output };
+        }
+    }
+}

package/src/Components/DataSourceCleaner.class.ts

@@ -1,92 +1,92 @@
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { Component } from './Component.class';
-import { TemplateString } from '@sre/helpers/TemplateString.helper';
-import Joi from 'joi';
-import { validateCharacterSet } from '../utils';
-import { ConnectorService } from '@sre/Core/ConnectorsService';
-import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-
-import { DataSourceIndexer } from './DataSourceIndexer.class';
-
-export class DataSourceCleaner extends Component {
-    protected configSchema = Joi.object({
-        namespaceId: Joi.string().max(50).allow('').label('namespace'),
-        id: Joi.string().custom(validateCharacterSet, 'custom validation characterSet').allow('').label('source identifier'),
-    });
-    constructor() {
-        super();
-    }
-    init() {}
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-        const teamId = agent.teamId;
-        const agentId = agent.id;
-        let debugOutput = agent.agentRuntime?.debug ? '== Source Indexer Log ==\n' : null;
-
-        try {
-            const configSchema = this.validateConfigData(config.data);
-            if (configSchema.error) {
-                throw new Error(`Config data validation error: ${configSchema.error}\n EXITING...`);
-            }
-
-            const outputs = {};
-            for (let con of config.outputs) {
-                if (con.default) continue;
-                outputs[con.name] = con?.description ? `<${con?.description}>` : '';
-            }
-
-            const inputSchema = this.validateInput(input);
-            if (inputSchema.error) {
-                throw new Error(`Input validation error: ${inputSchema.error}\n EXITING...`);
-            }
-
-            const namespaceId = configSchema.value.namespaceId.split('_')?.slice(1).join('_') || configSchema.value.namespaceId;
-
-            let vectorDbConnector = ConnectorService.getVectorDBConnector();
-
-            let existingnamespace = await vectorDbConnector.requester(AccessCandidate.team(teamId)).namespaceExists(namespaceId);
-            if (!existingnamespace) {
-                throw new Error(`Namespace ${namespaceId} does not exist`);
-            }
-
-            const providedId = TemplateString(config.data.id).parse(input).result;
-            const idRegex = /^[a-zA-Z0-9\-\_\.]+$/;
-            if (!idRegex.test(providedId)) {
-                throw new Error(`Invalid id. Accepted characters: 'a-z', 'A-Z', '0-9', '-', '_', '.'`);
-            }
-            debugOutput += `Searching for data source with id: ${providedId}\n`;
-
-            const dsId = DataSourceIndexer.genDsId(providedId, teamId, namespaceId);
-
-            await vectorDbConnector.requester(AccessCandidate.team(teamId)).deleteDatasource(namespaceId, dsId);
-
-            debugOutput += `Deleted data source with id: ${providedId}\n`;
-
-            return {
-                _debug: debugOutput,
-                Success: true,
-                // _error,
-            };
-        } catch (err: any) {
-            debugOutput += `Failed to delete data source: \n Error: ${err?.message}\n`;
-
-            return {
-                _debug: debugOutput,
-                _error: err?.message || "Couldn't delete data source",
-            };
-        }
-    }
-
-    validateInput(input: any) {
-        return Joi.object({}).unknown(true).validate(input);
-    }
-
-    validateConfigData(data: any) {
-        return Joi.object({
-            namespaceId: Joi.string().required(),
-            id: Joi.string().optional().allow('').allow(null),
-        })
-            .unknown(true)
-            .validate(data);
-    }
-}
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+import Joi from 'joi';
+import { validateCharacterSet } from '../utils';
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+
+import { DataSourceIndexer } from './DataSourceIndexer.class';
+
+export class DataSourceCleaner extends Component {
+    protected configSchema = Joi.object({
+        namespaceId: Joi.string().max(50).allow('').label('namespace'),
+        id: Joi.string().custom(validateCharacterSet, 'custom validation characterSet').allow('').label('source identifier'),
+    });
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+        const teamId = agent.teamId;
+        const agentId = agent.id;
+        let debugOutput = agent.agentRuntime?.debug ? '== Source Indexer Log ==\n' : null;
+
+        try {
+            const configSchema = this.validateConfigData(config.data);
+            if (configSchema.error) {
+                throw new Error(`Config data validation error: ${configSchema.error}\n EXITING...`);
+            }
+
+            const outputs = {};
+            for (let con of config.outputs) {
+                if (con.default) continue;
+                outputs[con.name] = con?.description ? `<${con?.description}>` : '';
+            }
+
+            const inputSchema = this.validateInput(input);
+            if (inputSchema.error) {
+                throw new Error(`Input validation error: ${inputSchema.error}\n EXITING...`);
+            }
+
+            const namespaceId = configSchema.value.namespaceId.split('_')?.slice(1).join('_') || configSchema.value.namespaceId;
+
+            let vectorDbConnector = ConnectorService.getVectorDBConnector();
+
+            let existingnamespace = await vectorDbConnector.requester(AccessCandidate.team(teamId)).namespaceExists(namespaceId);
+            if (!existingnamespace) {
+                throw new Error(`Namespace ${namespaceId} does not exist`);
+            }
+
+            const providedId = TemplateString(config.data.id).parse(input).result;
+            const idRegex = /^[a-zA-Z0-9\-\_\.]+$/;
+            if (!idRegex.test(providedId)) {
+                throw new Error(`Invalid id. Accepted characters: 'a-z', 'A-Z', '0-9', '-', '_', '.'`);
+            }
+            debugOutput += `Searching for data source with id: ${providedId}\n`;
+
+            const dsId = DataSourceIndexer.genDsId(providedId, teamId, namespaceId);
+
+            await vectorDbConnector.requester(AccessCandidate.team(teamId)).deleteDatasource(namespaceId, dsId);
+
+            debugOutput += `Deleted data source with id: ${providedId}\n`;
+
+            return {
+                _debug: debugOutput,
+                Success: true,
+                // _error,
+            };
+        } catch (err: any) {
+            debugOutput += `Failed to delete data source: \n Error: ${err?.message}\n`;
+
+            return {
+                _debug: debugOutput,
+                _error: err?.message || "Couldn't delete data source",
+            };
+        }
+    }
+
+    validateInput(input: any) {
+        return Joi.object({}).unknown(true).validate(input);
+    }
+
+    validateConfigData(data: any) {
+        return Joi.object({
+            namespaceId: Joi.string().required(),
+            id: Joi.string().optional().allow('').allow(null),
+        })
+            .unknown(true)
+            .validate(data);
+    }
+}