@noetaris/harness 0.9.0 → 0.11.0

package/dist/index.js

@@ -745,11 +745,13 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
     sessionId: ctx.sessionId,
     runId: typeof callbacks?.runId === "string" ? callbacks.runId : "",
     ...typeof callbacks?.parentRunId === "string" ? { parentRunId: callbacks.parentRunId } : {},
+    ...typeof callbacks?.requestId === "string" ? { requestId: callbacks.requestId } : {},
     ...typeof ctx.instanceId === "string" ? { instanceId: ctx.instanceId } : {},
     ...isBranch ? { branchPath } : {},
     // Branch runLoops receive the outer callbacks by spread, so the refs are dropped here.
     ...!isBranch && callbacks?.resumedFrom !== void 0 ? { resumedFrom: callbacks.resumedFrom } : {},
-    ...!isBranch && callbacks?.branchedFrom !== void 0 ? { branchedFrom: callbacks.branchedFrom } : {}
+    ...!isBranch && callbacks?.branchedFrom !== void 0 ? { branchedFrom: callbacks.branchedFrom } : {},
+    ...!isBranch && callbacks?.continuedFrom !== void 0 ? { continuedFrom: callbacks.continuedFrom } : {}
   };
   safeInvoke("onRunStart", () => obs?.onRunStart?.(runCtx), onObserverError);
   const carrier = isBranch ? void 0 : normalizeCarrier(safeCall("carry", () => obs?.carry?.(runCtx), onObserverError));
@@ -1084,6 +1086,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 = [];
@@ -1280,15 +1289,35 @@ async function querySessionPhase(store, agentId, sessionId) {
   return storedSessionToPhase(loaded);
 }
 function runRefsOf(loaded) {
-  if (loaded === null || loaded.phase !== "paused") return {};
-  if (loaded.step !== void 0) {
-    return { resumedFrom: { runId: loaded.runId, ...loaded.carrier !== void 0 ? { carrier: loaded.carrier } : {} } };
-  }
+  if (loaded === null) return {};
+  const ref = { runId: loaded.runId, ...loaded.carrier !== void 0 ? { carrier: loaded.carrier } : {} };
+  if (loaded.phase === "completed") return { continuedFrom: ref };
+  if (loaded.step !== void 0) return { resumedFrom: ref };
   return loaded.branchedFrom !== void 0 ? { branchedFrom: loaded.branchedFrom } : {};
 }
+function decideRun(args) {
+  const { loaded, older, mode, requestId, sessionId } = args;
+  if (loaded === null) return { action: "start" };
+  const pending = loaded.phase === "paused" && collectPendingInterrupts(loaded.step, loaded.finalState).length > 0;
+  if (mode === "resume") {
+    return loaded.phase === "completed" ? { action: "replay", row: loaded } : { action: "continue", mergeInput: false };
+  }
+  if (requestId !== void 0 && loaded.requestId === requestId) {
+    if (loaded.phase === "completed" || pending) return { action: "replay", row: loaded };
+    return { action: "continue", mergeInput: false };
+  }
+  if (older !== null) return { action: "replay", row: older };
+  if (loaded.phase === "completed") return { action: "new-turn" };
+  if (pending) return { action: "reject", error: new SessionPendingInterruptError(sessionId) };
+  return { action: "continue", mergeInput: true };
+}
+function withoutSystemFields(loaded) {
+  const { $error: _error, $interrupt: _interrupt, $interruptResponses: _responses, ...finalState } = loaded.finalState;
+  return { ...loaded, finalState };
+}
 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 = () => {
@@ -1299,10 +1328,11 @@ async function runWithSession(store, agentId, sessionId, runId, graph, initialSt
     }
     return false;
   };
+  const { mode = "run", requestId: callerRequestId, ...loopOptions } = options ?? {};
   if (store === void 0) {
     const state2 = initializeState(null, initialStateArg, schema);
     const result2 = await runLoop(graph, state2, ctx, schema, composedShouldStop, void 0, {
-      ...options,
+      ...loopOptions,
       runId,
       ...options?.parentRunId !== void 0 ? { parentRunId: options.parentRunId } : {}
     });
@@ -1313,31 +1343,46 @@ async function runWithSession(store, agentId, sessionId, runId, graph, initialSt
     }
     return result2;
   }
+  const requestId = mode === "run" ? callerRequestId : void 0;
+  const fail = (error) => {
+    const failState = initializeState(null, initialStateArg, schema);
+    failState["$error"] = error;
+    return { state: failState, signal: "$error", paused: false, cursor: null };
+  };
   let loaded;
+  let older = null;
   try {
     loaded = await store.load(agentId, sessionId);
+    if (requestId !== void 0 && loaded !== null && loaded.requestId !== requestId && typeof store.findRequest === "function") {
+      older = await store.findRequest(agentId, sessionId, requestId);
+    }
   } catch (error) {
     const storeError = new StoreLoadError(error);
     options?.onStoreError?.(storeError, "load");
-    const failState = initializeState(null, initialStateArg, schema);
-    failState["$error"] = storeError;
-    return { state: failState, signal: "$error", paused: false, cursor: null };
+    return fail(storeError);
   }
-  if (loaded !== null && loaded.phase === "completed") {
+  const decision = decideRun({ loaded, older, mode, requestId, sessionId });
+  if (decision.action === "reject") return fail(decision.error);
+  if (decision.action === "replay") {
+    const { row } = decision;
     return {
-      state: loaded.finalState,
-      signal: loaded.signal ?? null,
-      cursor: null,
-      paused: false
+      state: row.finalState,
+      signal: row.signal ?? null,
+      cursor: row.step ?? null,
+      paused: row.phase === "paused"
     };
   }
-  const state = initializeState(loaded, initialStateArg, schema);
+  const segmentRequestId = mode === "run" ? requestId : loaded?.requestId;
+  const base = decision.action === "new-turn" && loaded !== null ? withoutSystemFields(loaded) : loaded;
+  const input = decision.action === "continue" && !decision.mergeInput ? {} : initialStateArg;
+  const state = initializeState(base, input, schema);
   const initialStateSnapshot = { ...state };
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const result = await runLoop(graph, state, ctx, schema, composedShouldStop, loaded?.step, {
-    ...options,
+    ...loopOptions,
     runId,
     ...options?.parentRunId !== void 0 ? { parentRunId: options.parentRunId } : {},
+    ...segmentRequestId !== void 0 ? { requestId: segmentRequestId } : {},
     ...runRefsOf(loaded)
   });
   if (leaseExpired) {
@@ -1363,7 +1408,8 @@ async function runWithSession(store, agentId, sessionId, runId, graph, initialSt
         step: result.cursor,
         ...result.signal !== null ? { signal: result.signal } : {},
         ...metadata !== void 0 ? { metadata } : {},
-        ...result.carrier !== void 0 ? { carrier: result.carrier } : {}
+        ...result.carrier !== void 0 ? { carrier: result.carrier } : {},
+        ...segmentRequestId !== void 0 ? { requestId: segmentRequestId } : {}
       };
       await store.save(agentId, sessionId, saved);
     } else {
@@ -1379,7 +1425,8 @@ async function runWithSession(store, agentId, sessionId, runId, graph, initialSt
         finalState: result.state,
         ...result.signal !== null ? { signal: result.signal } : {},
         ...metadata !== void 0 ? { metadata } : {},
-        ...result.carrier !== void 0 ? { carrier: result.carrier } : {}
+        ...result.carrier !== void 0 ? { carrier: result.carrier } : {},
+        ...segmentRequestId !== void 0 ? { requestId: segmentRequestId } : {}
       };
       await store.save(agentId, sessionId, saved);
     }
@@ -1389,6 +1436,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() {
@@ -1459,10 +1550,23 @@ async function injectInterruptResponse(store, agentId, sessionId, interruptId, r
     ...loaded.signal !== void 0 ? { signal: loaded.signal } : {},
     ...loaded.metadata !== void 0 ? { metadata: loaded.metadata } : {},
     ...loaded.carrier !== void 0 ? { carrier: loaded.carrier } : {},
-    ...loaded.branchedFrom !== void 0 ? { branchedFrom: loaded.branchedFrom } : {}
+    ...loaded.branchedFrom !== void 0 ? { branchedFrom: loaded.branchedFrom } : {},
+    ...loaded.requestId !== void 0 ? { requestId: loaded.requestId } : {}
   };
   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 +1726,36 @@ 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 InvalidRunResourceError = class extends Error {
+  /** The resource key that was rejected. */
+  key;
+  /** The rejected value, as given. */
+  value;
+  constructor(key, value) {
+    super(`${key} must be a non-empty string \u2014 got ${describeValue(value)} in agent.run() resources`);
+    this.name = "InvalidRunResourceError";
+    this.key = key;
+    this.value = value;
+  }
+};
+function readIdResource(resources, key) {
+  const value = resources[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || value.length === 0) throw new InvalidRunResourceError(key, value);
+  return value;
+}
 var _agentInternals = /* @__PURE__ */ Symbol("_agentInternals");
 function createAgent(id, h, slots, agentOptions) {
   const internals = getInternals(h);
@@ -1652,6 +1786,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();
@@ -1701,11 +1842,12 @@ function createAgent(id, h, slots, agentOptions) {
     runtimeKeys,
     requiredKeys
   };
-  const reservedRunKeys = /* @__PURE__ */ new Set(["sessionId", "signal", "events", "listeners", "observer", "onObserverError", "claimOptions", "parentRunId"]);
+  const reservedRunKeys = /* @__PURE__ */ new Set(["sessionId", "requestId", "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 +1863,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,
+                  {
+                    mode: "resume",
+                    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 } : {}
+                  }
+                );
+                return { state: r.state, signal: r.signal };
+              }
+            });
           }
-        }
+        });
       } finally {
         inFlightSessions.delete(sId);
       }
@@ -1837,10 +1953,11 @@ function createAgent(id, h, slots, agentOptions) {
           throw new MissingRuntimeSlotError(key);
         }
       }
-      const sessionId = typeof resources["sessionId"] === "string" ? resources["sessionId"] : randomUUID();
+      const sessionId = readIdResource(resources, "sessionId") ?? randomUUID();
+      const requestId = readIdResource(resources, "requestId");
       const runId = randomUUID();
       if (inFlightSessions.has(sessionId)) throw new SessionInFlightError(sessionId);
-      if (interruptPendingSessions.has(sessionId)) throw new SessionPendingInterruptError(sessionId);
+      if (capturedStore === void 0 && interruptPendingSessions.has(sessionId)) throw new SessionPendingInterruptError(sessionId);
       inFlightSessions.add(sessionId);
       let _stopped = false;
       const abortController = new AbortController();
@@ -1887,7 +2004,10 @@ 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 = {
+        mode: "run",
+        ...requestId !== void 0 ? { requestId } : {},
         shouldStop: () => stopFlag.stopped,
         onBeforeStep: (name, state) => {
           stepRef.current = name;
@@ -1909,63 +2029,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 (capturedStore === void 0 && 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 +2085,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,
+                        {
+                          mode: "resume",
+                          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
+                        }
+                      );
+                      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 +2172,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 +2190,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 } : {},
@@ -2102,6 +2206,7 @@ function createAgent(id, h, slots, agentOptions) {
   return agent;
 }
 export {
+  InvalidRunResourceError,
   LeaseExpiredError,
   LoopNotDefinedError,
   NoInterruptError,