@smythos/sre 1.6.8 → 1.6.10

package/src/subsystems/AgentManager/ForkedAgent.class.ts

@@ -1,154 +1,154 @@
-import { IAgent } from '@sre/types/Agent.types';
-import { Agent } from './Agent.class';
-import { AgentRequest } from './AgentRequest.class';
-
-import { Logger } from '@sre/helpers/Log.helper';
-import { uid } from '@sre/utils';
-const console = Logger('ForkedAgent');
-
-/**
- * This class creates a forked agent from a parent agent branch, it allows running a sub-branch of the parent agent asynchrounously by providing a separate agent context
- * We use composition instead of inheritance to avoid circular dependencies between Agent and ForkedAgent
- */
-export class ForkedAgent {
-    public agent: IAgent;
-    public get agentRequest() {
-        return this.agent.agentRequest;
-    }
-    public get components() {
-        return this.agent.components;
-    }
-    public get agentRuntime() {
-        return this.agent.agentRuntime;
-    }
-    public get jobID() {
-        return this.agent.jobID;
-    }
-    constructor(
-        private parent: IAgent,
-        componentId: string, //the component to fork from
-    ) {
-        const data: any = fork(this.parent.data, componentId);
-        data.variables = JSON.parse(JSON.stringify(this.parent?.data?.variables || {})); //copy parent Agent variables to forked agent
-        data.teamId = this.parent.teamId;
-        data.planInfo = this.parent.data?.planInfo || {};
-        //TODO : we need to create a default APIEndpoint bound to the root component if root component is not an APIEndpoint
-        const content = { name: this.parent.name, data, teamId: this.parent.teamId, debugSessionEnabled: false, version: this.parent.version };
-
-        const agentRequest = new AgentRequest(this.parent.agentRequest.req);
-        agentRequest.headers = []; //clear all headers from parent agent to conflict with child agent
-
-        this.agent = new Agent(this.parent.id, content, this.parent.agentSettings, agentRequest);
-        const JobID = componentId + '-' + uid();
-        this.agent.jobID = JobID;
-        //since the jobID was updated we need to create a different runtime
-        //FIXME : we need to find a way to avoid creating default runtime for forked agents, then replace it
-        //this.agent.agentRuntime = new AgentRuntime(this.agent);
-
-        //super(parent.id, content, agentRequest);
-    }
-
-    process(path: string, input: any) {
-        return this.agent.process(path, input);
-    }
-}
-
-// Helper function to clone a component and update its ID
-function cloneComponent(component) {
-    const newComponent = JSON.parse(JSON.stringify(component));
-    newComponent.id = component.id;
-    return newComponent;
-}
-
-// Helper function to recursively clone components and their connections
-function cloneRecursively(componentData, currentID, newIDMap, clonedComponents, clonedConnections) {
-    const componentToClone = componentData.components.find((c) => c.id === currentID);
-    if (!componentToClone) {
-        return;
-    }
-
-    const clonedComponent = cloneComponent(componentToClone);
-    newIDMap[currentID] = clonedComponent.id; // Map old ID to new ID
-    clonedComponents.push(clonedComponent);
-
-    // Find all outgoing connections for the current component
-    const outgoingConnections = componentData.connections.filter((conn) => conn.sourceId === currentID);
-    outgoingConnections.forEach((conn) => {
-        // Clone the connection and update the IDs
-        const clonedConnection = JSON.parse(JSON.stringify(conn));
-        clonedConnection.sourceId = clonedComponent.id;
-        if (!newIDMap[conn.targetId]) {
-            // Recursively clone the connected component if it hasn't been cloned yet
-            cloneRecursively(componentData, conn.targetId, newIDMap, clonedComponents, clonedConnections);
-        }
-        clonedConnection.targetId = newIDMap[conn.targetId];
-        clonedConnections.push(clonedConnection);
-    });
-}
-
-function fork(componentData, componentID) {
-    const clonedComponents: any[] = [];
-    const clonedConnections: any[] = [];
-    const newIDMap = {}; // Map to keep track of old to new ID mappings
-
-    // Start the cloning process from the specified component ID
-    cloneRecursively(componentData, componentID, newIDMap, clonedComponents, clonedConnections);
-
-    const rootComponentData = clonedComponents.find((e) => e.id == componentID);
-    if (rootComponentData) {
-        if (rootComponentData.name !== 'APIEndpoint') {
-            const APIEndpointData: any = {
-                id: `${componentID}_ENDPOINT`,
-                name: 'APIEndpoint',
-                outputs: [
-                    { name: 'headers', index: 0, default: true },
-                    { name: 'body', index: 1, default: true },
-                    { name: 'query', index: 2, default: true },
-                ],
-                inputs: [],
-                data: { endpoint: componentID, description: '', method: 'POST' },
-                displayName: 'APIEndpoint',
-                title: 'APIEndpoint',
-                description: '',
-            };
-
-            //APIEndpointData.inputs = JSON.parse(JSON.stringify(rootComponentData.inputs));
-            clonedComponents.push(APIEndpointData);
-
-            //find all previously connected forked inputs
-            const incomingConnections = componentData.connections.filter((conn) => conn.targetId === componentID);
-            // //deduplicate connections by targetId
-            // const uniqueIncomingConnections = incomingConnections.filter(
-            //     (conn, index, self) => index === self.findIndex((t) => t.targetId === conn.targetId && t.sourceIndex === conn.sourceIndex && t.targetIndex === conn.targetIndex),
-            // );
-
-            let i = 3;
-            for (let con of incomingConnections) {
-                const input = rootComponentData.inputs.find((e) => e.index == con.targetIndex);
-                const epInput = JSON.parse(JSON.stringify(input));
-                APIEndpointData.inputs.push(epInput);
-
-                const epOutput = {
-                    name: input.name,
-                    expression: `body.${input.name}`,
-                    optional: false,
-                    index: i++,
-                    default: false,
-                };
-                APIEndpointData.outputs.push(epOutput);
-
-                clonedConnections.push({
-                    sourceId: APIEndpointData.id,
-                    targetId: rootComponentData.id,
-                    sourceIndex: epOutput.index,
-                    targetIndex: input.index,
-                });
-            }
-        }
-    }
-    // Return the cloned sub-workflow
-    return {
-        components: clonedComponents,
-        connections: clonedConnections,
-    };
-}
+import { IAgent } from '@sre/types/Agent.types';
+import { Agent } from './Agent.class';
+import { AgentRequest } from './AgentRequest.class';
+
+import { Logger } from '@sre/helpers/Log.helper';
+import { uid } from '@sre/utils';
+const console = Logger('ForkedAgent');
+
+/**
+ * This class creates a forked agent from a parent agent branch, it allows running a sub-branch of the parent agent asynchrounously by providing a separate agent context
+ * We use composition instead of inheritance to avoid circular dependencies between Agent and ForkedAgent
+ */
+export class ForkedAgent {
+    public agent: IAgent;
+    public get agentRequest() {
+        return this.agent.agentRequest;
+    }
+    public get components() {
+        return this.agent.components;
+    }
+    public get agentRuntime() {
+        return this.agent.agentRuntime;
+    }
+    public get jobID() {
+        return this.agent.jobID;
+    }
+    constructor(
+        private parent: IAgent,
+        componentId: string, //the component to fork from
+    ) {
+        const data: any = fork(this.parent.data, componentId);
+        data.variables = JSON.parse(JSON.stringify(this.parent?.data?.variables || {})); //copy parent Agent variables to forked agent
+        data.teamId = this.parent.teamId;
+        data.planInfo = this.parent.data?.planInfo || {};
+        //TODO : we need to create a default APIEndpoint bound to the root component if root component is not an APIEndpoint
+        const content = { name: this.parent.name, data, teamId: this.parent.teamId, debugSessionEnabled: false, version: this.parent.version };
+
+        const agentRequest = new AgentRequest(this.parent.agentRequest.req);
+        agentRequest.headers = []; //clear all headers from parent agent to conflict with child agent
+
+        this.agent = new Agent(this.parent.id, content, this.parent.agentSettings, agentRequest);
+        const JobID = componentId + '-' + uid();
+        this.agent.jobID = JobID;
+        //since the jobID was updated we need to create a different runtime
+        //FIXME : we need to find a way to avoid creating default runtime for forked agents, then replace it
+        //this.agent.agentRuntime = new AgentRuntime(this.agent);
+
+        //super(parent.id, content, agentRequest);
+    }
+
+    process(path: string, input: any) {
+        return this.agent.process(path, input);
+    }
+}
+
+// Helper function to clone a component and update its ID
+function cloneComponent(component) {
+    const newComponent = JSON.parse(JSON.stringify(component));
+    newComponent.id = component.id;
+    return newComponent;
+}
+
+// Helper function to recursively clone components and their connections
+function cloneRecursively(componentData, currentID, newIDMap, clonedComponents, clonedConnections) {
+    const componentToClone = componentData.components.find((c) => c.id === currentID);
+    if (!componentToClone) {
+        return;
+    }
+
+    const clonedComponent = cloneComponent(componentToClone);
+    newIDMap[currentID] = clonedComponent.id; // Map old ID to new ID
+    clonedComponents.push(clonedComponent);
+
+    // Find all outgoing connections for the current component
+    const outgoingConnections = componentData.connections.filter((conn) => conn.sourceId === currentID);
+    outgoingConnections.forEach((conn) => {
+        // Clone the connection and update the IDs
+        const clonedConnection = JSON.parse(JSON.stringify(conn));
+        clonedConnection.sourceId = clonedComponent.id;
+        if (!newIDMap[conn.targetId]) {
+            // Recursively clone the connected component if it hasn't been cloned yet
+            cloneRecursively(componentData, conn.targetId, newIDMap, clonedComponents, clonedConnections);
+        }
+        clonedConnection.targetId = newIDMap[conn.targetId];
+        clonedConnections.push(clonedConnection);
+    });
+}
+
+function fork(componentData, componentID) {
+    const clonedComponents: any[] = [];
+    const clonedConnections: any[] = [];
+    const newIDMap = {}; // Map to keep track of old to new ID mappings
+
+    // Start the cloning process from the specified component ID
+    cloneRecursively(componentData, componentID, newIDMap, clonedComponents, clonedConnections);
+
+    const rootComponentData = clonedComponents.find((e) => e.id == componentID);
+    if (rootComponentData) {
+        if (rootComponentData.name !== 'APIEndpoint') {
+            const APIEndpointData: any = {
+                id: `${componentID}_ENDPOINT`,
+                name: 'APIEndpoint',
+                outputs: [
+                    { name: 'headers', index: 0, default: true },
+                    { name: 'body', index: 1, default: true },
+                    { name: 'query', index: 2, default: true },
+                ],
+                inputs: [],
+                data: { endpoint: componentID, description: '', method: 'POST' },
+                displayName: 'APIEndpoint',
+                title: 'APIEndpoint',
+                description: '',
+            };
+
+            //APIEndpointData.inputs = JSON.parse(JSON.stringify(rootComponentData.inputs));
+            clonedComponents.push(APIEndpointData);
+
+            //find all previously connected forked inputs
+            const incomingConnections = componentData.connections.filter((conn) => conn.targetId === componentID);
+            // //deduplicate connections by targetId
+            // const uniqueIncomingConnections = incomingConnections.filter(
+            //     (conn, index, self) => index === self.findIndex((t) => t.targetId === conn.targetId && t.sourceIndex === conn.sourceIndex && t.targetIndex === conn.targetIndex),
+            // );
+
+            let i = 3;
+            for (let con of incomingConnections) {
+                const input = rootComponentData.inputs.find((e) => e.index == con.targetIndex);
+                const epInput = JSON.parse(JSON.stringify(input));
+                APIEndpointData.inputs.push(epInput);
+
+                const epOutput = {
+                    name: input.name,
+                    expression: `body.${input.name}`,
+                    optional: false,
+                    index: i++,
+                    default: false,
+                };
+                APIEndpointData.outputs.push(epOutput);
+
+                clonedConnections.push({
+                    sourceId: APIEndpointData.id,
+                    targetId: rootComponentData.id,
+                    sourceIndex: epOutput.index,
+                    targetIndex: input.index,
+                });
+            }
+        }
+    }
+    // Return the cloned sub-workflow
+    return {
+        components: clonedComponents,
+        connections: clonedConnections,
+    };
+}

package/src/subsystems/AgentManager/OSResourceMonitor.ts

@@ -1,77 +1,77 @@
-import os from 'os';
-import process from 'process';
-
-const OSResourceMonitor: any = {
-    mem: getMemoryUsage(),
-    //processMemory: getProcessMemoryUsage(),
-    cpu: getCpuUsage(),
-    //processCpu: getProcessCpuUsage(),
-};
-export { OSResourceMonitor };
-
-function getCpuUsage() {
-    const cpus = os.cpus();
-    let user = 0;
-    let nice = 0;
-    let sys = 0;
-    let idle = 0;
-    let irq = 0;
-    let total = 0;
-
-    for (let cpu of cpus) {
-        user += cpu.times.user;
-        nice += cpu.times.nice;
-        sys += cpu.times.sys;
-        idle += cpu.times.idle;
-        irq += cpu.times.irq;
-    }
-
-    total = user + nice + sys + idle + irq;
-
-    return {
-        user: (user / total) * 100,
-        sys: (sys / total) * 100,
-        idle: (idle / total) * 100,
-        load: 100 - (idle / total) * 100,
-    };
-}
-
-function getMemoryUsage() {
-    const totalMemory = os.totalmem();
-    const freeMemory = os.freemem();
-    const usedMemory = totalMemory - freeMemory;
-
-    return {
-        totalMemory: (totalMemory / 1024 ** 3).toFixed(2) + ' GB',
-        freeMemory: (freeMemory / 1024 ** 3).toFixed(2) + ' GB',
-        usedMemory: (usedMemory / 1024 ** 3).toFixed(2) + ' GB',
-        memoryUsagePercentage: ((usedMemory / totalMemory) * 100).toFixed(2),
-    };
-}
-
-function getProcessMemoryUsage() {
-    const memoryUsage = process.memoryUsage();
-    return {
-        total: memoryUsage.rss,
-        heapTotal: (memoryUsage.heapTotal / 1024 ** 2).toFixed(2) + ' MB',
-        heapUsed: (memoryUsage.heapUsed / 1024 ** 2).toFixed(2) + ' MB',
-        external: (memoryUsage.external / 1024 ** 2).toFixed(2) + ' MB',
-    };
-}
-
-function getProcessCpuUsage() {
-    const cpuUsage = process.cpuUsage();
-    return {
-        user: cpuUsage.user,
-        system: cpuUsage.system,
-    };
-}
-
-function logSystemUsage() {
-    OSResourceMonitor.mem = getMemoryUsage();
-    OSResourceMonitor.cpu = getCpuUsage();
-    //OSResourceMonitor.processMemory = getProcessMemoryUsage();
-    //OSResourceMonitor.processCpu = getProcessCpuUsage();
-}
-
-//setInterval(logSystemUsage, 5000); // update every 5 seconds
+import os from 'os';
+import process from 'process';
+
+const OSResourceMonitor: any = {
+    mem: getMemoryUsage(),
+    //processMemory: getProcessMemoryUsage(),
+    cpu: getCpuUsage(),
+    //processCpu: getProcessCpuUsage(),
+};
+export { OSResourceMonitor };
+
+function getCpuUsage() {
+    const cpus = os.cpus();
+    let user = 0;
+    let nice = 0;
+    let sys = 0;
+    let idle = 0;
+    let irq = 0;
+    let total = 0;
+
+    for (let cpu of cpus) {
+        user += cpu.times.user;
+        nice += cpu.times.nice;
+        sys += cpu.times.sys;
+        idle += cpu.times.idle;
+        irq += cpu.times.irq;
+    }
+
+    total = user + nice + sys + idle + irq;
+
+    return {
+        user: (user / total) * 100,
+        sys: (sys / total) * 100,
+        idle: (idle / total) * 100,
+        load: 100 - (idle / total) * 100,
+    };
+}
+
+function getMemoryUsage() {
+    const totalMemory = os.totalmem();
+    const freeMemory = os.freemem();
+    const usedMemory = totalMemory - freeMemory;
+
+    return {
+        totalMemory: (totalMemory / 1024 ** 3).toFixed(2) + ' GB',
+        freeMemory: (freeMemory / 1024 ** 3).toFixed(2) + ' GB',
+        usedMemory: (usedMemory / 1024 ** 3).toFixed(2) + ' GB',
+        memoryUsagePercentage: ((usedMemory / totalMemory) * 100).toFixed(2),
+    };
+}
+
+function getProcessMemoryUsage() {
+    const memoryUsage = process.memoryUsage();
+    return {
+        total: memoryUsage.rss,
+        heapTotal: (memoryUsage.heapTotal / 1024 ** 2).toFixed(2) + ' MB',
+        heapUsed: (memoryUsage.heapUsed / 1024 ** 2).toFixed(2) + ' MB',
+        external: (memoryUsage.external / 1024 ** 2).toFixed(2) + ' MB',
+    };
+}
+
+function getProcessCpuUsage() {
+    const cpuUsage = process.cpuUsage();
+    return {
+        user: cpuUsage.user,
+        system: cpuUsage.system,
+    };
+}
+
+function logSystemUsage() {
+    OSResourceMonitor.mem = getMemoryUsage();
+    OSResourceMonitor.cpu = getCpuUsage();
+    //OSResourceMonitor.processMemory = getProcessMemoryUsage();
+    //OSResourceMonitor.processCpu = getProcessCpuUsage();
+}
+
+//setInterval(logSystemUsage, 5000); // update every 5 seconds