@noetaris/harness 0.9.0 → 0.10.0

package/README.md

@@ -157,11 +157,12 @@ const resumed = agent.resume(response, sessionId, interruptId)
 ```
 
 `agent.resume()` takes an optional fourth argument with these reserved resources (a subset of
-`run()`'s): `observer`, `onObserverError`, `events: { onStoreError }`, and `parentRunId` (the caller's run id,
-for a sub agent resumed from a step). `parentRunId` applies to that resumed run only: calling
+`run()`'s): `observer`, `onObserverError`, `events: { onStoreError }`, `parentRunId` (the caller's run id,
+for a sub agent resumed from a step), and `claimOptions`. `parentRunId` applies to that resumed run only: calling
 `resume()` again on the handle it returns keeps the other resources but not `parentRunId`, which
 is stale by then. With a store, both `agent.resume()` and `run.resume()` record the agent's
-`instanceId` in the resumed run's `metadata`.
+`instanceId` in the resumed run's `metadata` and, when the store supports claims, claim the
+session for the resumed run; a `resume()` on the returned handle reuses the same claim TTL.
 
 **Resume replays the interrupted step from the top.** On resume, the step that called
 `ctx.interrupt()` runs again from its first line; each `ctx.interrupt()` call it reaches
@@ -410,7 +411,7 @@ The harness never trusts a wrapper. `fn` always runs exactly once, and the calle
 | Export | Description |
 |---|---|
 | `createHarness<Ctx>()(schema)` | Creates a harness. Fixes `Ctx`, infers `State` from schema. |
-| `createAgent(id, h, slots)` | Assigns the agent an ID and fills `required()` slots. Returns an `Agent`. |
+| `createAgent(id, h, slots, options?)` | Assigns the agent an ID and fills `required()` slots. `options` (`AgentOptions`) takes `instanceId`, `stores` (for `required()` store slots) and `claimOptions` (this agent's default claim TTL; per-call `claimOptions` wins, then `HARNESS_CLAIM_TTL_MS`, then 30 000 ms). Returns an `Agent`. |
 | `field<T>(opts)` | Declares a state field with a default and optional reduce function. |
 | `required()` | Marks a provider slot as required at `createAgent()`. |
 | `runtime()` | Marks a provider slot as required at `agent.run()`. |

package/dist/index.d.ts

@@ -1045,6 +1045,12 @@ interface AgentOptions {
      * Keyed by the store key used in the harness (e.g. `{ session: myStore }`).
      */
     readonly stores?: Record<string, unknown>;
+    /**
+     * Default claim options for every run and resume of this agent, used when the call passes none.
+     * Resolution: per-call `claimOptions` → this → `HARNESS_CLAIM_TTL_MS` → 30 000 ms.
+     * `ttlMs` must be a finite number greater than 0; otherwise `createAgent` throws `InvalidClaimOptionsError`.
+     */
+    readonly claimOptions?: ClaimOptions;
 }
 interface Agent {
     /** The agent's unique identifier, as provided to createAgent(). */
@@ -1062,6 +1068,9 @@ interface Agent {
      * - `parentRunId?: string` — the caller's run id, as for `run()`; set on this resumed run's
      *   `RunContext` only (a later `handle.resume()` on the returned handle does not inherit it)
      * - `events?.onStoreError?` — raw store-error callback (unchanged from prior shape)
+     * - `claimOptions?: ClaimOptions` — claim TTL for this resume, parsed like `agent.run()`'s; falls back
+     *   to `AgentOptions.claimOptions`, then `HARNESS_CLAIM_TTL_MS`, then 30 000 ms. A later `handle.resume()`
+     *   on the returned handle reuses it
      */
     resume(response: unknown, sessionId: string, interruptId: string, resources?: Record<string, unknown>): RunHandle;
     /**
@@ -1165,4 +1174,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, type ObserverErrorContext, type ObserverErrorSink, REQUIRED_TAG, RUNTIME_TAG, type RequiredMarker, type RouteFn, type RunCarrier, type RunContext, type RunFn, type RunRef, type RuntimeMarker, SessionBusyError, SessionInFlightError, SessionPendingInterruptError, type SessionStore, type SignalTransition, type StateFromSchema, type StepContext, type StepDef, type StepSettledEvent, type StepSettledNext, type StepState, StoreLoadError, type StoredRun, type StoredRunMetadata, type TelemetryContext, type TransitionTarget, type WrapScope, composeObservers, createAgent, createHarness, field, isForkCursor, isForkDef, isRequiredMarker, isRuntimeMarker, required, runtime };
+export { type Agent, type AgentOptions, 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 RunCarrier, type RunContext, type RunFn, type RunRef, type RuntimeMarker, SessionBusyError, SessionInFlightError, SessionPendingInterruptError, type SessionStore, type SignalTransition, type StateFromSchema, type StepContext, type StepDef, type StepSettledEvent, type StepSettledNext, type StepState, StoreLoadError, type StoredRun, type StoredRunMetadata, type TelemetryContext, type TransitionTarget, type WrapScope, composeObservers, createAgent, createHarness, field, isForkCursor, isForkDef, isRequiredMarker, isRuntimeMarker, required, runtime };

package/dist/index.js

@@ -1084,6 +1084,13 @@ async function handleFork(forkNode, priorBranches, state, ctx, schema, shouldSto
 }
 
 // src/agent/session-store.ts
+function isValidTtlMs(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function defaultClaimTtlMs() {
+  const ttlMs = Number(process.env["HARNESS_CLAIM_TTL_MS"]);
+  return isValidTtlMs(ttlMs) ? ttlMs : 3e4;
+}
 function collectPendingInterrupts(cursor, state) {
   if (cursor !== void 0 && isForkCursor(cursor)) {
     const result = [];
@@ -1288,7 +1295,7 @@ function runRefsOf(loaded) {
 }
 async function runWithSession(store, agentId, sessionId, runId, graph, initialStateArg, schema, ctx, options) {
   const leaseRef = options?.leaseRef ?? { current: null };
-  const keepAlive = createKeepAliveFn(leaseRef, store, options?.claimTtlMs ?? 3e4);
+  const keepAlive = createKeepAliveFn(leaseRef, store, options?.claimTtlMs ?? defaultClaimTtlMs());
   ctx["keepAlive"] = keepAlive;
   let leaseExpired = false;
   const composedShouldStop = () => {
@@ -1389,6 +1396,50 @@ async function runWithSession(store, agentId, sessionId, runId, graph, initialSt
   return result;
 }
 
+// src/agent/claim-scope.ts
+function failOutcome(failState, error) {
+  const state = failState();
+  state["$error"] = error;
+  return { state, signal: "$error" };
+}
+async function runClaimed(args) {
+  const { store, agentId, sessionId, claimOptions, onStoreError, failState, body } = args;
+  const fail = (error) => failOutcome(failState, error);
+  let leaseRef = void 0;
+  if (typeof store?.claim === "function") {
+    let lease;
+    try {
+      lease = await store.claim(agentId, sessionId, claimOptions);
+    } catch (claimError) {
+      const loadError = new StoreLoadError(claimError);
+      onStoreError?.(loadError, "claim");
+      return fail(loadError);
+    }
+    if (lease === null) {
+      const busyError = new SessionBusyError(sessionId);
+      onStoreError?.(busyError, "claim");
+      return fail(busyError);
+    }
+    leaseRef = { current: lease };
+  }
+  try {
+    return await body(leaseRef !== void 0 ? { leaseRef, claimTtlMs: claimOptions.ttlMs } : {});
+  } catch (error) {
+    if (error instanceof LeaseExpiredError) return fail(error);
+    throw error;
+  } finally {
+    if (leaseRef !== void 0 && typeof store?.release === "function") {
+      try {
+        await store.release(leaseRef.current);
+      } catch {
+      }
+    }
+  }
+}
+function parseClaimOptions(raw, fallback) {
+  return typeof raw === "object" && raw !== null && typeof raw["ttlMs"] === "number" ? raw : fallback;
+}
+
 // src/agent/interrupt-resume.ts
 var NoInterruptError = class extends Error {
   constructor() {
@@ -1463,6 +1514,18 @@ async function injectInterruptResponse(store, agentId, sessionId, interruptId, r
   };
   await store.save(agentId, sessionId, updated);
 }
+async function injectThenRun(args) {
+  const { store, agentId, sessionId, interruptId, response, onStoreError, failState, run } = args;
+  try {
+    await injectInterruptResponse(store, agentId, sessionId, interruptId, response);
+  } catch (injectError) {
+    if (injectError instanceof NoInterruptError) throw injectError;
+    const storeError = new StoreLoadError(injectError);
+    onStoreError?.(storeError, "claim");
+    return failOutcome(failState, storeError);
+  }
+  return run();
+}
 
 // src/agent/run-handle.ts
 function createRunHandle(sessionId, runId, execution, stopFlag, stepRef, resumeFn) {
@@ -1622,6 +1685,18 @@ var UnexpectedStoreSlotError = class extends Error {
     this.key = key;
   }
 };
+function describeValue(value) {
+  return typeof value === "string" ? JSON.stringify(value) : String(value);
+}
+var InvalidClaimOptionsError = class extends Error {
+  /** The rejected `ttlMs` value, as given. */
+  ttlMs;
+  constructor(ttlMs) {
+    super(`claimOptions.ttlMs must be a finite number of milliseconds greater than 0 \u2014 got ${describeValue(ttlMs)} in createAgent options`);
+    this.name = "InvalidClaimOptionsError";
+    this.ttlMs = ttlMs;
+  }
+};
 var _agentInternals = /* @__PURE__ */ Symbol("_agentInternals");
 function createAgent(id, h, slots, agentOptions) {
   const internals = getInternals(h);
@@ -1652,6 +1727,13 @@ function createAgent(id, h, slots, agentOptions) {
       }
     }
   }
+  let agentClaimOptions = void 0;
+  if (agentOptions?.claimOptions !== void 0) {
+    const ttlMs = agentOptions.claimOptions?.ttlMs;
+    if (!isValidTtlMs(ttlMs)) throw new InvalidClaimOptionsError(ttlMs);
+    agentClaimOptions = { ttlMs };
+  }
+  const fallbackClaimOptions = () => agentClaimOptions ?? { ttlMs: defaultClaimTtlMs() };
   const resolvedProviders = /* @__PURE__ */ new Map();
   const storeEntries = [];
   const runtimeKeys = /* @__PURE__ */ new Set();
@@ -1704,8 +1786,9 @@ function createAgent(id, h, slots, agentOptions) {
   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, resumeResources = {}) => {
-    const { onStoreError, observer, onObserverError, telemetrySlots, parentRunId } = resumeResources;
+  const resumeFailState = () => initializeState(null, {}, agentInternals.stateSchema);
+  const makeAgentResumeHandle = (resp, sId, iId, resumeResources) => {
+    const { onStoreError, observer, onObserverError, telemetrySlots, parentRunId, claimOptions } = resumeResources;
     let _stopped = false;
     const abortController = new AbortController();
     const flag = {
@@ -1721,89 +1804,63 @@ function createAgent(id, h, slots, agentOptions) {
     const rId = randomUUID();
     const exec = (async () => {
       await Promise.resolve();
-      const claimOptions = { ttlMs: 3e4 };
-      let leaseRef = void 0;
       try {
-        if (typeof capturedStore?.claim === "function") {
-          let lease;
-          try {
-            lease = await capturedStore.claim(id, sId, claimOptions);
-          } catch (claimError) {
-            const loadError = new StoreLoadError(claimError);
-            onStoreError?.(loadError, "claim");
-            const failState = initializeState(null, {}, agentInternals.stateSchema);
-            failState["$error"] = loadError;
-            return { state: failState, signal: "$error" };
-          }
-          if (lease === null) {
-            const busyError = new SessionBusyError(sId);
-            onStoreError?.(busyError, "claim");
-            const failState = initializeState(null, {}, agentInternals.stateSchema);
-            failState["$error"] = busyError;
-            return { state: failState, signal: "$error" };
-          }
-          leaseRef = { current: lease };
-        }
-        try {
-          if (capturedStore === void 0) throw new NoInterruptError();
-          try {
-            await injectInterruptResponse(capturedStore, id, sId, iId, resp);
-          } catch (injectError) {
-            if (injectError instanceof NoInterruptError) throw injectError;
-            const storeError = new StoreLoadError(injectError);
-            onStoreError?.(storeError, "claim");
-            const failState = initializeState(null, {}, agentInternals.stateSchema);
-            failState["$error"] = storeError;
-            return { state: failState, signal: "$error" };
-          }
-          const agentCtx = {
-            ...Object.fromEntries(agentInternals.resolvedProviders),
-            agentId: id,
-            sessionId: sId,
-            runId: rId,
-            signal: abortController.signal,
-            ...agentOptions?.instanceId !== void 0 ? { instanceId: agentOptions.instanceId } : {}
-          };
-          const r = await runWithSession(
-            capturedStore,
-            id,
-            sId,
-            rId,
-            agentInternals.loopDef,
-            {},
-            agentInternals.stateSchema,
-            agentCtx,
-            {
-              shouldStop: () => flag.stopped,
-              onBeforeStep: (n) => {
-                ref.current = n;
-              },
+        return await runClaimed({
+          store: capturedStore,
+          agentId: id,
+          sessionId: sId,
+          claimOptions,
+          ...onStoreError !== void 0 ? { onStoreError } : {},
+          failState: resumeFailState,
+          body: async (lease) => {
+            if (capturedStore === void 0) throw new NoInterruptError();
+            const store = capturedStore;
+            return injectThenRun({
+              store,
+              agentId: id,
+              sessionId: sId,
+              interruptId: iId,
+              response: resp,
               ...onStoreError !== void 0 ? { onStoreError } : {},
-              ...leaseRef !== void 0 ? { leaseRef, claimTtlMs: claimOptions.ttlMs } : {},
-              ...observer !== void 0 ? { observer } : {},
-              ...onObserverError !== void 0 ? { onObserverError } : {},
-              ...telemetrySlots !== void 0 && telemetrySlots.length > 0 ? { telemetrySlots } : {},
-              ...agentOptions?.instanceId !== void 0 ? { instanceId: agentOptions.instanceId } : {},
-              ...parentRunId !== void 0 ? { parentRunId } : {}
-            }
-          );
-          if (r.signal === "$interrupt") interruptPendingSessions.add(sId);
-          return { state: r.state, signal: r.signal };
-        } catch (error) {
-          if (error instanceof LeaseExpiredError) {
-            const failState = initializeState(null, {}, agentInternals.stateSchema);
-            failState["$error"] = error;
-            return { state: failState, signal: "$error" };
-          }
-          throw error;
-        } finally {
-          if (leaseRef !== void 0 && typeof capturedStore?.release === "function") {
-            try {
-              await capturedStore.release(leaseRef.current);
-            } catch {
-            }
+              failState: resumeFailState,
+              run: async () => {
+                const agentCtx = {
+                  ...Object.fromEntries(agentInternals.resolvedProviders),
+                  agentId: id,
+                  sessionId: sId,
+                  runId: rId,
+                  signal: abortController.signal,
+                  ...agentOptions?.instanceId !== void 0 ? { instanceId: agentOptions.instanceId } : {}
+                };
+                const r = await runWithSession(
+                  store,
+                  id,
+                  sId,
+                  rId,
+                  agentInternals.loopDef,
+                  {},
+                  agentInternals.stateSchema,
+                  agentCtx,
+                  {
+                    shouldStop: () => flag.stopped,
+                    onBeforeStep: (n) => {
+                      ref.current = n;
+                    },
+                    ...onStoreError !== void 0 ? { onStoreError } : {},
+                    ...lease,
+                    ...observer !== void 0 ? { observer } : {},
+                    ...onObserverError !== void 0 ? { onObserverError } : {},
+                    ...telemetrySlots !== void 0 && telemetrySlots.length > 0 ? { telemetrySlots } : {},
+                    ...agentOptions?.instanceId !== void 0 ? { instanceId: agentOptions.instanceId } : {},
+                    ...parentRunId !== void 0 ? { parentRunId } : {}
+                  }
+                );
+                if (r.signal === "$interrupt") interruptPendingSessions.add(sId);
+                return { state: r.state, signal: r.signal };
+              }
+            });
           }
-        }
+        });
       } finally {
         inFlightSessions.delete(sId);
       }
@@ -1887,6 +1944,7 @@ function createAgent(id, h, slots, agentOptions) {
         ...Object.entries(runtimeSlots)
       ]);
       const parentRunId = typeof resources["parentRunId"] === "string" ? resources["parentRunId"] : void 0;
+      const claimOptions = parseClaimOptions(resources["claimOptions"], fallbackClaimOptions());
       const options = {
         shouldStop: () => stopFlag.stopped,
         onBeforeStep: (name, state) => {
@@ -1909,63 +1967,31 @@ function createAgent(id, h, slots, agentOptions) {
       let lastResult = null;
       const execution = (async () => {
         await Promise.resolve();
-        const rawClaimOpts = resources["claimOptions"];
-        const claimOptions = typeof rawClaimOpts === "object" && rawClaimOpts !== null && typeof rawClaimOpts["ttlMs"] === "number" ? rawClaimOpts : { ttlMs: 3e4 };
-        let leaseRef = void 0;
         try {
-          if (typeof capturedStore?.claim === "function") {
-            let lease;
-            try {
-              lease = await capturedStore.claim(id, sessionId, claimOptions);
-            } catch (claimError) {
-              const loadError = new StoreLoadError(claimError);
-              events.onStoreError?.(loadError, "claim");
-              const failState = initializeState(null, initialState, agentInternals.stateSchema);
-              failState["$error"] = loadError;
-              return { state: failState, signal: "$error" };
-            }
-            if (lease === null) {
-              const busyError = new SessionBusyError(sessionId);
-              events.onStoreError?.(busyError, "claim");
-              const failState = initializeState(null, initialState, agentInternals.stateSchema);
-              failState["$error"] = busyError;
-              return { state: failState, signal: "$error" };
-            }
-            leaseRef = { current: lease };
-          }
-          try {
-            const r = await runWithSession(
-              capturedStore,
-              id,
-              sessionId,
-              runId,
-              agentInternals.loopDef,
-              initialState,
-              agentInternals.stateSchema,
-              ctx,
-              {
-                ...options,
-                ...leaseRef !== void 0 ? { leaseRef, claimTtlMs: claimOptions.ttlMs } : {}
-              }
-            );
-            if (r.signal === "$interrupt") interruptPendingSessions.add(sessionId);
-            lastResult = { state: r.state, cursor: r.cursor, runId, ...r.carrier !== void 0 ? { carrier: r.carrier } : {} };
-            return { state: r.state, signal: r.signal };
-          } catch (error) {
-            if (error instanceof LeaseExpiredError) {
-              const failState = initializeState(null, initialState, agentInternals.stateSchema);
-              failState["$error"] = error;
-              return { state: failState, signal: "$error" };
-            }
-            throw error;
-          } finally {
-            if (leaseRef !== void 0 && typeof capturedStore?.release === "function") {
-              try {
-                await capturedStore.release(leaseRef.current);
-              } catch {
-              }
+          return await runClaimed({
+            store: capturedStore,
+            agentId: id,
+            sessionId,
+            claimOptions,
+            ...events.onStoreError !== void 0 ? { onStoreError: events.onStoreError } : {},
+            failState: () => initializeState(null, initialState, agentInternals.stateSchema),
+            body: async (lease) => {
+              const r = await runWithSession(
+                capturedStore,
+                id,
+                sessionId,
+                runId,
+                agentInternals.loopDef,
+                initialState,
+                agentInternals.stateSchema,
+                ctx,
+                { ...options, ...lease }
+              );
+              if (r.signal === "$interrupt") interruptPendingSessions.add(sessionId);
+              lastResult = { state: r.state, cursor: r.cursor, runId, ...r.carrier !== void 0 ? { carrier: r.carrier } : {} };
+              return { state: r.state, signal: r.signal };
             }
-          }
+          });
         } finally {
           inFlightSessions.delete(sessionId);
         }
@@ -1997,38 +2023,59 @@ function createAgent(id, h, slots, agentOptions) {
                 signal: resumeAbortController.signal
               };
               if (capturedStore !== void 0) {
-                await injectInterruptResponse(capturedStore, id, sessionId, interruptId, response);
-                const r2 = await runWithSession(
-                  capturedStore,
-                  id,
+                const store = capturedStore;
+                const onStoreError = events.onStoreError;
+                return await runClaimed({
+                  store,
+                  agentId: id,
                   sessionId,
-                  resumeRunId,
-                  agentInternals.loopDef,
-                  {},
-                  agentInternals.stateSchema,
-                  resumeCtx,
-                  {
-                    shouldStop: () => resumeStopFlag.stopped,
-                    onBeforeStep: (n, s) => {
-                      resumeStepRef.current = n;
-                      events.onBeforeStep?.(n, s);
-                    },
-                    // spread optional event callbacks only when defined (exactOptionalPropertyTypes requires omission, not undefined)
-                    ...events.onStoreError !== void 0 ? { onStoreError: events.onStoreError } : {},
-                    ...events.onAfterStep !== void 0 ? { onAfterStep: events.onAfterStep } : {},
-                    ...events.onError !== void 0 ? { onError: events.onError } : {},
-                    ...events.onComplete !== void 0 ? { onComplete: events.onComplete } : {},
-                    ...events.onInterrupt !== void 0 ? { onInterrupt: events.onInterrupt } : {},
-                    ...Object.keys(listeners).length > 0 ? { listeners } : {},
-                    ...observer !== void 0 ? { observer } : {},
-                    ...onObserverError !== void 0 ? { onObserverError } : {},
-                    ...telemetrySlots.length > 0 ? { telemetrySlots } : {},
-                    ...agentOptions?.instanceId !== void 0 ? { instanceId: agentOptions.instanceId } : {}
-                  }
-                );
-                if (r2.signal === "$interrupt") interruptPendingSessions.add(sessionId);
-                lastResult = { state: r2.state, cursor: r2.cursor, runId: resumeRunId, ...r2.carrier !== void 0 ? { carrier: r2.carrier } : {} };
-                return { state: r2.state, signal: r2.signal };
+                  claimOptions,
+                  ...onStoreError !== void 0 ? { onStoreError } : {},
+                  failState: resumeFailState,
+                  body: (lease) => injectThenRun({
+                    store,
+                    agentId: id,
+                    sessionId,
+                    interruptId,
+                    response,
+                    ...onStoreError !== void 0 ? { onStoreError } : {},
+                    failState: resumeFailState,
+                    run: async () => {
+                      const r2 = await runWithSession(
+                        store,
+                        id,
+                        sessionId,
+                        resumeRunId,
+                        agentInternals.loopDef,
+                        {},
+                        agentInternals.stateSchema,
+                        resumeCtx,
+                        {
+                          shouldStop: () => resumeStopFlag.stopped,
+                          onBeforeStep: (n, s) => {
+                            resumeStepRef.current = n;
+                            events.onBeforeStep?.(n, s);
+                          },
+                          // spread optional event callbacks only when defined (exactOptionalPropertyTypes requires omission, not undefined)
+                          ...events.onStoreError !== void 0 ? { onStoreError: events.onStoreError } : {},
+                          ...events.onAfterStep !== void 0 ? { onAfterStep: events.onAfterStep } : {},
+                          ...events.onError !== void 0 ? { onError: events.onError } : {},
+                          ...events.onComplete !== void 0 ? { onComplete: events.onComplete } : {},
+                          ...events.onInterrupt !== void 0 ? { onInterrupt: events.onInterrupt } : {},
+                          ...Object.keys(listeners).length > 0 ? { listeners } : {},
+                          ...observer !== void 0 ? { observer } : {},
+                          ...onObserverError !== void 0 ? { onObserverError } : {},
+                          ...telemetrySlots.length > 0 ? { telemetrySlots } : {},
+                          ...agentOptions?.instanceId !== void 0 ? { instanceId: agentOptions.instanceId } : {},
+                          ...lease
+                        }
+                      );
+                      if (r2.signal === "$interrupt") interruptPendingSessions.add(sessionId);
+                      lastResult = { state: r2.state, cursor: r2.cursor, runId: resumeRunId, ...r2.carrier !== void 0 ? { carrier: r2.carrier } : {} };
+                      return { state: r2.state, signal: r2.signal };
+                    }
+                  })
+                });
               }
               const prev = lastResult;
               if (prev === null) throw new NoInterruptError();
@@ -2063,13 +2110,6 @@ function createAgent(id, h, slots, agentOptions) {
               if (r.signal === "$interrupt") interruptPendingSessions.add(sessionId);
               lastResult = { state: r.state, cursor: r.cursor, runId: resumeRunId, ...r.carrier !== void 0 ? { carrier: r.carrier } : {} };
               return { state: r.state, signal: r.signal };
-            } catch (error) {
-              if (error instanceof LeaseExpiredError) {
-                const failState = initializeState(null, initialState, agentInternals.stateSchema);
-                failState["$error"] = error;
-                return { state: failState, signal: "$error" };
-              }
-              throw error;
             } finally {
               inFlightSessions.delete(sessionId);
             }
@@ -2088,7 +2128,9 @@ function createAgent(id, h, slots, agentOptions) {
       const onObserverError = extractRunErrorSink(resources ?? {});
       const telemetrySlots = buildTelemetrySlots(agentInternals.resolvedProviders.entries());
       const parentRunId = resources?.["parentRunId"];
+      const claimOptions = parseClaimOptions(resources?.["claimOptions"], fallbackClaimOptions());
       return makeAgentResumeHandle(response, sessionId, interruptId, {
+        claimOptions,
         ...events.onStoreError !== void 0 ? { onStoreError: events.onStoreError } : {},
         ...observer !== void 0 ? { observer } : {},
         ...onObserverError !== void 0 ? { onObserverError } : {},