@smythos/sre 1.7.9 → 1.7.15

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