agent-relay 6.3.5 → 7.0.0

package/dist/index.cjs

@@ -43503,6 +43503,7 @@ __export(index_exports, {
   DEFAULT_PROXY_ENV_REGISTRY: () => DEFAULT_PROXY_ENV_REGISTRY,
   DefaultModels: () => DefaultModels,
   ERROR_SEARCH_HINT: () => ERROR_SEARCH_HINT,
+  EventBus: () => EventBus,
   GEMINI_MODEL_OPTIONS: () => GEMINI_MODEL_OPTIONS,
   GeminiModels: () => GeminiModels,
   GitHubClient: () => GitHubClient,
@@ -44423,6 +44424,69 @@ function formatBrokerNotFoundError() {
   return `@agent-relay/sdk couldn't find an agent-relay-broker binary for ${process.platform}-${process.arch}. The optional dependency ${pkgName} is expected to be installed alongside @agent-relay/sdk. Try reinstalling with --include=optional, or set BROKER_BINARY_PATH to point at a broker binary you've downloaded manually.`;
 }
 
+// packages/sdk/dist/event-bus.js
+var EventBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  /**
+   * Register a handler for `event`. Returns an unsubscribe function that
+   * removes the handler when called.
+   */
+  addListener(event, handler) {
+    let set2 = this.handlers.get(event);
+    if (!set2) {
+      set2 = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set2);
+    }
+    set2.add(handler);
+    return () => {
+      const current = this.handlers.get(event);
+      if (current !== set2)
+        return;
+      current.delete(handler);
+      if (current.size === 0) {
+        this.handlers.delete(event);
+      }
+    };
+  }
+  /** Remove a previously-registered handler. Idempotent. */
+  removeListener(event, handler) {
+    const set2 = this.handlers.get(event);
+    if (!set2)
+      return;
+    set2.delete(handler);
+    if (set2.size === 0) {
+      this.handlers.delete(event);
+    }
+  }
+  /** Number of currently-registered handlers for `event`. Useful for tests. */
+  listenerCount(event) {
+    return this.handlers.get(event)?.size ?? 0;
+  }
+  /** Snapshot the handlers for `event` so iteration is safe under concurrent mutation. */
+  listeners(event) {
+    const set2 = this.handlers.get(event);
+    return set2 ? Array.from(set2) : [];
+  }
+  /**
+   * Fire `event` with `args`, awaiting each handler sequentially in
+   * registration order. Handler exceptions are caught and logged; they
+   * never abort the dispatch chain.
+   *
+   * Return value is intentionally `void`; consumers that need to collect
+   * patches (e.g. `beforeAgentSpawn`'s shallow-merge contract) iterate
+   * `listeners()` directly so they can capture each handler's return.
+   */
+  async emit(event, ...args) {
+    for (const handler of this.listeners(event)) {
+      try {
+        await handler(...args);
+      } catch (err) {
+        console.error(`[agent-relay] listener for "${String(event)}" threw:`, err);
+      }
+    }
+  }
+};
+
 // packages/sdk/dist/client.js
 function isHeadlessProvider(value) {
   return value === "claude" || value === "opencode";
@@ -44430,6 +44494,45 @@ function isHeadlessProvider(value) {
 function resolveSpawnTransport(input) {
   return input.transport ?? (input.provider === "opencode" ? "headless" : "pty");
 }
+function buildSpawnPtyBody(input) {
+  return {
+    name: input.name,
+    cli: input.cli,
+    ...input.model !== void 0 ? { model: input.model } : {},
+    args: input.args ?? [],
+    ...input.task !== void 0 ? { task: input.task } : {},
+    channels: input.channels ?? [],
+    ...input.cwd !== void 0 ? { cwd: input.cwd } : {},
+    ...input.team !== void 0 ? { team: input.team } : {},
+    ...input.agentToken !== void 0 ? { agentToken: input.agentToken } : {},
+    ...input.shadowOf !== void 0 ? { shadowOf: input.shadowOf } : {},
+    ...input.shadowMode !== void 0 ? { shadowMode: input.shadowMode } : {},
+    ...input.continueFrom !== void 0 ? { continueFrom: input.continueFrom } : {},
+    ...input.idleThresholdSecs !== void 0 ? { idleThresholdSecs: input.idleThresholdSecs } : {},
+    ...input.restartPolicy !== void 0 ? { restartPolicy: input.restartPolicy } : {},
+    ...input.skipRelayPrompt !== void 0 ? { skipRelayPrompt: input.skipRelayPrompt } : {}
+  };
+}
+function buildSpawnProviderBody(input, transport) {
+  return {
+    name: input.name,
+    cli: input.provider,
+    ...input.model !== void 0 ? { model: input.model } : {},
+    args: input.args ?? [],
+    ...input.task !== void 0 ? { task: input.task } : {},
+    channels: input.channels ?? [],
+    ...input.cwd !== void 0 ? { cwd: input.cwd } : {},
+    ...input.team !== void 0 ? { team: input.team } : {},
+    ...input.agentToken !== void 0 ? { agentToken: input.agentToken } : {},
+    ...input.shadowOf !== void 0 ? { shadowOf: input.shadowOf } : {},
+    ...input.shadowMode !== void 0 ? { shadowMode: input.shadowMode } : {},
+    ...input.continueFrom !== void 0 ? { continueFrom: input.continueFrom } : {},
+    ...input.idleThresholdSecs !== void 0 ? { idleThresholdSecs: input.idleThresholdSecs } : {},
+    ...input.restartPolicy !== void 0 ? { restartPolicy: input.restartPolicy } : {},
+    ...input.skipRelayPrompt !== void 0 ? { skipRelayPrompt: input.skipRelayPrompt } : {},
+    transport
+  };
+}
 function isProcessRunning(pid) {
   if (!Number.isInteger(pid) || pid <= 0) {
     return false;
@@ -44467,7 +44570,13 @@ var AgentRelayClient = class _AgentRelayClient {
   /** Lease renewal timer (only for spawned brokers). */
   leaseTimer = null;
   workspaceKey;
+  /** Resolved broker URL — captured so call-site lifecycle contexts can surface it. */
+  baseUrl;
+  /** Shared multi-listener registry. Created bare when no `eventBus` is passed in. */
+  eventBus;
   constructor(options) {
+    this.baseUrl = options.baseUrl;
+    this.eventBus = options.eventBus ?? new EventBus();
     this.transport = new BrokerTransport({
       baseUrl: options.baseUrl,
       apiKey: options.apiKey,
@@ -44475,6 +44584,39 @@ var AgentRelayClient = class _AgentRelayClient {
       requestTimeoutMs: options.requestTimeoutMs
     });
   }
+  /**
+   * Register a listener on the client's event bus. Returns an unsubscribe
+   * function. Equivalent to `client.eventBus.addListener(...)` but mirrors
+   * the `AgentRelay` facade API so direct-client callers don't need to
+   * reach through `.eventBus`.
+   */
+  addListener(event, handler) {
+    return this.eventBus.addListener(event, handler);
+  }
+  /** Remove a previously-registered listener. */
+  removeListener(event, handler) {
+    this.eventBus.removeListener(event, handler);
+  }
+  /**
+   * Fold `beforeAgentSpawn` patches into the input. Listeners run in
+   * registration order; each may return a {@link SpawnPatch} that is
+   * shallow-merged over the running result. Handler exceptions are caught
+   * and logged but do not abort the chain.
+   */
+  async runBeforeSpawn(ctx) {
+    let resolved = { ...ctx.input };
+    for (const handler of this.eventBus.listeners("beforeAgentSpawn")) {
+      try {
+        const patch = await handler({ ...ctx, input: resolved });
+        if (patch && typeof patch === "object") {
+          resolved = { ...resolved, ...patch };
+        }
+      } catch (err) {
+        console.error("[agent-relay] beforeAgentSpawn listener threw:", err);
+      }
+    }
+    return resolved;
+  }
   /**
    * Connect to an already-running broker by reading its connection file.
    *
@@ -44504,7 +44646,11 @@ var AgentRelayClient = class _AgentRelayClient {
     if (!isProcessRunning(conn.pid)) {
       throw new Error(`Stale broker connection file (${connPath}) points to dead pid ${conn.pid}. Start the broker with 'agent-relay up' or use AgentRelayClient.spawn().`);
     }
-    return new _AgentRelayClient({ baseUrl: conn.url, apiKey: conn.api_key });
+    return new _AgentRelayClient({
+      baseUrl: conn.url,
+      apiKey: conn.api_key,
+      ...options?.eventBus ? { eventBus: options.eventBus } : {}
+    });
   }
   /**
    * Spawn a local broker process and return a connected client.
@@ -44564,7 +44710,8 @@ var AgentRelayClient = class _AgentRelayClient {
     const client = new _AgentRelayClient({
       baseUrl,
       apiKey,
-      requestTimeoutMs: options?.requestTimeoutMs
+      requestTimeoutMs: options?.requestTimeoutMs,
+      ...options?.eventBus ? { eventBus: options.eventBus } : {}
     });
     client.child = child;
     const brokerExited = new Promise((_2, reject) => {
@@ -44632,53 +44779,52 @@ var AgentRelayClient = class _AgentRelayClient {
   }
   // ── Agent lifecycle ────────────────────────────────────────────────
   async spawnPty(input) {
-    return this.transport.request("/api/spawn", {
-      method: "POST",
-      body: JSON.stringify({
-        name: input.name,
-        cli: input.cli,
-        ...input.model !== void 0 ? { model: input.model } : {},
-        args: input.args ?? [],
-        ...input.task !== void 0 ? { task: input.task } : {},
-        channels: input.channels ?? [],
-        ...input.cwd !== void 0 ? { cwd: input.cwd } : {},
-        ...input.team !== void 0 ? { team: input.team } : {},
-        ...input.agentToken !== void 0 ? { agentToken: input.agentToken } : {},
-        ...input.shadowOf !== void 0 ? { shadowOf: input.shadowOf } : {},
-        ...input.shadowMode !== void 0 ? { shadowMode: input.shadowMode } : {},
-        ...input.continueFrom !== void 0 ? { continueFrom: input.continueFrom } : {},
-        ...input.idleThresholdSecs !== void 0 ? { idleThresholdSecs: input.idleThresholdSecs } : {},
-        ...input.restartPolicy !== void 0 ? { restartPolicy: input.restartPolicy } : {},
-        ...input.skipRelayPrompt !== void 0 ? { skipRelayPrompt: input.skipRelayPrompt } : {}
-      })
-    });
+    const beforeCtx = {
+      kind: "pty",
+      input,
+      spawnerPid: process.pid,
+      spawnStartTs: (/* @__PURE__ */ new Date()).toISOString(),
+      baseUrl: this.baseUrl
+    };
+    const t0 = Date.now();
+    const resolvedInput = await this.runBeforeSpawn(beforeCtx);
+    try {
+      const result = await this.transport.request("/api/spawn", {
+        method: "POST",
+        body: JSON.stringify(buildSpawnPtyBody(resolvedInput))
+      });
+      await this.emitAfterSpawn(beforeCtx, resolvedInput, t0, result, void 0);
+      return result;
+    } catch (err) {
+      await this.emitAfterSpawn(beforeCtx, resolvedInput, t0, void 0, err);
+      throw err;
+    }
   }
   async spawnProvider(input) {
     const transport = resolveSpawnTransport(input);
     if (transport === "headless" && !isHeadlessProvider(input.provider)) {
       throw new Error(`provider '${input.provider}' does not support headless transport (supported: claude, opencode)`);
     }
-    return this.transport.request("/api/spawn", {
-      method: "POST",
-      body: JSON.stringify({
-        name: input.name,
-        cli: input.provider,
-        ...input.model !== void 0 ? { model: input.model } : {},
-        args: input.args ?? [],
-        ...input.task !== void 0 ? { task: input.task } : {},
-        channels: input.channels ?? [],
-        ...input.cwd !== void 0 ? { cwd: input.cwd } : {},
-        ...input.team !== void 0 ? { team: input.team } : {},
-        ...input.agentToken !== void 0 ? { agentToken: input.agentToken } : {},
-        ...input.shadowOf !== void 0 ? { shadowOf: input.shadowOf } : {},
-        ...input.shadowMode !== void 0 ? { shadowMode: input.shadowMode } : {},
-        ...input.continueFrom !== void 0 ? { continueFrom: input.continueFrom } : {},
-        ...input.idleThresholdSecs !== void 0 ? { idleThresholdSecs: input.idleThresholdSecs } : {},
-        ...input.restartPolicy !== void 0 ? { restartPolicy: input.restartPolicy } : {},
-        ...input.skipRelayPrompt !== void 0 ? { skipRelayPrompt: input.skipRelayPrompt } : {},
-        transport
-      })
-    });
+    const beforeCtx = {
+      kind: "provider",
+      input,
+      spawnerPid: process.pid,
+      spawnStartTs: (/* @__PURE__ */ new Date()).toISOString(),
+      baseUrl: this.baseUrl
+    };
+    const t0 = Date.now();
+    const resolvedInput = await this.runBeforeSpawn(beforeCtx);
+    try {
+      const result = await this.transport.request("/api/spawn", {
+        method: "POST",
+        body: JSON.stringify(buildSpawnProviderBody(resolvedInput, transport))
+      });
+      await this.emitAfterSpawn(beforeCtx, resolvedInput, t0, result, void 0);
+      return result;
+    } catch (err) {
+      await this.emitAfterSpawn(beforeCtx, resolvedInput, t0, void 0, err);
+      throw err;
+    }
   }
   async spawnHeadless(input) {
     return this.spawnProvider({ ...input, transport: "headless" });
@@ -44690,10 +44836,39 @@ var AgentRelayClient = class _AgentRelayClient {
     return this.spawnProvider({ ...input, provider: "opencode" });
   }
   async release(name, reason) {
-    return this.transport.request(`/api/spawned/${encodeURIComponent(name)}`, {
-      method: "DELETE",
-      ...reason ? { body: JSON.stringify({ reason }) } : {}
-    });
+    const beforeCtx = { name, reason, baseUrl: this.baseUrl };
+    const t0 = Date.now();
+    await this.eventBus.emit("beforeAgentRelease", beforeCtx);
+    try {
+      const result = await this.transport.request(`/api/spawned/${encodeURIComponent(name)}`, {
+        method: "DELETE",
+        ...reason ? { body: JSON.stringify({ reason }) } : {}
+      });
+      const afterCtx = {
+        ...beforeCtx,
+        durationMs: Date.now() - t0
+      };
+      await this.eventBus.emit("afterAgentRelease", afterCtx);
+      return result;
+    } catch (err) {
+      const afterCtx = {
+        ...beforeCtx,
+        error: err instanceof Error ? err : new Error(String(err)),
+        durationMs: Date.now() - t0
+      };
+      await this.eventBus.emit("afterAgentRelease", afterCtx);
+      throw err;
+    }
+  }
+  async emitAfterSpawn(beforeCtx, resolvedInput, startMs, result, error51) {
+    const afterCtx = {
+      ...beforeCtx,
+      resolvedInput,
+      ...result ? { result } : {},
+      ...error51 !== void 0 ? { error: error51 instanceof Error ? error51 : new Error(String(error51)) } : {},
+      durationMs: Date.now() - startMs
+    };
+    await this.eventBus.emit("afterAgentSpawn", afterCtx);
   }
   async listAgents() {
     const result = await this.transport.request("/api/spawned");
@@ -70529,20 +70704,40 @@ function toWorkspaceRegistryEntry(value) {
   };
 }
 var AgentRelay = class {
-  // Event hooks — assign a callback or null to clear.
-  onMessageReceived = null;
-  onMessageSent = null;
-  onAgentSpawned = null;
-  onAgentReleased = null;
-  onAgentExited = null;
-  onAgentReady = null;
-  onWorkerOutput = null;
-  onDeliveryUpdate = null;
-  onAgentExitRequested = null;
-  onAgentIdle = null;
-  onAgentActivityChanged = null;
-  onChannelSubscribed = null;
-  onChannelUnsubscribed = null;
+  /**
+   * Multi-listener event registry. Subscribe via {@link addListener} or
+   * `bus.addListener` directly; emit happens internally as broker events
+   * arrive and at SDK call sites for the spawn / release lifecycle hooks.
+   *
+   * The bus is shared with the underlying `AgentRelayClient` (created via
+   * {@link ensureStarted}) so listeners registered on either object see
+   * the same events.
+   */
+  bus = new EventBus();
+  // ── Listener registration ───────────────────────────────────────────────
+  /**
+   * Register a listener for a relay lifecycle event. Returns an
+   * unsubscribe function.
+   *
+   * Example:
+   * ```ts
+   * const off = relay.addListener('agentSpawned', (agent) => console.log(agent.name));
+   * // later:
+   * off();
+   * ```
+   *
+   * Replaces the pre-2.x single-callback `on*` fields. Multiple listeners
+   * can register for the same event; they fire sequentially in
+   * registration order. Async handlers are awaited. Handler exceptions
+   * are caught and logged; one bad listener never blocks the others.
+   */
+  addListener(event, handler) {
+    return this.bus.addListener(event, handler);
+  }
+  /** Remove a previously-registered listener. Idempotent. */
+  removeListener(event, handler) {
+    this.bus.removeListener(event, handler);
+  }
   // ── Public accessors ────────────────────────────────────────────────────
   /** The resolved Relaycast workspace API key (available after first spawn). */
   get workspaceKey() {
@@ -70893,7 +71088,7 @@ var AgentRelay = class {
           data: input.data,
           mode: input.mode
         };
-        this.onMessageSent?.(msg);
+        void this.bus.emit("messageSent", msg);
         return msg;
       }
     };
@@ -71268,7 +71463,7 @@ var AgentRelay = class {
       return;
     }
     state.active = active;
-    this.onAgentActivityChanged?.({
+    void this.bus.emit("agentActivityChanged", {
       name,
       active,
       pendingDeliveries: state.pendingDeliveries.size,
@@ -71385,6 +71580,7 @@ var AgentRelay = class {
       return this.startPromise;
     this.startPromise = this.ensureRelaycastApiKey().then(() => AgentRelayClient.spawn({
       ...this.clientOptions,
+      eventBus: this.bus,
       onStderr: (line) => {
         for (const listener of this.stderrListeners) {
           try {
@@ -71434,7 +71630,7 @@ var AgentRelay = class {
             threadId: event.thread_id,
             mode: event.injection_mode ?? event.mode
           };
-          this.onMessageReceived?.(msg);
+          void this.bus.emit("messageReceived", msg);
           break;
         }
         case "agent_spawned": {
@@ -71443,7 +71639,7 @@ var AgentRelay = class {
           this.messageReadyAgents.delete(event.name);
           this.exitedAgents.delete(event.name);
           this.idleAgents.delete(event.name);
-          this.onAgentSpawned?.(agent);
+          void this.bus.emit("agentSpawned", agent);
           break;
         }
         case "agent_released": {
@@ -71453,7 +71649,7 @@ var AgentRelay = class {
           this.readyAgents.delete(event.name);
           this.messageReadyAgents.delete(event.name);
           this.idleAgents.delete(event.name);
-          this.onAgentReleased?.(agent);
+          void this.bus.emit("agentReleased", agent);
           this.knownAgents.delete(event.name);
           this.outputListeners.delete(event.name);
           this.exitResolvers.get(event.name)?.resolve("released");
@@ -71474,7 +71670,7 @@ var AgentRelay = class {
           if (event.reason !== void 0) {
             agent.exitReason = event.reason;
           }
-          this.onAgentExited?.(agent);
+          void this.bus.emit("agentExited", agent);
           this.knownAgents.delete(event.name);
           this.outputListeners.delete(event.name);
           this.exitResolvers.get(event.name)?.resolve("exited");
@@ -71486,7 +71682,7 @@ var AgentRelay = class {
         case "agent_exit": {
           const agent = this.knownAgents.get(event.name) ?? this.ensureAgentHandle(event.name, "pty", []);
           agent.exitReason = event.reason;
-          this.onAgentExitRequested?.({ name: event.name, reason: event.reason });
+          void this.bus.emit("agentExitRequested", { name: event.name, reason: event.reason });
           break;
         }
         case "worker_ready": {
@@ -71494,17 +71690,17 @@ var AgentRelay = class {
           this.readyAgents.add(event.name);
           this.exitedAgents.delete(event.name);
           this.idleAgents.delete(event.name);
-          this.onAgentReady?.(agent);
+          void this.bus.emit("agentReady", agent);
           break;
         }
         case "channel_subscribed": {
           this.addAgentChannels(event.name, event.channels);
-          this.onChannelSubscribed?.(event.name, event.channels);
+          void this.bus.emit("channelSubscribed", { agent: event.name, channels: event.channels });
           break;
         }
         case "channel_unsubscribed": {
           this.removeAgentChannels(event.name, event.channels);
-          this.onChannelUnsubscribed?.(event.name, event.channels);
+          void this.bus.emit("channelUnsubscribed", { agent: event.name, channels: event.channels });
           break;
         }
         case "delivery_queued": {
@@ -71550,7 +71746,7 @@ var AgentRelay = class {
         }
         case "worker_stream": {
           this.idleAgents.delete(event.name);
-          this.onWorkerOutput?.({
+          void this.bus.emit("workerOutput", {
             name: event.name,
             stream: event.stream,
             chunk: event.chunk
@@ -71561,7 +71757,7 @@ var AgentRelay = class {
         case "agent_idle": {
           this.clearAgentDeliveries(event.name, "agent_idle");
           this.idleAgents.add(event.name);
-          this.onAgentIdle?.({
+          void this.bus.emit("agentIdle", {
             name: event.name,
             idleSecs: event.idle_secs
           });
@@ -71571,7 +71767,7 @@ var AgentRelay = class {
         }
       }
       if (event.kind.startsWith("delivery_") || event.kind.startsWith("message_delivery_")) {
-        this.onDeliveryUpdate?.(event);
+        void this.bus.emit("deliveryUpdate", event);
       }
     });
   }
@@ -71730,7 +71926,7 @@ var AgentRelay = class {
           data: input.data,
           mode: input.mode
         };
-        relay.onMessageSent?.(msg);
+        void relay.bus.emit("messageSent", msg);
         return msg;
       },
       async subscribe(channelsToAdd) {
@@ -72394,7 +72590,7 @@ var ShadowManager = class {
    * Determine which shadows should receive a copy of a message
    * between `from` and `to`. Returns a list of shadow copies to deliver.
    *
-   * Call this from your `onMessageReceived` / `onMessageSent` hooks
+   * Call this from your `messageReceived` / `messageSent` listeners
    * to fan out shadow copies.
    */
   intercept(from, to2) {
@@ -72882,15 +73078,15 @@ async function spawnFromEnv(options = {}) {
     cwd: policy.cwd ?? process.cwd(),
     env
   });
-  relay.onAgentSpawned = (agent) => {
+  relay.addListener("agentSpawned", (agent) => {
     console.log(`[spawn-from-env] Agent spawned: ${agent.name}`);
-  };
-  relay.onAgentReady = (agent) => {
+  });
+  relay.addListener("agentReady", (agent) => {
     console.log(`[spawn-from-env] Agent ready: ${agent.name}`);
-  };
-  relay.onAgentExited = (agent) => {
+  });
+  relay.addListener("agentExited", (agent) => {
     console.log(`[spawn-from-env] Agent exited: ${agent.name} code=${agent.exitCode ?? "none"} signal=${agent.exitSignal ?? "none"}`);
-  };
+  });
   try {
     const agent = await relay.spawnPty({
       name: policy.name,
@@ -82414,6 +82610,7 @@ var WorkflowRunner = class _WorkflowRunner {
   runStartTime;
   /** Unsubscribe handle for broker stderr listener wired during a run. */
   unsubBrokerStderr;
+  unsubRelayListeners = [];
   /** Tracks last idle log time per agent to debounce idle warnings (30s multiples). */
   lastIdleLog = /* @__PURE__ */ new Map();
   /** Tracks last logged activity type per agent to avoid duplicate status lines. */
@@ -84405,7 +84602,7 @@ ${err.suggestion}`);
           // long-running PTY processes from earlier steps. 120s gives room to breathe.
           requestTimeoutMs: this.relayOptions.requestTimeoutMs ?? 12e4
         });
-        this.relay.onWorkerOutput = ({ name, chunk }) => {
+        this.unsubRelayListeners.push(this.relay.addListener("workerOutput", ({ name, chunk }) => {
           const listener = this.ptyListeners.get(name);
           if (listener)
             listener(chunk);
@@ -84444,8 +84641,8 @@ ${err.suggestion}`);
             this.lastActivity.set(name, activity);
             this.log(`[${shortName}] ${activity}`);
           }
-        };
-        this.relay.onMessageReceived = (msg) => {
+        }));
+        this.unsubRelayListeners.push(this.relay.addListener("messageReceived", (msg) => {
           this.emit({
             type: "broker:event",
             runId,
@@ -84482,8 +84679,8 @@ ${err.suggestion}`);
             });
             void this.trajectory?.ownerMonitoringEvent(supervision.stepName, supervision.logicalName, `Messaged ${msg.to}: ${msg.text.slice(0, 120)}`, { to: msg.to, text: msg.text });
           }
-        };
-        this.relay.onAgentSpawned = (agent) => {
+        }));
+        this.unsubRelayListeners.push(this.relay.addListener("agentSpawned", (agent) => {
           this.emit({
             type: "broker:event",
             runId,
@@ -84496,8 +84693,8 @@ ${err.suggestion}`);
           if (!this.activeAgentHandles.has(agent.name)) {
             this.log(`[spawned] ${agent.name} (${agent.runtime})`);
           }
-        };
-        this.relay.onAgentReleased = (agent) => {
+        }));
+        this.unsubRelayListeners.push(this.relay.addListener("agentReleased", (agent) => {
           this.emit({
             type: "broker:event",
             runId,
@@ -84506,8 +84703,8 @@ ${err.suggestion}`);
               name: agent.name
             }
           });
-        };
-        this.relay.onAgentExited = (agent) => {
+        }));
+        this.unsubRelayListeners.push(this.relay.addListener("agentExited", (agent) => {
           this.emit({
             type: "broker:event",
             runId,
@@ -84523,11 +84720,11 @@ ${err.suggestion}`);
           if (!this.activeAgentHandles.has(agent.name)) {
             this.log(`[exited] ${agent.name} (code: ${agent.exitCode ?? "?"})`);
           }
-        };
-        this.relay.onDeliveryUpdate = (event) => {
+        }));
+        this.unsubRelayListeners.push(this.relay.addListener("deliveryUpdate", (event) => {
           this.emit({ type: "broker:event", runId, event });
-        };
-        this.relay.onAgentIdle = ({ name, idleSecs }) => {
+        }));
+        this.unsubRelayListeners.push(this.relay.addListener("agentIdle", ({ name, idleSecs }) => {
           this.emit({
             type: "broker:event",
             runId,
@@ -84543,7 +84740,7 @@ ${err.suggestion}`);
             const shortName = name.replace(/-[a-f0-9]{6,}$/, "");
             this.log(`[idle] ${shortName} silent for ${bucket}s`);
           }
-        };
+        }));
         this.relaycast = void 0;
         this.relaycastAgent = void 0;
         this.unsubBrokerStderr = this.relay.onBrokerStderr((line) => {
@@ -84654,15 +84851,13 @@ ${err.suggestion}`);
       this.ptyListeners.clear();
       this.unsubBrokerStderr?.();
       this.unsubBrokerStderr = void 0;
-      if (this.relay) {
-        this.relay.onMessageReceived = null;
-        this.relay.onAgentSpawned = null;
-        this.relay.onAgentReleased = null;
-        this.relay.onAgentExited = null;
-        this.relay.onAgentIdle = null;
-        this.relay.onWorkerOutput = null;
-        this.relay.onDeliveryUpdate = null;
+      for (const off of this.unsubRelayListeners) {
+        try {
+          off();
+        } catch {
+        }
       }
+      this.unsubRelayListeners = [];
       this.lastIdleLog.clear();
       this.lastActivity.clear();
       this.supervisedRuntimeAgents.clear();
@@ -94695,6 +94890,7 @@ init_dist2();
   DEFAULT_PROXY_ENV_REGISTRY,
   DefaultModels,
   ERROR_SEARCH_HINT,
+  EventBus,
   GEMINI_MODEL_OPTIONS,
   GeminiModels,
   GitHubClient,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay",
-  "version": "6.3.5",
+  "version": "7.0.0",
   "description": "Real-time agent-to-agent communication system",
   "type": "module",
   "main": "dist/index.cjs",
@@ -132,14 +132,14 @@
   },
   "homepage": "https://github.com/AgentWorkforce/relay#readme",
   "dependencies": {
-    "@agent-relay/cloud": "6.3.5",
-    "@agent-relay/config": "6.3.5",
-    "@agent-relay/hooks": "6.3.5",
-    "@agent-relay/sdk": "6.3.5",
-    "@agent-relay/telemetry": "6.3.5",
-    "@agent-relay/trajectory": "6.3.5",
-    "@agent-relay/user-directory": "6.3.5",
-    "@agent-relay/utils": "6.3.5",
+    "@agent-relay/cloud": "7.0.0",
+    "@agent-relay/config": "7.0.0",
+    "@agent-relay/hooks": "7.0.0",
+    "@agent-relay/sdk": "7.0.0",
+    "@agent-relay/telemetry": "7.0.0",
+    "@agent-relay/trajectory": "7.0.0",
+    "@agent-relay/user-directory": "7.0.0",
+    "@agent-relay/utils": "7.0.0",
     "@aws-sdk/client-s3": "3.1020.0",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "@relayauth/core": "^0.1.2",