@noetaris/harness 0.4.0 → 0.6.0

package/dist/index.js

@@ -491,6 +491,54 @@ function createBuilderInstance(internals) {
   return builder;
 }
 
+// src/agent/observer.ts
+function reportObserverError(error, ctx, sink) {
+  if (sink !== void 0) {
+    try {
+      sink(error, ctx);
+    } catch (sinkError) {
+      console.error(`[harness] onObserverError sink threw while handling '${ctx.hookName}':`, sinkError);
+    }
+    return;
+  }
+  console.error(`[harness] observer hook '${ctx.hookName}' threw:`, error);
+}
+function safeInvoke(hookName, call, sink) {
+  try {
+    call();
+  } catch (error) {
+    reportObserverError(error, { hookName }, sink);
+  }
+}
+function composeObservers(observers, onObserverError) {
+  return {
+    onRunStart: (ctx) => {
+      for (const o of observers) safeInvoke("onRunStart", () => o.onRunStart?.(ctx), onObserverError);
+    },
+    onRunEnd: (ctx, event) => {
+      for (const o of observers) safeInvoke("onRunEnd", () => o.onRunEnd?.(ctx, event), onObserverError);
+    },
+    onStepStart: (ctx) => {
+      for (const o of observers) safeInvoke("onStepStart", () => o.onStepStart?.(ctx), onObserverError);
+    },
+    onStepEnd: (ctx, event) => {
+      for (const o of observers) safeInvoke("onStepEnd", () => o.onStepEnd?.(ctx, event), onObserverError);
+    },
+    onStepError: (ctx, event) => {
+      for (const o of observers) safeInvoke("onStepError", () => o.onStepError?.(ctx, event), onObserverError);
+    },
+    onInterrupt: (ctx, event) => {
+      for (const o of observers) safeInvoke("onInterrupt", () => o.onInterrupt?.(ctx, event), onObserverError);
+    },
+    onEvent: (ctx, type, payload) => {
+      for (const o of observers) safeInvoke("onEvent", () => o.onEvent?.(ctx, type, payload), onObserverError);
+    },
+    onStepSettled: (ctx, event) => {
+      for (const o of observers) safeInvoke("onStepSettled", () => o.onStepSettled?.(ctx, event), onObserverError);
+    }
+  };
+}
+
 // src/agent/ctx-interrupt.ts
 var InterruptPause = class extends Error {
   interruptId;
@@ -523,11 +571,12 @@ function createInterruptFn(state, callCountRef, branchPath) {
 }
 
 // src/agent/ctx-emit.ts
-function createEmitFn(listeners, observer, stepCtxRef) {
+function createEmitFn(listeners, observer, stepCtxRef, onObserverError) {
   return (name, payload) => {
     listeners[name]?.(payload);
     if (observer !== void 0 && stepCtxRef !== void 0 && stepCtxRef.current !== null) {
-      observer.onEvent?.(stepCtxRef.current, name, payload);
+      const ctx = stepCtxRef.current;
+      safeInvoke("onEvent", () => observer.onEvent?.(ctx, name, payload), onObserverError);
     }
   };
 }
@@ -540,6 +589,7 @@ function extractRunListeners(resources) {
 }
 
 // src/loop/loop-executor.ts
+var NOOP_OBSERVER = {};
 function isForkCursor(cursor) {
   return typeof cursor !== "string";
 }
@@ -598,9 +648,19 @@ function applyUpdate(state, update, schema, touchedKeys) {
     touchedKeys?.add(key);
   }
 }
+function fireSettled(obs, stepCtx, stepStart, fields, onObserverError) {
+  const hook = obs?.onStepSettled;
+  if (hook === void 0) return;
+  const event = { ...fields, durationMs: Date.now() - stepStart };
+  safeInvoke("onStepSettled", () => hook(stepCtx, event), onObserverError);
+}
+function asError(e) {
+  return e instanceof Error ? e : new Error(String(e));
+}
 async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callbacks) {
   const { onBeforeStep, onAfterStep, onError, onComplete, onInterrupt } = callbacks ?? {};
   const obs = callbacks?.observer;
+  const onObserverError = callbacks?.onObserverError;
   const implicitNextMap = buildImplicitNextMap(graph);
   if (!("$error" in state)) state.$error = null;
   if (!("$interrupt" in state)) state.$interrupt = null;
@@ -614,15 +674,15 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
     ...typeof ctx.instanceId === "string" ? { instanceId: ctx.instanceId } : {},
     ...callbacks?.branchPath !== void 0 && callbacks.branchPath.length > 0 ? { branchPath: callbacks.branchPath } : {}
   };
-  obs?.onRunStart?.(runCtx);
+  safeInvoke("onRunStart", () => obs?.onRunStart?.(runCtx), onObserverError);
   const callCountRef = { current: 0 };
   const stepCtxRef = { current: null };
   ctx["interrupt"] = createInterruptFn(state, callCountRef, callbacks?.branchPath);
-  ctx["emit"] = createEmitFn(callbacks?.listeners ?? {}, obs, stepCtxRef);
+  ctx["emit"] = createEmitFn(callbacks?.listeners ?? {}, obs, stepCtxRef, onObserverError);
   let cursor = startCursor ?? graph.entryStep;
   while (true) {
     if (shouldStop?.()) {
-      obs?.onRunEnd?.(runCtx, { signal: "$stopped", durationMs: Date.now() - runStart });
+      safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, { signal: "$stopped", durationMs: Date.now() - runStart }), onObserverError);
       return { state, signal: null, cursor, paused: true };
     }
     if (isForkCursor(cursor)) {
@@ -685,13 +745,17 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
     };
     stepCtxRef.current = stepCtx;
     const stepStart = Date.now();
-    obs?.onStepStart?.(stepCtx);
-    if (callbacks?.setStepContextSlots !== void 0) {
-      for (const slot of callbacks.setStepContextSlots) {
-        slot.setStepContext(stepCtx);
+    safeInvoke("onStepStart", () => obs?.onStepStart?.(stepCtx), onObserverError);
+    if (callbacks?.telemetrySlots !== void 0) {
+      const telemetry = { observer: obs ?? NOOP_OBSERVER, stepContext: stepCtx };
+      for (const { key, slot } of callbacks.telemetrySlots) {
+        ;
+        ctx[key] = slot.withTelemetry(telemetry);
       }
     }
     let runSucceeded = false;
+    let applied;
+    const settle = (fields) => fireSettled(obs, stepCtx, stepStart, { ...fields, ...applied !== void 0 ? { update: applied } : {} }, onObserverError);
     if (step.run !== void 0) {
       const hadResponses = Object.keys(state.$interruptResponses).length > 0;
       try {
@@ -700,6 +764,7 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
           ctx
         );
         applyUpdate(state, update, schema, callbacks?.touchedKeys);
+        applied = update;
         if (hadResponses) {
           state.$interrupt = null;
           state.$interruptResponses = {};
@@ -708,19 +773,20 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
       } catch (e) {
         if (isInterruptPause(e)) {
           onInterrupt?.(e.prompt, e.interruptId);
-          obs?.onInterrupt?.(stepCtx, { prompt: e.prompt, interruptId: e.interruptId });
-          obs?.onRunEnd?.(runCtx, { signal: "$interrupt", durationMs: Date.now() - runStart });
+          safeInvoke("onInterrupt", () => obs?.onInterrupt?.(stepCtx, { prompt: e.prompt, interruptId: e.interruptId }), onObserverError);
+          settle({ outcome: "interrupt", interrupt: { interruptId: e.interruptId, prompt: e.prompt }, next: { kind: "pause" } });
+          safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, { signal: "$interrupt", durationMs: Date.now() - runStart }), onObserverError);
           return { state, signal: "$interrupt", cursor, paused: true };
         }
         state.$error = e instanceof Error ? e : new Error(String(e));
         onError?.(state.$error, cursor);
-        obs?.onStepError?.(stepCtx, { error: state.$error, durationMs: Date.now() - stepStart });
+        safeInvoke("onStepError", () => obs?.onStepError?.(stepCtx, { error: state.$error, durationMs: Date.now() - stepStart }), onObserverError);
       }
     }
     if (runSucceeded) {
       state.$error = null;
       onAfterStep?.(cursor, state);
-      obs?.onStepEnd?.(stepCtx, { durationMs: Date.now() - stepStart });
+      safeInvoke("onStepEnd", () => obs?.onStepEnd?.(stepCtx, { durationMs: Date.now() - stepStart }), onObserverError);
     }
     const callRoute = step.route !== void 0 && (runSucceeded || step.run === void 0 || step.errorAware);
     if (callRoute) {
@@ -730,31 +796,42 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
         signal = routeFn(state);
       } catch (e) {
         state.$error = e instanceof Error ? e : new Error(String(e));
-        obs?.onRunEnd?.(runCtx, { signal: "$error", durationMs: Date.now() - runStart });
+        settle({ outcome: "error", error: state.$error, next: { kind: "pause" } });
+        safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, { signal: "$error", durationMs: Date.now() - runStart }), onObserverError);
         return { state, signal: "$error", cursor, paused: true };
       }
+      const routed = runSucceeded || step.run === void 0 ? { outcome: "ok", signal } : { outcome: "error", signal, error: state.$error };
       const transition = step.transitions.find((t) => t.signal === signal);
       if (transition === void 0) {
-        throw new UnknownSignalError(cursor, signal);
+        const unknownSignal = new UnknownSignalError(cursor, signal);
+        settle({ outcome: "error", signal, error: unknownSignal, next: { kind: "throw" } });
+        throw unknownSignal;
       }
       if (transition.target.kind === "end") {
+        settle({ ...routed, next: { kind: "end" } });
         onComplete?.(state, signal);
-        obs?.onRunEnd?.(runCtx, { signal, durationMs: Date.now() - runStart });
+        safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, { signal, durationMs: Date.now() - runStart }), onObserverError);
         return { state, signal, cursor: null, paused: false };
       }
+      settle({ ...routed, next: { kind: "step", name: transition.target.name } });
       cursor = transition.target.name;
     } else if (step.run !== void 0 && !runSucceeded) {
       if (graph.onError !== void 0) {
+        settle({ outcome: "error", error: state.$error, next: { kind: "step", name: graph.onError } });
         cursor = graph.onError;
       } else {
-        obs?.onRunEnd?.(runCtx, { signal: "$error", durationMs: Date.now() - runStart });
+        settle({ outcome: "error", error: state.$error, next: { kind: "pause" } });
+        safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, { signal: "$error", durationMs: Date.now() - runStart }), onObserverError);
         return { state, signal: "$error", cursor, paused: true };
       }
     } else {
       const next = step.next ?? implicitNextMap.get(cursor) ?? null;
       if (next === null) {
-        throw new NoNextStepError(cursor);
+        const noNext = new NoNextStepError(cursor);
+        settle({ outcome: "error", error: noNext, next: { kind: "throw" } });
+        throw noNext;
       }
+      settle({ outcome: "ok", next: { kind: "step", name: next } });
       cursor = next;
     }
   }
@@ -792,16 +869,25 @@ async function dispatchFork(forkNode, priorBranches, outerState, outerCtx, schem
   );
   const { onBeforeStep: _outerOnBeforeStep, onAfterStep: _outerOnAfterStep, onComplete: _outerOnComplete, ...branchCallbacksRest } = callbacks ?? {};
   const branchCallbacksBase = callbacks !== void 0 ? branchCallbacksRest : void 0;
-  const outcomes = await Promise.all(
+  const settled = await Promise.allSettled(
     forkNode.branches.map(async (branch, i) => {
       const prior = priorByName.get(branch.name);
-      const outcome = await runBranch(branch, prior, outerState, outerCtx, schema, shouldStop, branchSignals[i], branchCallbacksBase);
+      let outcome;
+      try {
+        outcome = await runBranch(branch, prior, outerState, outerCtx, schema, shouldStop, branchSignals[i], branchCallbacksBase);
+      } catch (e) {
+        for (const controller of localAborts) controller.abort();
+        throw e;
+      }
       if (outcome.result.paused && outcome.result.signal === "$error") {
         for (const controller of localAborts) controller.abort();
       }
       return outcome;
     })
   );
+  const rejected = settled.find((r) => r.status === "rejected");
+  if (rejected !== void 0) throw rejected.reason;
+  const outcomes = settled.map((r) => r.value);
   const failed = outcomes.find((o) => o.result.paused && o.result.signal === "$error");
   if (failed !== void 0) {
     return { kind: "failed", error: failed.result.state.$error };
@@ -825,7 +911,8 @@ async function dispatchFork(forkNode, priorBranches, outerState, outerCtx, schem
         touchedKeys: [...o.touchedKeys]
       };
     });
-    return { kind: "paused", forkCursor: { kind: "fork", fork: forkNode.name, branches } };
+    const interrupted = outcomes.some((o) => o.result.paused && o.result.signal === "$interrupt");
+    return { kind: "paused", forkCursor: { kind: "fork", fork: forkNode.name, branches }, interrupted };
   }
   const keyOwners = /* @__PURE__ */ new Map();
   for (const outcome of outcomes) {
@@ -849,7 +936,10 @@ async function dispatchFork(forkNode, priorBranches, outerState, outerCtx, schem
       }
     }
   }
-  return { kind: "success" };
+  return {
+    kind: "success",
+    branches: outcomes.map((o) => ({ name: o.name, status: "done", touchedKeys: [...o.touchedKeys] }))
+  };
 }
 async function handleFork(forkNode, priorBranches, state, ctx, schema, shouldStop, callbacks, obs, runCtx, runStart, implicitNextMap, graph) {
   const stepCtx = {
@@ -859,29 +949,50 @@ async function handleFork(forkNode, priorBranches, state, ctx, schema, shouldSto
     ...callbacks?.branchPath !== void 0 && callbacks.branchPath.length > 0 ? { branchPath: callbacks.branchPath } : {}
   };
   const stepStart = Date.now();
-  obs?.onStepStart?.(stepCtx);
-  const dispatch = await dispatchFork(forkNode, priorBranches, state, ctx, schema, shouldStop, callbacks);
+  const onObserverError = callbacks?.onObserverError;
+  safeInvoke("onStepStart", () => obs?.onStepStart?.(stepCtx), onObserverError);
+  let dispatch;
+  try {
+    dispatch = await dispatchFork(forkNode, priorBranches, state, ctx, schema, shouldStop, callbacks);
+  } catch (e) {
+    fireSettled(obs, stepCtx, stepStart, { outcome: "error", error: asError(e), next: { kind: "throw" } }, onObserverError);
+    throw e;
+  }
   if (dispatch.kind === "paused") {
-    obs?.onRunEnd?.(runCtx, { signal: "$interrupt", durationMs: Date.now() - runStart });
-    return { done: true, result: { state, signal: "$interrupt", cursor: dispatch.forkCursor, paused: true } };
+    const fork = {
+      branches: dispatch.forkCursor.branches.map((b) => ({ name: b.name, status: b.status, touchedKeys: b.touchedKeys }))
+    };
+    if (dispatch.interrupted === true) {
+      fireSettled(obs, stepCtx, stepStart, { outcome: "interrupt", next: { kind: "pause" }, fork }, onObserverError);
+      safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, { signal: "$interrupt", durationMs: Date.now() - runStart }), onObserverError);
+      return { done: true, result: { state, signal: "$interrupt", cursor: dispatch.forkCursor, paused: true } };
+    }
+    fireSettled(obs, stepCtx, stepStart, { outcome: "stopped", next: { kind: "pause" }, fork }, onObserverError);
+    safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, { signal: "$stopped", durationMs: Date.now() - runStart }), onObserverError);
+    return { done: true, result: { state, signal: null, cursor: dispatch.forkCursor, paused: true } };
   }
   if (dispatch.kind === "failed") {
     state.$error = dispatch.error;
     callbacks?.onError?.(state.$error, forkNode.name);
-    obs?.onStepError?.(stepCtx, { error: state.$error, durationMs: Date.now() - stepStart });
+    safeInvoke("onStepError", () => obs?.onStepError?.(stepCtx, { error: state.$error, durationMs: Date.now() - stepStart }), onObserverError);
     if (graph.onError !== void 0) {
+      fireSettled(obs, stepCtx, stepStart, { outcome: "error", error: state.$error, next: { kind: "step", name: graph.onError } }, onObserverError);
       return { done: false, nextCursor: graph.onError };
     }
-    obs?.onRunEnd?.(runCtx, { signal: "$error", durationMs: Date.now() - runStart });
+    fireSettled(obs, stepCtx, stepStart, { outcome: "error", error: state.$error, next: { kind: "pause" } }, onObserverError);
+    safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, { signal: "$error", durationMs: Date.now() - runStart }), onObserverError);
     return { done: true, result: { state, signal: "$error", cursor: forkNode.name, paused: true } };
   }
   state.$error = null;
-  obs?.onStepEnd?.(stepCtx, { durationMs: Date.now() - stepStart });
+  safeInvoke("onStepEnd", () => obs?.onStepEnd?.(stepCtx, { durationMs: Date.now() - stepStart }), onObserverError);
   callbacks?.onAfterStep?.(forkNode.name, state);
   const next = forkNode.next ?? implicitNextMap.get(forkNode.name) ?? null;
   if (next === null) {
-    throw new NoNextStepError(forkNode.name);
+    const noNext = new NoNextStepError(forkNode.name);
+    fireSettled(obs, stepCtx, stepStart, { outcome: "error", error: noNext, next: { kind: "throw" } }, onObserverError);
+    throw noNext;
   }
+  fireSettled(obs, stepCtx, stepStart, { outcome: "ok", next: { kind: "step", name: next }, fork: { branches: dispatch.branches } }, onObserverError);
   return { done: false, nextCursor: next };
 }
 
@@ -1315,12 +1426,24 @@ function extractRunEvents(resources) {
 }
 
 // src/agent/create-agent.ts
-var NOOP_OBSERVER = {};
+function buildTelemetrySlots(entries) {
+  const out = [];
+  for (const [key, slot] of entries) {
+    if (slot !== null && typeof slot === "object" && typeof slot["withTelemetry"] === "function") {
+      out.push({ key, slot });
+    }
+  }
+  return out;
+}
 function extractRunObserver(resources) {
   const raw = resources["observer"];
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return void 0;
   return raw;
 }
+function extractRunErrorSink(resources) {
+  const raw = resources["onObserverError"];
+  return typeof raw === "function" ? raw : void 0;
+}
 var MissingLoopError = class extends Error {
   constructor() {
     super("harness has no loop \u2014 call h.loop() before createAgent(id, h, slots)");
@@ -1478,10 +1601,10 @@ function createAgent(id, h, slots, agentOptions) {
     runtimeKeys,
     requiredKeys
   };
-  const reservedRunKeys = /* @__PURE__ */ new Set(["sessionId", "signal", "events", "listeners", "observer", "claimOptions", "parentRunId"]);
+  const reservedRunKeys = /* @__PURE__ */ new Set(["sessionId", "signal", "events", "listeners", "observer", "onObserverError", "claimOptions", "parentRunId"]);
   const inFlightSessions = /* @__PURE__ */ new Set();
   const interruptPendingSessions = /* @__PURE__ */ new Set();
-  const makeAgentResumeHandle = (resp, sId, iId, resumeOpts, observer, setStepContextSlots) => {
+  const makeAgentResumeHandle = (resp, sId, iId, resumeOpts, observer, onObserverError, telemetrySlots) => {
     let _stopped = false;
     const abortController = new AbortController();
     const flag = {
@@ -1556,7 +1679,8 @@ function createAgent(id, h, slots, agentOptions) {
               ...resumeOpts?.onStoreError !== void 0 ? { onStoreError: resumeOpts.onStoreError } : {},
               ...leaseRef !== void 0 ? { leaseRef, claimTtlMs: claimOptions.ttlMs } : {},
               ...observer !== void 0 ? { observer } : {},
-              ...setStepContextSlots !== void 0 && setStepContextSlots.length > 0 ? { setStepContextSlots } : {}
+              ...onObserverError !== void 0 ? { onObserverError } : {},
+              ...telemetrySlots !== void 0 && telemetrySlots.length > 0 ? { telemetrySlots } : {}
             }
           );
           if (r.signal === "$interrupt") interruptPendingSessions.add(sId);
@@ -1652,17 +1776,11 @@ function createAgent(id, h, slots, agentOptions) {
       const events = extractRunEvents(resources);
       const listeners = extractRunListeners(resources);
       const observer = extractRunObserver(resources);
-      for (const slot of [...agentInternals.resolvedProviders.values(), ...Object.values(runtimeSlots)]) {
-        if (slot !== null && typeof slot === "object" && typeof slot["bindObserver"] === "function") {
-          slot.bindObserver(observer ?? NOOP_OBSERVER);
-        }
-      }
-      const setStepContextSlots = [];
-      for (const slot of [...agentInternals.resolvedProviders.values(), ...Object.values(runtimeSlots)]) {
-        if (slot !== null && typeof slot === "object" && typeof slot["setStepContext"] === "function") {
-          setStepContextSlots.push(slot);
-        }
-      }
+      const onObserverError = extractRunErrorSink(resources);
+      const telemetrySlots = buildTelemetrySlots([
+        ...agentInternals.resolvedProviders.entries(),
+        ...Object.entries(runtimeSlots)
+      ]);
       const parentRunId = typeof resources["parentRunId"] === "string" ? resources["parentRunId"] : void 0;
       const options = {
         shouldStop: () => stopFlag.stopped,
@@ -1678,9 +1796,10 @@ function createAgent(id, h, slots, agentOptions) {
         ...events.onInterrupt !== void 0 ? { onInterrupt: events.onInterrupt } : {},
         ...Object.keys(listeners).length > 0 ? { listeners } : {},
         ...observer !== void 0 ? { observer } : {},
+        ...onObserverError !== void 0 ? { onObserverError } : {},
         ...agentOptions?.instanceId !== void 0 ? { instanceId: agentOptions.instanceId } : {},
         ...parentRunId !== void 0 ? { parentRunId } : {},
-        ...setStepContextSlots.length > 0 ? { setStepContextSlots } : {}
+        ...telemetrySlots.length > 0 ? { telemetrySlots } : {}
       };
       let lastResult = null;
       const execution = (async () => {
@@ -1797,7 +1916,8 @@ function createAgent(id, h, slots, agentOptions) {
                     ...events.onInterrupt !== void 0 ? { onInterrupt: events.onInterrupt } : {},
                     ...Object.keys(listeners).length > 0 ? { listeners } : {},
                     ...observer !== void 0 ? { observer } : {},
-                    ...setStepContextSlots.length > 0 ? { setStepContextSlots } : {}
+                    ...onObserverError !== void 0 ? { onObserverError } : {},
+                    ...telemetrySlots.length > 0 ? { telemetrySlots } : {}
                   }
                 );
                 if (r2.signal === "$interrupt") interruptPendingSessions.add(sessionId);
@@ -1829,7 +1949,8 @@ function createAgent(id, h, slots, agentOptions) {
                   ...events.onInterrupt !== void 0 ? { onInterrupt: events.onInterrupt } : {},
                   ...Object.keys(listeners).length > 0 ? { listeners } : {},
                   ...observer !== void 0 ? { observer } : {},
-                  ...setStepContextSlots.length > 0 ? { setStepContextSlots } : {}
+                  ...onObserverError !== void 0 ? { onObserverError } : {},
+                  ...telemetrySlots.length > 0 ? { telemetrySlots } : {}
                 }
               );
               if (r.signal === "$interrupt") interruptPendingSessions.add(sessionId);
@@ -1858,51 +1979,15 @@ function createAgent(id, h, slots, agentOptions) {
       const events = extractRunEvents(resources ?? {});
       const resumeOpts = events.onStoreError !== void 0 ? { onStoreError: events.onStoreError } : void 0;
       const observer = extractRunObserver(resources ?? {});
-      for (const slot of agentInternals.resolvedProviders.values()) {
-        if (slot !== null && typeof slot === "object" && typeof slot["bindObserver"] === "function") {
-          slot.bindObserver(observer ?? NOOP_OBSERVER);
-        }
-      }
-      const setStepContextSlots = [];
-      for (const slot of agentInternals.resolvedProviders.values()) {
-        if (slot !== null && typeof slot === "object" && typeof slot["setStepContext"] === "function") {
-          setStepContextSlots.push(slot);
-        }
-      }
-      return makeAgentResumeHandle(response, sessionId, interruptId, resumeOpts, observer ?? void 0, setStepContextSlots.length > 0 ? setStepContextSlots : void 0);
+      const onObserverError = extractRunErrorSink(resources ?? {});
+      const telemetrySlots = buildTelemetrySlots(agentInternals.resolvedProviders.entries());
+      return makeAgentResumeHandle(response, sessionId, interruptId, resumeOpts, observer ?? void 0, onObserverError ?? void 0, telemetrySlots.length > 0 ? telemetrySlots : void 0);
     },
     status: (sessionId) => querySessionPhase(capturedStore, id, sessionId),
     [_agentInternals]: agentInternals
   };
   return agent;
 }
-
-// src/agent/observer.ts
-function composeObservers(...observers) {
-  return {
-    onRunStart: (ctx) => {
-      for (const o of observers) o.onRunStart?.(ctx);
-    },
-    onRunEnd: (ctx, event) => {
-      for (const o of observers) o.onRunEnd?.(ctx, event);
-    },
-    onStepStart: (ctx) => {
-      for (const o of observers) o.onStepStart?.(ctx);
-    },
-    onStepEnd: (ctx, event) => {
-      for (const o of observers) o.onStepEnd?.(ctx, event);
-    },
-    onStepError: (ctx, event) => {
-      for (const o of observers) o.onStepError?.(ctx, event);
-    },
-    onInterrupt: (ctx, event) => {
-      for (const o of observers) o.onInterrupt?.(ctx, event);
-    },
-    onEvent: (ctx, type, payload) => {
-      for (const o of observers) o.onEvent?.(ctx, type, payload);
-    }
-  };
-}
 export {
   LeaseExpiredError,
   LoopNotDefinedError,