@slashfi/agents-sdk 0.16.0 → 0.17.0

package/src/registry.ts

@@ -5,6 +5,12 @@
  */
 
 import { dirname, resolve } from "node:path";
+import type {
+  AgentEvent,
+  EventCallback,
+  EventType,
+} from "./events.js";
+import { createEventBus } from "./events.js";
 import type {
   AgentAction,
   AgentDefinition,
@@ -41,8 +47,15 @@ const DEFAULT_SUPPORTED_ACTIONS: AgentAction[] = [
  */
 export interface RegistryMiddleware {
   load?: (
-    defaultFn: (agent: AgentDefinition, request: CallAgentLoadRequest) => Promise<CallAgentLoadResponse>,
-    ctx: { agent: AgentDefinition; request: CallAgentLoadRequest; registry: AgentRegistry },
+    defaultFn: (
+      agent: AgentDefinition,
+      request: CallAgentLoadRequest,
+    ) => Promise<CallAgentLoadResponse>,
+    ctx: {
+      agent: AgentDefinition;
+      request: CallAgentLoadRequest;
+      registry: AgentRegistry;
+    },
   ) => Promise<CallAgentLoadResponse>;
 }
 
@@ -79,6 +92,12 @@ export interface AgentRegistry {
 
   /** Call an agent (execute action) */
   call(request: CallAgentRequest): Promise<CallAgentResponse>;
+
+  /** Register an event listener (global scope — fires for all agents) */
+  on<T extends EventType>(eventType: T, callback: EventCallback<T>): void;
+
+  /** Emit an event to all listeners. Used by the runtime to push lifecycle events. */
+  emit(event: AgentEvent): Promise<void>;
 }
 
 // ============================================
@@ -105,13 +124,16 @@ export interface AgentRegistry {
  * Factory function that enriches the base ToolContext with application-specific data.
  * Called before every tool execution.
  */
-export type ContextFactory = (baseCtx: import("./types.js").ToolContext) => import("./types.js").ToolContext;
+export type ContextFactory = (
+  baseCtx: import("./types.js").ToolContext,
+) => import("./types.js").ToolContext;
 
 export function createAgentRegistry(
   options: AgentRegistryOptions = {},
 ): AgentRegistry {
   const { defaultVisibility = "internal" } = options;
   const agents = new Map<string, AgentDefinition>();
+  const eventBus = createEventBus();
 
   /**
    * Check if agent supports the requested action.
@@ -268,7 +290,12 @@ export function createAgentRegistry(
         const refAgent = agents.get(refPath);
         const allTools = (refAgent?.tools ?? [])
           .filter((t: ToolDefinition) =>
-            checkToolAccess(refAgent!, t.name, request.callerId, request.callerType),
+            checkToolAccess(
+              refAgent!,
+              t.name,
+              request.callerId,
+              request.callerType,
+            ),
           )
           .map((t: ToolDefinition) => ({
             name: t.name,
@@ -289,7 +316,8 @@ export function createAgentRegistry(
       }
     }
 
-    const systemPrompt = agent.entrypoint + buildToolsSection(toolSchemas, agentRefs);
+    const systemPrompt =
+      agent.entrypoint + buildToolsSection(toolSchemas, agentRefs);
 
     return {
       success: true,
@@ -308,6 +336,28 @@ export function createAgentRegistry(
   const registry: AgentRegistry = {
     register(agent: AgentDefinition): void {
       agents.set(agent.path, agent);
+
+      // Collect agent-level listeners into the bus
+      if (agent._listeners) {
+        for (const entry of agent._listeners) {
+          eventBus._onScoped(entry.eventType, entry.callback, {
+            agentPath: agent.path,
+            toolName: entry.toolScope,
+          });
+        }
+      }
+
+      // Collect tool-level listeners into the bus
+      for (const tool of agent.tools) {
+        if (tool._listeners) {
+          for (const entry of tool._listeners) {
+            eventBus._onScoped(entry.eventType, entry.callback, {
+              agentPath: agent.path,
+              toolName: tool.name,
+            });
+          }
+        }
+      }
     },
 
     get(path: string): AgentDefinition | undefined {
@@ -326,6 +376,14 @@ export function createAgentRegistry(
       return Array.from(agents.keys());
     },
 
+    on<T extends EventType>(eventType: T, callback: EventCallback<T>): void {
+      eventBus.on(eventType, callback);
+    },
+
+    async emit(event: AgentEvent): Promise<void> {
+      await eventBus.emit(event);
+    },
+
     async call(request: CallAgentRequest): Promise<CallAgentResponse> {
       const agent = agents.get(request.path);
 
@@ -434,15 +492,59 @@ export function createAgentRegistry(
                 error: `Tool ${request.tool} has no execute function`,
               } as CallAgentErrorResponse;
             }
-            const result = await tool.execute(request.params, ctx);
+
+            // Emit tool/call before execution
+            const startMs = Date.now();
+            await eventBus.emit({
+              type: "tool/call",
+              agentPath: agent.path,
+              tool: request.tool!,
+              params: request.params,
+              timestamp: startMs,
+            });
+
+            let result: unknown;
+            try {
+              result = await tool.execute(request.params, ctx);
+            } catch (err) {
+              // Emit tool/error on failure
+              await eventBus.emit({
+                type: "tool/error",
+                agentPath: agent.path,
+                tool: request.tool!,
+                params: request.params,
+                error: err,
+                durationMs: Date.now() - startMs,
+                timestamp: Date.now(),
+              }).catch(() => {}); // don't let emit error mask tool error
+
+              return {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+                code: "TOOL_EXECUTION_ERROR",
+              } as CallAgentErrorResponse;
+            }
+
+            // Emit tool/result after success
+            await eventBus.emit({
+              type: "tool/result",
+              agentPath: agent.path,
+              tool: request.tool!,
+              params: request.params,
+              result,
+              durationMs: Date.now() - startMs,
+              timestamp: Date.now(),
+            });
+
             return {
               success: true,
               result,
             } as CallAgentExecuteToolResponse;
-          } catch (err) {
+          } catch (outerErr) {
+            // Catch-all for unexpected errors (e.g., emit failures)
             return {
               success: false,
-              error: err instanceof Error ? err.message : String(err),
+              error: outerErr instanceof Error ? outerErr.message : String(outerErr),
               code: "TOOL_EXECUTION_ERROR",
             } as CallAgentErrorResponse;
           }
@@ -476,7 +578,11 @@ export function createAgentRegistry(
 
         case "load": {
           if (options.middleware?.load) {
-            return options.middleware.load(defaultLoad, { agent, request, registry });
+            return options.middleware.load(defaultLoad, {
+              agent,
+              request,
+              registry,
+            });
           }
           return defaultLoad(agent, request);
         }

package/src/secret-collection.ts

@@ -44,7 +44,8 @@ export const pendingCollections = new Map<string, PendingCollection>();
 
 /** Generate a random one-time token for secret collection */
 export function generateCollectionToken(): string {
-  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const chars =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
   let token = "";
   for (let i = 0; i < 48; i++) {
     token += chars[Math.floor(Math.random() * chars.length)];