@noetaris/harness 0.6.0 → 0.8.0

package/dist/index.js

@@ -510,7 +510,27 @@ function safeInvoke(hookName, call, sink) {
     reportObserverError(error, { hookName }, sink);
   }
 }
+async function runWrapped(wrap, fn, onObserverError) {
+  let p;
+  const inner = () => {
+    if (p === void 0) {
+      p = new Promise((resolve) => resolve(fn()));
+      p.catch(() => {
+      });
+    }
+    return p;
+  };
+  try {
+    await wrap(inner);
+  } catch (e) {
+    const started = p;
+    const passedThrough = started !== void 0 && await started.then(() => false, (err) => err === e);
+    if (!passedThrough) reportObserverError(e, { hookName: "wrap" }, onObserverError);
+  }
+  return inner();
+}
 function composeObservers(observers, onObserverError) {
+  const wrappers = observers.filter((o) => o.wrap !== void 0);
   return {
     onRunStart: (ctx) => {
       for (const o of observers) safeInvoke("onRunStart", () => o.onRunStart?.(ctx), onObserverError);
@@ -535,6 +555,11 @@ function composeObservers(observers, onObserverError) {
     },
     onStepSettled: (ctx, event) => {
       for (const o of observers) safeInvoke("onStepSettled", () => o.onStepSettled?.(ctx, event), onObserverError);
+    },
+    // First observer outermost; each layer isolated on its own by runWrapped.
+    wrap: (ctx, scope, fn) => {
+      const layer = (i) => i === wrappers.length ? fn() : runWrapped((inner) => wrappers[i].wrap(ctx, scope, inner), () => layer(i + 1), onObserverError);
+      return layer(0);
     }
   };
 }
@@ -588,6 +613,21 @@ function extractRunListeners(resources) {
   return raw;
 }
 
+// src/agent/ctx-within.ts
+function createWithinFn(observer, currentStep, onObserverError) {
+  return (type, payload, fn) => {
+    const wrap = observer?.wrap;
+    const stepCtx = currentStep();
+    if (wrap === void 0 || stepCtx === null) return fn();
+    return runWrapped((inner) => wrap(stepCtx, { kind: "event", type, payload }, inner), fn, onObserverError);
+  };
+}
+function runStepScope(observer, stepCtx, fn, onObserverError) {
+  const wrap = observer?.wrap;
+  if (wrap === void 0) return fn();
+  return runWrapped((inner) => wrap(stepCtx, { kind: "step" }, inner), fn, onObserverError);
+}
+
 // src/loop/loop-executor.ts
 var NOOP_OBSERVER = {};
 function isForkCursor(cursor) {
@@ -654,6 +694,15 @@ function fireSettled(obs, stepCtx, stepStart, fields, onObserverError) {
   const event = { ...fields, durationMs: Date.now() - stepStart };
   safeInvoke("onStepSettled", () => hook(stepCtx, event), onObserverError);
 }
+function stepContextOf(runCtx, stepName) {
+  return {
+    agentId: runCtx.agentId,
+    sessionId: runCtx.sessionId,
+    runId: runCtx.runId,
+    stepName,
+    ...runCtx.branchPath !== void 0 ? { branchPath: runCtx.branchPath } : {}
+  };
+}
 function asError(e) {
   return e instanceof Error ? e : new Error(String(e));
 }
@@ -675,165 +724,178 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
     ...callbacks?.branchPath !== void 0 && callbacks.branchPath.length > 0 ? { branchPath: callbacks.branchPath } : {}
   };
   safeInvoke("onRunStart", () => obs?.onRunStart?.(runCtx), onObserverError);
+  let runEnded = false;
+  const endRun = (signal, failure) => {
+    runEnded = true;
+    const event = { signal, durationMs: Date.now() - runStart, ...failure !== void 0 ? { error: failure.error } : {} };
+    safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, event), onObserverError);
+  };
   const callCountRef = { current: 0 };
   const stepCtxRef = { current: null };
   ctx["interrupt"] = createInterruptFn(state, callCountRef, callbacks?.branchPath);
   ctx["emit"] = createEmitFn(callbacks?.listeners ?? {}, obs, stepCtxRef, onObserverError);
+  ctx["within"] = createWithinFn(obs, () => stepCtxRef.current, onObserverError);
+  const telemetryObserver = obs !== void 0 ? composeObservers([obs], onObserverError) : NOOP_OBSERVER;
   let cursor = startCursor ?? graph.entryStep;
-  while (true) {
-    if (shouldStop?.()) {
-      safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, { signal: "$stopped", durationMs: Date.now() - runStart }), onObserverError);
-      return { state, signal: null, cursor, paused: true };
-    }
-    if (isForkCursor(cursor)) {
-      const forkCursor = cursor;
-      const forkNode = graph.steps.find((s) => s.name === forkCursor.fork);
-      if (!isForkDef(forkNode)) {
-        throw new NoNextStepError(forkCursor.fork);
-      }
-      onBeforeStep?.(forkNode.name, { ...state });
-      const outcome = await handleFork(
-        forkNode,
-        forkCursor.branches,
-        state,
-        ctx,
-        schema,
-        shouldStop,
-        callbacks,
-        obs,
-        runCtx,
-        runStart,
-        implicitNextMap,
-        graph
-      );
-      if (outcome.done) {
-        return outcome.result;
-      }
-      cursor = outcome.nextCursor;
-      continue;
-    }
-    onBeforeStep?.(cursor, { ...state });
-    const node = graph.steps.find((s) => s.name === cursor);
-    if (isForkDef(node)) {
-      const outcome = await handleFork(
-        node,
-        void 0,
-        state,
-        ctx,
-        schema,
-        shouldStop,
-        callbacks,
-        obs,
-        runCtx,
-        runStart,
-        implicitNextMap,
-        graph
-      );
-      if (outcome.done) {
-        return outcome.result;
-      }
-      cursor = outcome.nextCursor;
-      continue;
-    }
-    const step = node;
-    callCountRef.current = 0;
-    const stepCtx = {
-      agentId: ctx.agentId,
-      sessionId: ctx.sessionId,
-      stepName: cursor,
-      ...callbacks?.branchPath !== void 0 && callbacks.branchPath.length > 0 ? { branchPath: callbacks.branchPath } : {}
-    };
-    stepCtxRef.current = stepCtx;
-    const stepStart = Date.now();
-    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);
+  try {
+    while (true) {
+      if (shouldStop?.()) {
+        endRun("$stopped");
+        return { state, signal: null, cursor, paused: true };
       }
-    }
-    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 {
-        const update = await step.run(
+      if (isForkCursor(cursor)) {
+        const forkCursor = cursor;
+        const forkNode = graph.steps.find((s) => s.name === forkCursor.fork);
+        if (!isForkDef(forkNode)) {
+          throw new NoNextStepError(forkCursor.fork);
+        }
+        onBeforeStep?.(forkNode.name, { ...state });
+        const outcome = await handleFork(
+          forkNode,
+          forkCursor.branches,
           state,
-          ctx
+          ctx,
+          schema,
+          shouldStop,
+          callbacks,
+          obs,
+          runCtx,
+          endRun,
+          implicitNextMap,
+          graph
         );
-        applyUpdate(state, update, schema, callbacks?.touchedKeys);
-        applied = update;
-        if (hadResponses) {
-          state.$interrupt = null;
-          state.$interruptResponses = {};
+        if (outcome.done) {
+          return outcome.result;
         }
-        runSucceeded = true;
-      } catch (e) {
-        if (isInterruptPause(e)) {
-          onInterrupt?.(e.prompt, e.interruptId);
-          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 };
+        cursor = outcome.nextCursor;
+        continue;
+      }
+      onBeforeStep?.(cursor, { ...state });
+      const node = graph.steps.find((s) => s.name === cursor);
+      if (isForkDef(node)) {
+        const outcome = await handleFork(
+          node,
+          void 0,
+          state,
+          ctx,
+          schema,
+          shouldStop,
+          callbacks,
+          obs,
+          runCtx,
+          endRun,
+          implicitNextMap,
+          graph
+        );
+        if (outcome.done) {
+          return outcome.result;
         }
-        state.$error = e instanceof Error ? e : new Error(String(e));
-        onError?.(state.$error, cursor);
-        safeInvoke("onStepError", () => obs?.onStepError?.(stepCtx, { error: state.$error, durationMs: Date.now() - stepStart }), onObserverError);
+        cursor = outcome.nextCursor;
+        continue;
       }
-    }
-    if (runSucceeded) {
-      state.$error = null;
-      onAfterStep?.(cursor, state);
-      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) {
-      const routeFn = step.route;
-      let signal;
-      try {
-        signal = routeFn(state);
-      } catch (e) {
-        state.$error = e instanceof Error ? e : new Error(String(e));
-        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 step = node;
+      callCountRef.current = 0;
+      const stepCtx = stepContextOf(runCtx, cursor);
+      stepCtxRef.current = stepCtx;
+      const stepStart = Date.now();
+      safeInvoke("onStepStart", () => obs?.onStepStart?.(stepCtx), onObserverError);
+      if (callbacks?.telemetrySlots !== void 0) {
+        const telemetry = {
+          observer: telemetryObserver,
+          stepContext: stepCtx,
+          within: createWithinFn(obs, () => stepCtx, onObserverError)
+        };
+        for (const { key, slot } of callbacks.telemetrySlots) {
+          ;
+          ctx[key] = slot.withTelemetry(telemetry);
+        }
       }
-      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) {
-        const unknownSignal = new UnknownSignalError(cursor, signal);
-        settle({ outcome: "error", signal, error: unknownSignal, next: { kind: "throw" } });
-        throw unknownSignal;
+      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 {
+          const run = step.run;
+          const update = await runStepScope(obs, stepCtx, () => run(
+            state,
+            ctx
+          ), onObserverError);
+          applyUpdate(state, update, schema, callbacks?.touchedKeys);
+          applied = update;
+          if (hadResponses) {
+            state.$interrupt = null;
+            state.$interruptResponses = {};
+          }
+          runSucceeded = true;
+        } catch (e) {
+          if (isInterruptPause(e)) {
+            onInterrupt?.(e.prompt, e.interruptId);
+            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" } });
+            endRun("$interrupt");
+            return { state, signal: "$interrupt", cursor, paused: true };
+          }
+          state.$error = e instanceof Error ? e : new Error(String(e));
+          onError?.(state.$error, cursor);
+          safeInvoke("onStepError", () => obs?.onStepError?.(stepCtx, { error: state.$error, durationMs: Date.now() - stepStart }), onObserverError);
+        }
       }
-      if (transition.target.kind === "end") {
-        settle({ ...routed, next: { kind: "end" } });
-        onComplete?.(state, signal);
-        safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, { signal, durationMs: Date.now() - runStart }), onObserverError);
-        return { state, signal, cursor: null, paused: false };
+      if (runSucceeded) {
+        state.$error = null;
+        onAfterStep?.(cursor, state);
+        safeInvoke("onStepEnd", () => obs?.onStepEnd?.(stepCtx, { durationMs: Date.now() - stepStart }), onObserverError);
       }
-      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;
+      const callRoute = step.route !== void 0 && (runSucceeded || step.run === void 0 || step.errorAware);
+      if (callRoute) {
+        const routeFn = step.route;
+        let signal;
+        try {
+          signal = routeFn(state);
+        } catch (e) {
+          state.$error = e instanceof Error ? e : new Error(String(e));
+          settle({ outcome: "error", error: state.$error, next: { kind: "pause" } });
+          endRun("$error", { error: state.$error });
+          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) {
+          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);
+          endRun(signal);
+          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 {
+          settle({ outcome: "error", error: state.$error, next: { kind: "pause" } });
+          endRun("$error", { error: state.$error });
+          return { state, signal: "$error", cursor, paused: true };
+        }
       } else {
-        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) {
-        const noNext = new NoNextStepError(cursor);
-        settle({ outcome: "error", error: noNext, next: { kind: "throw" } });
-        throw noNext;
+        const next = step.next ?? implicitNextMap.get(cursor) ?? null;
+        if (next === null) {
+          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;
       }
-      settle({ outcome: "ok", next: { kind: "step", name: next } });
-      cursor = next;
     }
+  } catch (e) {
+    if (!runEnded) endRun("$error", { error: e });
+    throw e;
   }
 }
 async function runBranch(branch, prior, outerState, outerCtx, schema, shouldStop, branchSignal, branchCallbacks) {
@@ -941,13 +1003,8 @@ async function dispatchFork(forkNode, priorBranches, outerState, outerCtx, schem
     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 = {
-    agentId: ctx.agentId,
-    sessionId: ctx.sessionId,
-    stepName: forkNode.name,
-    ...callbacks?.branchPath !== void 0 && callbacks.branchPath.length > 0 ? { branchPath: callbacks.branchPath } : {}
-  };
+async function handleFork(forkNode, priorBranches, state, ctx, schema, shouldStop, callbacks, obs, runCtx, endRun, implicitNextMap, graph) {
+  const stepCtx = stepContextOf(runCtx, forkNode.name);
   const stepStart = Date.now();
   const onObserverError = callbacks?.onObserverError;
   safeInvoke("onStepStart", () => obs?.onStepStart?.(stepCtx), onObserverError);
@@ -964,11 +1021,11 @@ async function handleFork(forkNode, priorBranches, state, ctx, schema, shouldSto
     };
     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);
+      endRun("$interrupt");
       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);
+    endRun("$stopped");
     return { done: true, result: { state, signal: null, cursor: dispatch.forkCursor, paused: true } };
   }
   if (dispatch.kind === "failed") {
@@ -980,7 +1037,7 @@ async function handleFork(forkNode, priorBranches, state, ctx, schema, shouldSto
       return { done: false, nextCursor: graph.onError };
     }
     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);
+    endRun("$error", { error: state.$error });
     return { done: true, result: { state, signal: "$error", cursor: forkNode.name, paused: true } };
   }
   state.$error = null;