@smythos/sre 1.7.11 → 1.7.16

package/src/Core/HookService.ts

@@ -114,25 +114,119 @@ export function hook(hookName: string) {
     };
 }
 
+// Store metadata about which methods should be auto-wrapped in child classes
+// Maps constructor -> Map<methodName, {hookName, customContext}>
+const hookableMethodsMetadata = new WeakMap<
+    any,
+    Map<string, { hookName: string; customContext?: Record<string, any> | ((instance: any) => Record<string, any>) }>
+>();
+
+/**
+ * Class decorator that automatically applies hookAsync to ALL child class methods
+ * that override parent methods decorated with hookAsync
+ *
+ * Usage:
+ * @hookableClass
+ * export class Component {
+ *     @hookAsync('Component.process')
+ *     async process(...) { ... }
+ *
+ *     @hookAsync('Component.postProcess')
+ *     async postProcess(...) { ... }
+ * }
+ */
+export function hookableClass<T extends { new (...args: any[]): {} }>(constructor: T) {
+    return class extends constructor {
+        constructor(...args: any[]) {
+            super(...args);
+
+            // Get metadata for this class
+            const metadataMap = hookableMethodsMetadata.get(constructor);
+            if (!metadataMap) return; // No hooks to apply
+
+            const instance = this as any;
+            const childPrototype = Object.getPrototypeOf(instance);
+            const parentPrototype = constructor.prototype;
+
+            // Only process if this is a child class instance
+            if (childPrototype !== parentPrototype) {
+                // Apply hooks to all methods that have metadata
+                metadataMap.forEach((metadata, methodName) => {
+                    // Get the method from the child prototype
+                    const childMethod = childPrototype[methodName];
+                    const parentMethod = parentPrototype[methodName];
+
+                    // Check if child has overridden the method
+                    if (childMethod && typeof childMethod === 'function' && childMethod !== parentMethod) {
+                        // Get or create descriptor for the child method
+                        let descriptor = Object.getOwnPropertyDescriptor(childPrototype, methodName);
+
+                        // If not own property, create descriptor from the method
+                        if (!descriptor) {
+                            descriptor = {
+                                value: childMethod,
+                                writable: true,
+                                enumerable: false,
+                                configurable: true,
+                            };
+                        }
+
+                        // Apply hookAsync decorator to child method
+                        const modifiedDescriptor = hookAsync(metadata.hookName, metadata.customContext)(childPrototype, methodName, descriptor);
+
+                        // Update the prototype with the modified descriptor
+                        if (modifiedDescriptor && modifiedDescriptor.value) {
+                            Object.defineProperty(childPrototype, methodName, {
+                                value: modifiedDescriptor.value,
+                                writable: true,
+                                enumerable: false,
+                                configurable: true,
+                            });
+                        }
+                    }
+                });
+            }
+        }
+    } as T;
+}
+
 /**
  * Decorator function that executes registered hooks asynchronously before and after the decorated method
+ * Automatically stores metadata for hookableClass decorator to enable automatic child class wrapping
  * @param hookName The name of the hook to trigger
  */
 export function hookAsync(hookName: string, customContext?: Record<string, any> | ((instance: any) => Record<string, any>)) {
     return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
         const originalMethod = descriptor.value;
 
+        // Store metadata for this hookable method (for hookableClass decorator)
+        if (!hookableMethodsMetadata.has(target.constructor)) {
+            hookableMethodsMetadata.set(target.constructor, new Map());
+        }
+        const metadataMap = hookableMethodsMetadata.get(target.constructor)!;
+        metadataMap.set(propertyKey, { hookName, customContext });
+
         descriptor.value = async function (...args: any[]) {
+            // Check if we're being called via super from a child class that has its own wrapper
+            // If this[propertyKey] is different from our wrapped method, a child has overridden it
+            const instanceMethod = (this as any)[propertyKey];
+            const isSuperCall = instanceMethod !== descriptor.value && instanceMethod !== originalMethod;
+
+            // If called via super from a wrapped child, skip hooks and call original method directly
+            // The child wrapper already handles hooks, so we just need parent logic
+            if (isSuperCall) {
+                return await originalMethod.apply(this, args);
+            }
+
             // Get additional context if contextFn is provided
             let _context;
             if (typeof customContext === 'function') {
-                _context = await customContext(this);
+                _context = { instance: this, args: args, context: await customContext(this) };
             } else if (typeof customContext === 'object') {
-                _context = customContext;
+                _context = { instance: this, args: args, context: customContext };
             } else {
-                _context = this;
+                _context = { instance: this, args: args, context: {} };
             }
-
             // Execute non-blocking pre-hooks first (fire and forget)
             if (nonBlockingHooks[hookName]) {
                 void Promise.allSettled(nonBlockingHooks[hookName].map((callback) => Promise.resolve(callback.apply(_context, args)))).catch((err) =>
@@ -186,7 +280,6 @@ export function hookAsync(hookName: string, customContext?: Record<string, any>
         return descriptor;
     };
 }
-
 /**
  * Decorator function that executes registered hooks asynchronously before the decorated method
  * @param hookName The name of the hook to trigger
@@ -200,11 +293,12 @@ export function hookAsyncWithContext(hookName: string, contextFn?: (instance: an
             // Get additional context if contextFn is provided
             const additionalContext = typeof contextFn === 'function' ? await contextFn(this) : {};
             const contextualArgs = [additionalContext, ...args];
+            const _context = { instance: this, args: args, context: additionalContext };
 
             // Execute non-blocking pre-hooks first (fire and forget)
             if (nonBlockingHooks[hookName]) {
                 void Promise.allSettled(
-                    nonBlockingHooks[hookName].map((callback) => Promise.resolve().then(() => callback.apply(this, contextualArgs)))
+                    nonBlockingHooks[hookName].map((callback) => Promise.resolve().then(() => callback.apply(_context, contextualArgs)))
                 );
             }
 
@@ -214,7 +308,7 @@ export function hookAsyncWithContext(hookName: string, contextFn?: (instance: an
             try {
                 // Execute blocking pre-hooks and wait for them
                 if (blockingHooks[hookName]) {
-                    await Promise.all(blockingHooks[hookName].map((callback) => Promise.resolve(callback.apply(this, contextualArgs))));
+                    await Promise.all(blockingHooks[hookName].map((callback) => Promise.resolve(callback.apply(_context, contextualArgs))));
                 }
 
                 // Call the original method
@@ -228,16 +322,14 @@ export function hookAsyncWithContext(hookName: string, contextFn?: (instance: an
                 // Execute non-blocking after-hooks first (fire and forget)
                 if (nonBlockingAfterHooks[hookName]) {
                     void Promise.allSettled(
-                        nonBlockingAfterHooks[hookName].map((callback) =>
-                            Promise.resolve().then(() => callback({ result, args: contextualArgs, error }))
-                        )
-                    );
+                        nonBlockingAfterHooks[hookName].map((callback) => Promise.resolve(callback.apply(_context, [{ result, args, error }])))
+                    ).catch((err) => console.error(`Non-blocking after-hook ${hookName} error:`, err));
                 }
 
                 // Execute blocking after-hooks and wait for them
                 if (blockingAfterHooks[hookName]) {
                     await Promise.all(
-                        blockingAfterHooks[hookName].map((callback) => Promise.resolve(callback({ result, args: contextualArgs, error })))
+                        blockingAfterHooks[hookName].map((callback) => Promise.resolve(callback.apply(_context, [{ result, args, error }])))
                     );
                 }
             } catch (afterHookError) {

package/src/Core/boot.ts

@@ -12,11 +12,12 @@ import { CLIService } from '@sre/IO/CLI.service';
 import { NKVService } from '@sre/IO/NKV.service';
 import { RouterService } from '@sre/IO/Router.service';
 import { ManagedVaultService } from '@sre/Security/ManagedVault.service';
-import { LogService } from '@sre/IO/Log.service';
+import { LogService } from '@sre/ObservabilityManager/Log.service';
 import { ComponentService } from '@sre/AgentManager/Component.service';
 import { ModelsProviderService } from '@sre/LLMManager/ModelsProvider.service';
 import { CodeService } from '@sre/ComputeManager/Code.service';
 import { SchedulerService } from '@sre/AgentManager/Scheduler.service';
+import { TelemetryService } from '@sre/ObservabilityManager/Telemetry.service';
 const console = Logger('Boot');
 let _booted = false;
 export function boot() {
@@ -44,6 +45,7 @@ export function boot() {
     service.Component = new ComponentService();
     service.Code = new CodeService();
     service.Scheduler = new SchedulerService();
+    service.Telemetry = new TelemetryService();
 
     SystemEvents.on('SRE:Initialized', () => {
         console.debug('SRE Initialized');

package/src/helpers/Conversation.helper.ts

@@ -38,6 +38,9 @@ type ToolParams = {
 //TODO: handle authentication
 export class Conversation extends EventEmitter {
     private _agentId: string = '';
+    public get agentId() {
+        return this._agentId;
+    }
     private _systemPrompt;
     private userDefinedSystemPrompt: string = '';
     public toolChoice: string = 'auto';
@@ -68,6 +71,11 @@ export class Conversation extends EventEmitter {
     private _agentVersion: string = undefined;
     public agentData: any;
 
+    private _id: string = '';
+    public get id() {
+        return this._id;
+    }
+
     public get context() {
         return this._context;
     }
@@ -128,6 +136,7 @@ export class Conversation extends EventEmitter {
         //TODO: handle loading previous session (messages)
         super();
 
+        this._id = 'conv_' + randomUUID();
         //this event listener avoids unhandled errors that can cause crashes
         this.on('error', (error) => {
             this._lastError = error;
@@ -310,6 +319,16 @@ export class Conversation extends EventEmitter {
             maxTokens = this.model.params.maxTokens;
         }
 
+        const llmReqUid = randomUUID();
+        this.emit(TLLMEvent.Requested, {
+            model: typeof this.model === 'string' ? this.model : this.model?.modelId,
+            contextWindow,
+            files,
+            maxTokens,
+            agentId: this._agentId,
+            requestId: llmReqUid,
+        });
+
         const eventEmitter: any = await llmInference
             .promptStream({
                 contextWindow,
@@ -325,7 +344,7 @@ export class Conversation extends EventEmitter {
             })
             .catch((error) => {
                 console.error('Error on promptStream: ', error);
-                this.emit(TLLMEvent.Error, error);
+                this.emit(TLLMEvent.Error, error, { requestId: llmReqUid });
             });
 
         // remove listeners from llm event emitter to stop receiving stream data
@@ -338,20 +357,24 @@ export class Conversation extends EventEmitter {
             throw new Error('[LLM Request Error]');
         }
 
-        if (message) this.emit('start');
-        eventEmitter.on('data', (data) => {
-            if (this.stop) return;
-            this.emit('data', data);
-        });
+        if (message) this.emit('start', { requestId: llmReqUid });
+        // eventEmitter.on(TLLMEvent.Data, (data) => {
+        //     if (this.stop) return;
+        //     this.emit('data', data);
+        // });
 
         eventEmitter.on(TLLMEvent.Thinking, (thinking) => {
             if (this.stop) return;
-            this.emit(TLLMEvent.Thinking, thinking);
+            this.emit(TLLMEvent.Thinking, thinking, { requestId: llmReqUid });
         });
 
         eventEmitter.on(TLLMEvent.Data, (data) => {
             if (this.stop) return;
-            this.emit(TLLMEvent.Data, data);
+            this.emit(TLLMEvent.Data, data, {
+                contextWindow,
+                requestId: llmReqUid,
+                model: typeof this.model === 'string' ? this.model : this.model?.modelId,
+            });
         });
 
         eventEmitter.on(TLLMEvent.Content, (content) => {
@@ -368,7 +391,7 @@ export class Conversation extends EventEmitter {
             //     let s = true;
             // }
             _content += content;
-            this.emit(TLLMEvent.Content, content);
+            this.emit(TLLMEvent.Content, content, { requestId: llmReqUid });
         });
 
         let finishReason = 'stop';
@@ -408,6 +431,9 @@ export class Conversation extends EventEmitter {
                 toolsData.forEach((tool) => {
                     tool.status = tool.name ? this._toolStatusMap?.[tool.name] : undefined;
                 });
+                toolsData.content = _content;
+                toolsData.requestId = llmReqUid;
+                toolsData.contextWindow = contextWindow;
 
                 llmMessage.tool_calls = toolsData.map((tool) => {
                     return {
@@ -473,7 +499,7 @@ export class Conversation extends EventEmitter {
                         this.emit('beforeToolCall', { tool, args }, llmMessage); //deprecated
 
                         const status = tool.name ? this._toolStatusMap?.[tool.name] : undefined;
-                        this.emit(TLLMEvent.ToolCall, { tool, status, _llmRequest: llmMessage });
+                        this.emit(TLLMEvent.ToolCall, { tool, status, _llmRequest: llmMessage, requestId: llmReqUid });
 
                         const toolArgs = {
                             type: tool?.type,
@@ -500,7 +526,7 @@ export class Conversation extends EventEmitter {
 
                         //await afterFunctionCall(functionResponse, toolsData[tool.index]);
                         this.emit('afterToolCall', { tool, args }, functionResponse); // Deprecated
-                        this.emit(TLLMEvent.ToolResult, { tool, result });
+                        this.emit(TLLMEvent.ToolResult, { tool, result, requestId: llmReqUid });
 
                         return { ...tool, result: functionResponse };
                     }
@@ -542,7 +568,7 @@ export class Conversation extends EventEmitter {
                 if (_finishReason) finishReason = _finishReason;
                 if (usage_data) {
                     //FIXME : normalize the usage data format
-                    this.emit(TLLMEvent.Usage, usage_data);
+                    this.emit(TLLMEvent.Usage, usage_data, { requestId: llmReqUid });
                 }
                 if (hasError) return;
 
@@ -563,7 +589,7 @@ export class Conversation extends EventEmitter {
         const toolsContent = await toolsPromise.catch((error) => {
             console.error('Error in toolsPromise: ', error);
             //this.emit('error', error);
-            this.emit(TLLMEvent.Error, error);
+            this.emit(TLLMEvent.Error, error, { requestId: llmReqUid });
             return '';
         });
         _content += toolsContent;
@@ -588,9 +614,9 @@ export class Conversation extends EventEmitter {
             //this._context.push({ role: 'assistant', content: content });
 
             if (finishReason !== 'stop') {
-                this.emit(TLLMEvent.Interrupted, finishReason);
+                this.emit(TLLMEvent.Interrupted, finishReason, { requestId: llmReqUid });
             }
-            this.emit(TLLMEvent.End);
+            this.emit(TLLMEvent.End, { requestId: llmReqUid });
         } else {
             //console.log('tool content', content);
         }
@@ -671,6 +697,7 @@ export class Conversation extends EventEmitter {
 
                 reqConfig.headers['X-CACHE-ID'] = this._context?.llmCache?.id;
 
+                reqConfig.headers['X-REQUEST-TAG'] = this.id;
                 /*
                  * Objective for the following conditions:
                  * - In case it is not a debug call and there is no monitor id, then we need to run the agent locally to reduce latency

package/src/index.ts

@@ -130,8 +130,6 @@ export * from './subsystems/ComputeManager/Code.service/CodeConnector';
 export * from './subsystems/ComputeManager/Code.service/index';
 export * from './subsystems/IO/CLI.service/CLIConnector';
 export * from './subsystems/IO/CLI.service/index';
-export * from './subsystems/IO/Log.service/index';
-export * from './subsystems/IO/Log.service/LogConnector';
 export * from './subsystems/IO/NKV.service/index';
 export * from './subsystems/IO/NKV.service/NKVConnector';
 export * from './subsystems/IO/Router.service/index';
@@ -149,6 +147,10 @@ export * from './subsystems/LLMManager/ModelsProvider.service/ModelsProviderConn
 export * from './subsystems/MemoryManager/Cache.service/CacheConnector';
 export * from './subsystems/MemoryManager/Cache.service/index';
 export * from './subsystems/MemoryManager/LLMMemory.service/LLMMemoryConnector';
+export * from './subsystems/ObservabilityManager/Log.service/index';
+export * from './subsystems/ObservabilityManager/Log.service/LogConnector';
+export * from './subsystems/ObservabilityManager/Telemetry.service/index';
+export * from './subsystems/ObservabilityManager/Telemetry.service/TelemetryConnector';
 export * from './subsystems/Security/AccessControl/AccessCandidate.class';
 export * from './subsystems/Security/AccessControl/AccessRequest.class';
 export * from './subsystems/Security/AccessControl/ACL.class';
@@ -167,7 +169,6 @@ export * from './subsystems/AgentManager/AgentData.service/connectors/NullAgentD
 export * from './subsystems/AgentManager/Component.service/connectors/LocalComponentConnector.class';
 export * from './subsystems/AgentManager/Scheduler.service/connectors/LocalScheduler.class';
 export * from './subsystems/ComputeManager/Code.service/connectors/AWSLambdaCode.class';
-export * from './subsystems/IO/Log.service/connectors/ConsoleLog.class';
 export * from './subsystems/IO/NKV.service/connectors/NKVLocalStorage.class';
 export * from './subsystems/IO/NKV.service/connectors/NKVRAM.class';
 export * from './subsystems/IO/NKV.service/connectors/NKVRedis.class';
@@ -196,6 +197,7 @@ export * from './subsystems/MemoryManager/Cache.service/connectors/LocalStorageC
 export * from './subsystems/MemoryManager/Cache.service/connectors/RAMCache.class';
 export * from './subsystems/MemoryManager/Cache.service/connectors/RedisCache.class';
 export * from './subsystems/MemoryManager/Cache.service/connectors/S3Cache.class';
+export * from './subsystems/ObservabilityManager/Log.service/connectors/ConsoleLog.class';
 export * from './subsystems/Security/Account.service/connectors/DummyAccount.class';
 export * from './subsystems/Security/Account.service/connectors/JSONFileAccount.class';
 export * from './subsystems/Security/Account.service/connectors/MySQLAccount.class';
@@ -207,5 +209,7 @@ export * from './subsystems/Security/Vault.service/connectors/NullVault.class';
 export * from './subsystems/Security/Vault.service/connectors/SecretsManager.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/openai/OpenAIConnector.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/openai/types';
+export * from './subsystems/ObservabilityManager/Telemetry.service/connectors/OTel/OTel.class';
+export * from './subsystems/ObservabilityManager/Telemetry.service/connectors/OTel/OTelContextRegistry';
 export * from './subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/constants';
 export * from './subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/utils';

package/src/index.ts.bak

@@ -130,8 +130,6 @@ export * from './subsystems/ComputeManager/Code.service/CodeConnector';
 export * from './subsystems/ComputeManager/Code.service/index';
 export * from './subsystems/IO/CLI.service/CLIConnector';
 export * from './subsystems/IO/CLI.service/index';
-export * from './subsystems/IO/Log.service/index';
-export * from './subsystems/IO/Log.service/LogConnector';
 export * from './subsystems/IO/NKV.service/index';
 export * from './subsystems/IO/NKV.service/NKVConnector';
 export * from './subsystems/IO/Router.service/index';
@@ -149,6 +147,10 @@ export * from './subsystems/LLMManager/ModelsProvider.service/ModelsProviderConn
 export * from './subsystems/MemoryManager/Cache.service/CacheConnector';
 export * from './subsystems/MemoryManager/Cache.service/index';
 export * from './subsystems/MemoryManager/LLMMemory.service/LLMMemoryConnector';
+export * from './subsystems/ObservabilityManager/Log.service/index';
+export * from './subsystems/ObservabilityManager/Log.service/LogConnector';
+export * from './subsystems/ObservabilityManager/Telemetry.service/index';
+export * from './subsystems/ObservabilityManager/Telemetry.service/TelemetryConnector';
 export * from './subsystems/Security/AccessControl/AccessCandidate.class';
 export * from './subsystems/Security/AccessControl/AccessRequest.class';
 export * from './subsystems/Security/AccessControl/ACL.class';
@@ -167,7 +169,6 @@ export * from './subsystems/AgentManager/AgentData.service/connectors/NullAgentD
 export * from './subsystems/AgentManager/Component.service/connectors/LocalComponentConnector.class';
 export * from './subsystems/AgentManager/Scheduler.service/connectors/LocalScheduler.class';
 export * from './subsystems/ComputeManager/Code.service/connectors/AWSLambdaCode.class';
-export * from './subsystems/IO/Log.service/connectors/ConsoleLog.class';
 export * from './subsystems/IO/NKV.service/connectors/NKVLocalStorage.class';
 export * from './subsystems/IO/NKV.service/connectors/NKVRAM.class';
 export * from './subsystems/IO/NKV.service/connectors/NKVRedis.class';
@@ -196,6 +197,7 @@ export * from './subsystems/MemoryManager/Cache.service/connectors/LocalStorageC
 export * from './subsystems/MemoryManager/Cache.service/connectors/RAMCache.class';
 export * from './subsystems/MemoryManager/Cache.service/connectors/RedisCache.class';
 export * from './subsystems/MemoryManager/Cache.service/connectors/S3Cache.class';
+export * from './subsystems/ObservabilityManager/Log.service/connectors/ConsoleLog.class';
 export * from './subsystems/Security/Account.service/connectors/DummyAccount.class';
 export * from './subsystems/Security/Account.service/connectors/JSONFileAccount.class';
 export * from './subsystems/Security/Account.service/connectors/MySQLAccount.class';
@@ -207,5 +209,7 @@ export * from './subsystems/Security/Vault.service/connectors/NullVault.class';
 export * from './subsystems/Security/Vault.service/connectors/SecretsManager.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/openai/OpenAIConnector.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/openai/types';
+export * from './subsystems/ObservabilityManager/Telemetry.service/connectors/OTel/OTel.class';
+export * from './subsystems/ObservabilityManager/Telemetry.service/connectors/OTel/OTelContextRegistry';
 export * from './subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/constants';
 export * from './subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/utils';

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

@@ -16,7 +16,7 @@ import { Trigger } from '@sre/Components/Triggers/Trigger.class';
 import { IAgent } from '@sre/types/Agent.types';
 import { AgentSSE } from './AgentSSE.class';
 
-const console = Logger('Agent');
+const logger = Logger('Agent');
 const idPromise = (id) => id;
 const MAX_LATENCY = 50;
 
@@ -169,7 +169,7 @@ export class Agent implements IAgent {
                     this._componentInstancesLoader.resolve(true);
                 });
         } catch (error) {
-            console.warn('Could not load custom components', AccessCandidate.agent(this.id));
+            logger.warn('Could not load custom components', AccessCandidate.agent(this.id));
             this._componentInstancesLoader.reject('Could not load custom components');
         }
 
@@ -329,9 +329,10 @@ export class Agent implements IAgent {
             step = await this.agentRuntime.runCycle();
 
             //adjust latency based on cpu load
-            const qosLatency = Math.floor(OSResourceMonitor.cpu.load * MAX_LATENCY || 0);
+            const qosLatency = Math.floor((OSResourceMonitor.cpu.load / 100) * MAX_LATENCY || 0);
 
-            await delay(10 + qosLatency);
+            await delay(qosLatency);
+            await new Promise((resolve) => setImmediate(resolve)); // yield to the event loop to prevent blocking other operations
         } while (!step?.finalResult && !this._killReason);
 
         if (this._killReason) {
@@ -349,7 +350,7 @@ export class Agent implements IAgent {
                 input,
                 error: 'Agent killed',
             });
-            console.warn(`Agent ${this.id} was killed`, AccessCandidate.agent(this.id));
+            logger.warn(`Agent ${this.id} was killed`, AccessCandidate.agent(this.id));
             return { error: 'AGENT_KILLED', reason: this._killReason };
         }
         result = await this.postProcess(step?.finalResult).catch((error) => ({ error }));
@@ -590,7 +591,7 @@ export class Agent implements IAgent {
         });
 
         if (this._killReason) {
-            console.warn(`Agent ${this.id} was killed, skipping component ${componentData.name}`, AccessCandidate.agent(this.id));
+            logger.warn(`Agent ${this.id} was killed, skipping component ${componentData.name}`, AccessCandidate.agent(this.id));
 
             const output = { id: componentData.id, name: componentData.displayName, result: null, error: 'Agent killed' };
 
@@ -714,10 +715,10 @@ export class Agent implements IAgent {
                         await this.parseVariables(); //make sure that any vault variable is loaded before processing the component
                         //TODO: apply type inference here instead of in the component .process method
                         output = await component.process({ ...this.agentVariables, ..._input }, { ...componentData, eventId }, this);
-                        console.debug(output, AccessCandidate.agent(this.id));
+                        logger.debug(output, AccessCandidate.agent(this.id));
                     } catch (error: any) {
                         //this are fatal errors requiring to cancel the execution of this component.
-                        console.error(
+                        logger.error(
                             'Error on component process: ',
                             { componentId, name: componentData.name, input: _input },
                             error,

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

@@ -7,7 +7,7 @@ import { RuntimeContext } from '@sre/MemoryManager/RuntimeContext';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
 import { uid } from '@sre/utils';
 
-const console = Logger('AgentRuntime');
+const logger = Logger('AgentRuntime');
 const AgentRuntimeUnavailable = new Proxy(
     {},
     {
@@ -18,7 +18,7 @@ const AgentRuntimeUnavailable = new Proxy(
             } else {
                 // Return a function that logs "unavailable"
                 return function () {
-                    console.warn(`AgentRuntime Unavailable tried to call : ${prop.toString()}`);
+                    logger.warn(`AgentRuntime Unavailable tried to call : ${prop.toString()}`);
                 };
             }
         },
@@ -150,7 +150,7 @@ export class AgentRuntime {
             for (let component of this.agent.data.components) {
                 const cpt: Component = this.agent.ComponentInstances[component.name];
                 if (!cpt) {
-                    console.warn(`Component ${component.name} Exists in agent but has no implementation`, AccessCandidate.agent(this.agent.id));
+                    logger.warn(`Component ${component.name} Exists in agent but has no implementation`, AccessCandidate.agent(this.agent.id));
                     continue;
                 }
 
@@ -316,7 +316,7 @@ export class AgentRuntime {
      * @returns
      */
     public async runCycle() {
-        console.debug(
+        logger.debug(
             `runCycle agentId=${this.agent.id} wfReqId=${this.workflowReqId}  reqTag=${this.reqTag} session=${this.xDebugRun} cycleId=${this.processID}`,
             AccessCandidate.agent(this.agent.id)
         );

package/src/subsystems/AgentManager/OSResourceMonitor.ts

@@ -1,12 +1,34 @@
 import os from 'os';
 import process from 'process';
 
-const OSResourceMonitor: any = {
+// Store previous CPU times for delta calculation
+let previousCpuTimes: { user: number; nice: number; sys: number; idle: number; irq: number } | null = null;
+
+const monitorData: any = {
     mem: getMemoryUsage(),
-    //processMemory: getProcessMemoryUsage(),
     cpu: getCpuUsage(),
+    //processMemory: getProcessMemoryUsage(),
     //processCpu: getProcessCpuUsage(),
 };
+
+const itv = setInterval(() => {
+    monitorData.mem = getMemoryUsage();
+    monitorData.cpu = getCpuUsage();
+    //monitorData.processMemory = getProcessMemoryUsage();
+    //monitorData.processCpu = getProcessCpuUsage();
+}, 5000);
+
+itv.unref();
+
+const OSResourceMonitor: any = {
+    get mem() {
+        return monitorData.mem;
+    },
+    get cpu() {
+        return monitorData.cpu;
+    },
+};
+
 export { OSResourceMonitor };
 
 function getCpuUsage() {
@@ -16,8 +38,8 @@ function getCpuUsage() {
     let sys = 0;
     let idle = 0;
     let irq = 0;
-    let total = 0;
 
+    // Sum up times across all CPU cores
     for (let cpu of cpus) {
         user += cpu.times.user;
         nice += cpu.times.nice;
@@ -26,13 +48,52 @@ function getCpuUsage() {
         irq += cpu.times.irq;
     }
 
-    total = user + nice + sys + idle + irq;
+    const currentTimes = { user, nice, sys, idle, irq };
+
+    // If this is the first measurement, store it and return zero load
+    if (!previousCpuTimes) {
+        previousCpuTimes = currentTimes;
+        return {
+            user: 0,
+            sys: 0,
+            idle: 100,
+            load: 0,
+        };
+    }
+
+    // Calculate deltas since last measurement
+    const userDelta = currentTimes.user - previousCpuTimes.user;
+    const niceDelta = currentTimes.nice - previousCpuTimes.nice;
+    const sysDelta = currentTimes.sys - previousCpuTimes.sys;
+    const idleDelta = currentTimes.idle - previousCpuTimes.idle;
+    const irqDelta = currentTimes.irq - previousCpuTimes.irq;
+
+    const totalDelta = userDelta + niceDelta + sysDelta + idleDelta + irqDelta;
+
+    // Store current times for next calculation
+    previousCpuTimes = currentTimes;
+
+    // Avoid division by zero
+    if (totalDelta === 0) {
+        return {
+            user: 0,
+            sys: 0,
+            idle: 100,
+            load: 0,
+        };
+    }
+
+    // Calculate percentages based on delta (actual usage since last check)
+    const userPercent = (userDelta / totalDelta) * 100;
+    const sysPercent = (sysDelta / totalDelta) * 100;
+    const idlePercent = (idleDelta / totalDelta) * 100;
+    const loadPercent = 100 - idlePercent;
 
     return {
-        user: (user / total) * 100,
-        sys: (sys / total) * 100,
-        idle: (idle / total) * 100,
-        load: 100 - (idle / total) * 100,
+        user: Math.round(userPercent * 100) / 100, // Round to 2 decimals
+        sys: Math.round(sysPercent * 100) / 100,
+        idle: Math.round(idlePercent * 100) / 100,
+        load: Math.round(loadPercent * 100) / 100,
     };
 }
 

package/src/subsystems/LLMManager/LLM.service/connectors/Echo.class.ts

@@ -49,7 +49,7 @@ export class EchoConnector extends LLMConnector {
 
                 for (let i = 0; i < chunks.length; i++) {
                     // Simulate network delay
-                    await delay(10);
+                    await delay(3);
 
                     const isLastChunk = i === chunks.length - 1;
                     // Add space between chunks except for the last one to avoid trailing space in file URLs