@noetaris/harness 0.5.0 → 0.7.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);
@@ -532,6 +552,14 @@ function composeObservers(observers, 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);
+    },
+    // 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);
     }
   };
 }
@@ -585,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) {
@@ -645,6 +688,24 @@ 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 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));
+}
 async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callbacks) {
   const { onBeforeStep, onAfterStep, onError, onComplete, onInterrupt } = callbacks ?? {};
   const obs = callbacks?.observer;
@@ -663,150 +724,177 @@ 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) => {
+    runEnded = true;
+    safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, { signal, durationMs: Date.now() - runStart }), 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;
-    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);
-        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);
-          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));
-        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 transition = step.transitions.find((t) => t.signal === signal);
-      if (transition === void 0) {
-        throw new UnknownSignalError(cursor, signal);
+      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") {
-        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);
       }
-      cursor = transition.target.name;
-    } else if (step.run !== void 0 && !runSucceeded) {
-      if (graph.onError !== void 0) {
-        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");
+          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");
+          return { state, signal: "$error", cursor, paused: true };
+        }
       } else {
-        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 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;
       }
-      cursor = next;
     }
+  } catch (e) {
+    if (!runEnded) endRun("$error");
+    throw e;
   }
 }
 async function runBranch(branch, prior, outerState, outerCtx, schema, shouldStop, branchSignal, branchCallbacks) {
@@ -842,16 +930,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 };
@@ -875,7 +972,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) {
@@ -899,31 +997,46 @@ async function dispatchFork(forkNode, priorBranches, outerState, outerCtx, schem
       }
     }
   }
-  return { kind: "success" };
-}
-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 } : {}
+  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, endRun, implicitNextMap, graph) {
+  const stepCtx = stepContextOf(runCtx, forkNode.name);
   const stepStart = Date.now();
   const onObserverError = callbacks?.onObserverError;
   safeInvoke("onStepStart", () => obs?.onStepStart?.(stepCtx), onObserverError);
-  const dispatch = await dispatchFork(forkNode, priorBranches, state, ctx, schema, shouldStop, callbacks);
+  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") {
-    safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, { signal: "$interrupt", durationMs: Date.now() - runStart }), onObserverError);
-    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);
+      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);
+    endRun("$stopped");
+    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);
     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 };
     }
-    safeInvoke("onRunEnd", () => obs?.onRunEnd?.(runCtx, { signal: "$error", durationMs: Date.now() - runStart }), onObserverError);
+    fireSettled(obs, stepCtx, stepStart, { outcome: "error", error: state.$error, next: { kind: "pause" } }, onObserverError);
+    endRun("$error");
     return { done: true, result: { state, signal: "$error", cursor: forkNode.name, paused: true } };
   }
   state.$error = null;
@@ -931,8 +1044,11 @@ async function handleFork(forkNode, priorBranches, state, ctx, schema, shouldSto
   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 };
 }