@smythos/sre 1.7.11 → 1.7.15

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

package/src/subsystems/{IO → ObservabilityManager}/Log.service/LogConnector.ts

@@ -12,7 +12,10 @@ export interface ILogRequest {
 
 export abstract class LogConnector extends SecureConnector {
     public abstract id: string;
-    public abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+
+    constructor() {
+        super();
+    }
 
     public requester(candidate: AccessCandidate): ILogRequest {
         if (candidate.role !== 'agent') throw new Error('Only agents can use Log connector');
@@ -27,6 +30,8 @@ export abstract class LogConnector extends SecureConnector {
         };
     }
 
+    public abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
     protected abstract log(acRequest: AccessRequest, logData: AgentCallLog, callId?: string): Promise<any>;
     protected abstract logTask(acRequest: AccessRequest, tasks: number, isUsingTestDomain: boolean): Promise<void>;
+    protected abstract setupHooks(): Promise<void>;
 }

package/src/subsystems/{IO → ObservabilityManager}/Log.service/connectors/ConsoleLog.class.ts

@@ -5,7 +5,7 @@ import { IAccessCandidate } from '@sre/types/ACL.types';
 import { LogConnector } from '../LogConnector';
 import { AgentCallLog } from '@sre/types/AgentLogger.types';
 
-const console = Logger('SmythLog');
+const logger = Logger('SmythLog');
 
 export class ConsoleLog extends LogConnector {
     public name: string = 'ConsoleLog';
@@ -14,15 +14,18 @@ export class ConsoleLog extends LogConnector {
         return Promise.resolve(new ACL());
     }
     protected log(acRequest: AccessRequest, logData: AgentCallLog, callId?: string): Promise<any> {
-        console.debug(`Log for agent ${acRequest.candidate.id}: ${typeof logData === 'string' ? logData : JSON.stringify(logData)}`);
+        logger.debug(`Log for agent ${acRequest.candidate.id}: ${typeof logData === 'string' ? logData : JSON.stringify(logData)}`);
 
         return Promise.resolve();
     }
     protected logTask(acRequest: AccessRequest, tasks: number, isUsingTestDomain: boolean): Promise<void> {
-        console.debug(
+        logger.debug(
             `${tasks} Task(s) Consumed by agent ${acRequest.candidate.id}: ${isUsingTestDomain ? 'Using Test Domain' : 'Using Production Domain'}`
         );
 
         return Promise.resolve();
     }
+    protected setupHooks(): Promise<void> {
+        return Promise.resolve();
+    }
 }

package/src/subsystems/{IO → ObservabilityManager}/Log.service/index.ts

@@ -1,10 +1,9 @@
 import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
 import { TConnectorService } from '@sre/types/SRE.types';
-import { Logger } from '@sre/helpers/Log.helper';
 
 import { ConsoleLog } from './connectors/ConsoleLog.class';
 
-const console = Logger('LogService');
+//const console = Logger('LogService');
 
 export class LogService extends ConnectorServiceProvider {
     public register() {

package/src/subsystems/ObservabilityManager/Telemetry.service/TelemetryConnector.ts

@@ -0,0 +1,23 @@
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { AgentCallLog } from '@sre/types/AgentLogger.types';
+
+export interface ITelemetryRequest {}
+
+export abstract class TelemetryConnector extends SecureConnector {
+    public abstract id: string;
+
+    constructor() {
+        super();
+    }
+
+    public requester(candidate: AccessCandidate): ITelemetryRequest {
+        return {};
+    }
+
+    public abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    protected abstract setupHooks(): Promise<void>;
+}