@noetaris/harness 0.4.0 → 0.5.0

package/README.md

@@ -190,6 +190,8 @@ const resumed = agent.resume(response, sessionId, interruptId)
 - ESM only (`"type": "module"`)
 - Zero runtime dependencies
 
+See [LIMITATIONS.md](LIMITATIONS.md) for known limitations.
+
 ## Related Packages
 
 - [`@noetaris/harness-store`](https://github.com/noetaris-lab/harness-store) — session store implementations (`InMemorySessionStore`, `LocalFileSessionStore`, etc.)

package/dist/index.d.ts

@@ -195,38 +195,38 @@ interface Observer {
     onEvent?: (ctx: StepContext, type: string, payload: unknown) => void;
 }
 /**
- * Implemented by resources (e.g. LLM adapters) that accept an {@link Observer}
- * at run time.  The harness calls `bindObserver` on every slot value that
- * implements this interface before the first step runs.
+ * The telemetry a resource needs to attribute an `invoke()` call to the correct
+ * run and step: the run's {@link Observer} and the current {@link StepContext}.
  *
- * Optionally, the harness calls `setStepContext` at the start of each step for
- * every slot that exposes it.  Adapters use this to attribute per-step telemetry
- * (e.g. `observer.onEvent`) to the correct step without manual calls from step code.
+ * The harness passes this per call rather than storing it on the resource instance,
+ * so concurrently-running fork branches that share one instance never race on it —
+ * each call carries its own context by value.
+ */
+interface TelemetryContext {
+    readonly observer: Observer;
+    readonly stepContext: StepContext;
+}
+/**
+ * Implemented by resources (e.g. LLM adapters) that emit per-step telemetry.
+ *
+ * The harness calls {@link ObserverAware.withTelemetry} at the start of each step for every
+ * slot that exposes it, and installs the returned value as that slot on the step's `ctx`.
+ * Step code then calls the returned view (e.g. `ctx.llm.invoke(...)`) with no telemetry
+ * arguments, and the view forwards the {@link TelemetryContext} into the call it wraps — so
+ * telemetry travels *with the call* rather than living in mutable instance state.
+ *
+ * The return is typed `unknown` because core exports no LLM-domain type; a concrete adapter
+ * narrows it (e.g. to its `LLM` view). The harness treats the returned value as an opaque
+ * slot, exactly as it treats every provided slot.
  */
 interface ObserverAware {
     /**
-     * Receive the run's observer.  The harness calls this once per `agent.run()`
-     * invocation before execution begins.
+     * Return a view of this resource scoped to the given telemetry. The harness installs
+     * the returned value as the resource's slot on the step's `ctx` before calling `step.run`.
+     * Called once per step (and once per step per branch), so each concurrent branch gets its
+     * own scoped view and there is no shared field to race on.
      */
-    bindObserver(observer: Observer): void;
-    /**
-     * Receive the current step context.  The harness calls this at the start of
-     * each step for every slot that exposes this method, before calling `step.run`.
-     *
-     * Adapters that emit `observer.onEvent` in their `invoke()` method store the
-     * provided `StepContext` and use it as the first argument to `onEvent`, so
-     * events are attributed to the correct step automatically.
-     *
-     * **Known limitation (fork/join branches):** the store-in-a-field pattern above is safe only
-     * because exactly one step runs at a time in a non-forked run. When a fork's branches run
-     * concurrently, they typically share one `ObserverAware` slot instance (`h.provide('llm', ...)`
-     * provides it once), so concurrent branches race on that stored field and `onEvent` calls may
-     * be attributed to the wrong branch/step. This is a known v1 limitation of the built-in LLM
-     * adapters (`@noetaris/harness-anthropic`/`-openai`/`-google`/`-ollama`), not fixed for this
-     * release — a correct fix means passing `StepContext` through the call instead of storing it.
-     * Treat per-step LLM telemetry as unreliable for concurrently-running branches until then.
-     */
-    setStepContext?(ctx: StepContext): void;
+    withTelemetry(ctx: TelemetryContext): unknown;
 }
 /**
  * Combine multiple {@link Observer} instances into one.  Each hook on the
@@ -234,10 +234,27 @@ interface ObserverAware {
  *
  * @example
  * ```ts
- * const observer = composeObservers(otelObserver, metricsObserver)
+ * const observer = composeObservers([otelObserver, metricsObserver])
  * ```
  */
-declare function composeObservers(...observers: Observer[]): Observer;
+/**
+ * Identifies which observer hook threw. Passed to an {@link ObserverErrorSink}.
+ */
+interface ObserverErrorContext {
+    /** The observer hook that threw, e.g. `'onStepStart'`, `'onRunEnd'`, `'onEvent'`. */
+    readonly hookName: string;
+}
+/**
+ * Opt-in sink for errors thrown by observer callbacks. Supplied under the
+ * `'onObserverError'` key in `agent.run()` / `agent.resume()` resources.
+ *
+ * Telemetry is a side-channel: an observer that throws must never crash a run.
+ * The harness routes every such throw here and continues. The sink is called at
+ * most once per failed hook invocation and MUST NOT rethrow into the run — if it
+ * does, the harness contains that too (see {@link safeInvoke}).
+ */
+type ObserverErrorSink = (error: unknown, ctx: ObserverErrorContext) => void;
+declare function composeObservers(observers: Observer[], onObserverError?: ObserverErrorSink): Observer;
 
 type Cursor = string | ForkCursor;
 /**
@@ -664,11 +681,10 @@ interface LoopBuilder<S, Ctx> {
      * with .branch() immediately after. The step immediately following the fork automatically
      * waits for every branch to settle (the "join") — no separate join primitive exists.
      *
-     * Known limitation: the built-in LLM adapters (`@noetaris/harness-anthropic`/`-openai`/
-     * `-google`/`-ollama`) attribute per-step telemetry via a stored-field pattern that is not
-     * safe when one adapter instance is shared across concurrently-running branches (the normal
-     * setup). See `ObserverAware.setStepContext`'s doc comment (`agent/observer.ts`) for details
-     * — not fixed for this release.
+     * Per-step telemetry is attributed correctly across concurrent branches: the harness scopes
+     * each branch's slots per step via {@link ObserverAware.withTelemetry}, so telemetry travels
+     * with the call rather than through shared instance state. See `ObserverAware`'s doc comment
+     * (`agent/observer.ts`).
      */
     fork(name: string): LoopBuilder<S, Ctx>;
     /**
@@ -967,4 +983,4 @@ declare class LeaseExpiredError extends Error {
     constructor(sessionId: string);
 }
 
-export { type Agent, type BranchCursor, type BranchDef, type ClaimOptions, type Cursor, type DeepWithMarkers, type FieldDefinition, type ForkCursor, type ForkDef, type FrameworkState, type Harness, type Lease, LeaseExpiredError, type LoopDefinition, type LoopNode, LoopNotDefinedError, NoInterruptError, type Observer, type ObserverAware, REQUIRED_TAG, RUNTIME_TAG, type RequiredMarker, type RouteFn, type RunContext, type RunFn, type RuntimeMarker, SessionBusyError, SessionInFlightError, SessionPendingInterruptError, type SessionStore, type SignalTransition, type StateFromSchema, type StepContext, type StepDef, type StepState, StoreLoadError, type StoredRun, type StoredRunMetadata, type TransitionTarget, composeObservers, createAgent, createHarness, field, isForkCursor, isForkDef, isRequiredMarker, isRuntimeMarker, required, runtime };
+export { type Agent, type BranchCursor, type BranchDef, type ClaimOptions, type Cursor, type DeepWithMarkers, type FieldDefinition, type ForkCursor, type ForkDef, type FrameworkState, type Harness, type Lease, LeaseExpiredError, type LoopDefinition, type LoopNode, LoopNotDefinedError, NoInterruptError, type Observer, type ObserverAware, type ObserverErrorContext, type ObserverErrorSink, REQUIRED_TAG, RUNTIME_TAG, type RequiredMarker, type RouteFn, type RunContext, type RunFn, type RuntimeMarker, SessionBusyError, SessionInFlightError, SessionPendingInterruptError, type SessionStore, type SignalTransition, type StateFromSchema, type StepContext, type StepDef, type StepState, StoreLoadError, type StoredRun, type StoredRunMetadata, type TelemetryContext, type TransitionTarget, composeObservers, createAgent, createHarness, field, isForkCursor, isForkDef, isRequiredMarker, isRuntimeMarker, required, runtime };

package/dist/index.js

@@ -491,6 +491,51 @@ 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);
+    }
+  };
+}
+
 // src/agent/ctx-interrupt.ts
 var InterruptPause = class extends Error {
   interruptId;
@@ -523,11 +568,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 +586,7 @@ function extractRunListeners(resources) {
 }
 
 // src/loop/loop-executor.ts
+var NOOP_OBSERVER = {};
 function isForkCursor(cursor) {
   return typeof cursor !== "string";
 }
@@ -601,6 +648,7 @@ function applyUpdate(state, update, schema, touchedKeys) {
 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 +662,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,10 +733,12 @@ 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;
@@ -708,19 +758,19 @@ 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);
+          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,7 +780,7 @@ 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 });
+        safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, { signal: "$error", durationMs: Date.now() - runStart }), onObserverError);
         return { state, signal: "$error", cursor, paused: true };
       }
       const transition = step.transitions.find((t) => t.signal === signal);
@@ -739,7 +789,7 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
       }
       if (transition.target.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 };
       }
       cursor = transition.target.name;
@@ -747,7 +797,7 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
       if (graph.onError !== void 0) {
         cursor = graph.onError;
       } else {
-        obs?.onRunEnd?.(runCtx, { signal: "$error", durationMs: Date.now() - runStart });
+        safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, { signal: "$error", durationMs: Date.now() - runStart }), onObserverError);
         return { state, signal: "$error", cursor, paused: true };
       }
     } else {
@@ -859,24 +909,25 @@ 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 onObserverError = callbacks?.onObserverError;
+  safeInvoke("onStepStart", () => obs?.onStepStart?.(stepCtx), onObserverError);
   const dispatch = await dispatchFork(forkNode, priorBranches, state, ctx, schema, shouldStop, callbacks);
   if (dispatch.kind === "paused") {
-    obs?.onRunEnd?.(runCtx, { signal: "$interrupt", durationMs: Date.now() - runStart });
+    safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, { signal: "$interrupt", durationMs: Date.now() - runStart }), onObserverError);
     return { done: true, result: { state, signal: "$interrupt", 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) {
       return { done: false, nextCursor: graph.onError };
     }
-    obs?.onRunEnd?.(runCtx, { signal: "$error", durationMs: Date.now() - runStart });
+    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) {
@@ -1315,12 +1366,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 +1541,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 +1619,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 +1716,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 +1736,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 +1856,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 +1889,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 +1919,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,