@statelyai/agent 2.0.0-alpha.18 → 2.0.0-alpha.20

package/dist/index.cjs

@@ -1,9 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_errors = require("./errors-DUBBzRLP.cjs");
-const require_setup_agent = require("./setup-agent-C3ETi_HZ.cjs");
-const require_decision = require("./decision-DnQCQPew.cjs");
-const require_event_log_store = require("./event-log-store-yquOV1TX.cjs");
+const require_setup_agent = require("./setup-agent-gISRLxRe.cjs");
+const require_decision = require("./decision-DhsKLYAI.cjs");
+const require_event_log_store = require("./event-log-store-a_TKy1gk.cjs");
+require("./validate.cjs");
 let xstate = require("xstate");
+let xstate_durable = require("xstate/durable");
 //#region src/internal/state-request-pass.ts
 async function runTextPhase(stateRequest, baseMessages, deps) {
 	const { model, system } = stateRequest;
@@ -103,7 +105,7 @@ async function runAdvancePhase(plan, deps) {
 		messages: [...deps.messages],
 		events,
 		attempts: []
-	}, deps.decide, {
+	}, { decide: deps.decide }, {
 		signal: deps.signal,
 		canTake: (event) => deps.getSnapshot().can(event)
 	});
@@ -139,8 +141,7 @@ async function runStateRequestPass(requests, deps) {
 * {@link getAcceptedEvents}). A programmer/integration error, in the same
 * class as runAgent's bind-time throws — it throws rather than settling an
 * `error` result. A type-legal event a guard rejects is NOT this error (the
-* machine simply takes no transition). Opt out with
-* {@link RunAgentOptions.onIllegalResumeEvent} `'ignore'`.
+* machine simply takes no transition). Always enforced; there is no opt-out.
 */
 var AgentIllegalResumeEventError = class extends require_errors.AgentError {
 	eventType;
@@ -258,7 +259,7 @@ function toJsonValue(value, ancestors) {
 * in a JSONL file). Live values are sanitized rather than trusted:
 *
 * - Snapshots (`run.start`, `machine.transition`, `run.end`) go through the
-*   same JSON round-trip as {@link persistSnapshot}, so what lands on disk is
+*   same JSON round-trip as `machine.getPersistedSnapshot(...)`, so what lands on disk is
 *   what a resume would see.
 * - `request.end`'s `raw` (a provider SDK object, frequently cyclic) is DROPPED
 *   unless `includeRaw` is set, in which case it is sanitized like everything
@@ -285,11 +286,92 @@ function serializeTraceEvent(event, options = {}) {
 	}
 	return out;
 }
+function snapshotNodes(snapshot) {
+	return (snapshot.nodes ?? []).map((raw) => {
+		const node = raw;
+		return {
+			id: node.id ?? "",
+			key: node.key ?? "",
+			...node.description !== void 0 ? { description: node.description } : {},
+			tags: [...node.tags ?? []],
+			...node.meta !== void 0 ? { meta: node.meta } : {},
+			ownEvents: [...node.ownEvents ?? []],
+			leaf: Object.keys(node.states ?? {}).length === 0
+		};
+	});
+}
+/**
+* The active state nodes of a snapshot, as plain {@link AgentSnapshotNode}
+* descriptors. The escape hatch under {@link getSnapshotRequests}: use it when
+* your `getRequests` hook needs to build requests some other way, so host code
+* never touches xstate's private `snapshot._nodes`.
+*/
+function getSnapshotNodes(snapshot) {
+	return snapshotNodes(snapshot);
+}
+/**
+* Builds the {@link AgentStateRequest}s for a snapshot straight from its active
+* state nodes — the prompts-in-descriptions recipe as a function, so a
+* {@link RunAgentOptions.getRequests} hook is one line and never reaches into
+* xstate's private `snapshot._nodes`:
+*
+* ```ts
+* runAgent(machine, {
+*   executors,
+*   getRequests: (snapshot) => getSnapshotRequests(snapshot, { model: 'writer' }),
+* });
+* ```
+*
+* Each described active node becomes one request: `prompt` from the node's
+* `description`, `kind: 'decision'` when it is tagged `'decision'`, `system`
+* from `meta.role` when present, `allowedEvents` scoped to the node's own
+* events, and an explicit `onDone` when the node has exactly one own event
+* (single-outcome states advance deterministically; anything else falls
+* through to a `decide` call). Nodes tagged `'waiting'` produce nothing, so the
+* run settles idle for a human. Override any of it with `filter`/`map`.
+*/
+function getSnapshotRequests(snapshot, options) {
+	const filter = options.filter ?? ((node) => !!node.description && !node.tags.includes("waiting"));
+	const requests = [];
+	for (const node of snapshotNodes(snapshot)) {
+		if (!filter(node)) continue;
+		const system = node.meta?.role;
+		const request = {
+			model: options.model,
+			prompt: node.description ?? "",
+			kind: node.tags.includes("decision") ? "decision" : "text",
+			...system !== void 0 ? { system } : {},
+			...node.ownEvents.length > 0 ? { allowedEvents: node.ownEvents } : {},
+			...node.ownEvents.length === 1 ? { onDone: { type: node.ownEvents[0] } } : {}
+		};
+		const mapped = options.map ? options.map(request, node) : request;
+		if (mapped) requests.push(mapped);
+	}
+	return requests;
+}
 let nextRunAgentTraceId = 1;
+/**
+* Thrown into the invoke that would have made the call once
+* {@link RunAgentOptions.maxModelCalls} is spent. It reaches the machine
+* through the normal error channel, so an invoke's `onError` can branch on it
+* (`error.code === 'max-model-calls'`, the same string the settled result's
+* `cause` uses) and route to a degraded/finish state instead of failing the
+* run. Unhandled, it settles `{ status: 'error', cause: 'max-model-calls' }`.
+*
+* ```ts
+* onError: [
+*   { guard: ({ event }) => event.error?.code === 'max-model-calls', target: 'budgetSpent' },
+*   { target: 'failed' },
+* ]
+* ```
+*/
 var AgentMaxModelCallsExceededError = class extends require_errors.AgentError {
-	constructor() {
-		super("max-model-calls-exceeded", "runAgent exceeded maxModelCalls.");
+	/** The budget that was exceeded (`options.maxModelCalls`). */
+	maxModelCalls;
+	constructor(maxModelCalls) {
+		super("max-model-calls", `runAgent exceeded maxModelCalls (${maxModelCalls}). Raise the budget, or handle it in the invoke's onError (error.code === 'max-model-calls').`);
 		this.name = "AgentMaxModelCallsExceededError";
+		this.maxModelCalls = maxModelCalls;
 	}
 };
 function wrapsDecisionExhausted(error) {
@@ -329,7 +411,7 @@ function collectConfiguredInvokeSrcs(stateConfig, stateName, out) {
 * walk into invoked child machines (their internal agent requests are opaque
 * to the parent-level source walk otherwise).
 */
-function isStateMachine(logic) {
+function isStateMachineLogic(logic) {
 	return !!logic && typeof logic === "object" && "config" in logic && "root" in logic && typeof logic.provide === "function" && typeof logic.sources === "object" && !!logic.sources?.actors;
 }
 /**
@@ -361,7 +443,7 @@ function assertMachineBindable(machine, effectiveSources, executors, ctx) {
 	const where = ctx.isChild ? `child machine '${ctx.childPath}' state` : "state";
 	for (const { stateName, src } of invokes) {
 		if (typeof src !== "string") {
-			if (isStateMachine(src)) {
+			if (isStateMachineLogic(src)) {
 				assertChildMachineBindable(src, src, stateName, executors, ctx);
 				continue;
 			}
@@ -370,7 +452,7 @@ function assertMachineBindable(machine, effectiveSources, executors, ctx) {
 		}
 		const logic = effectiveSources[src];
 		if (logic === void 0) throw new Error(`runAgent: ${where} '${stateName}' invokes unregistered actor source '${src}'. Provide it via machine.provide({ actors: { '${src}': ... } }) or runAgent(machine, { actors: { '${src}': ... } }).`);
-		if (isStateMachine(logic)) {
+		if (isStateMachineLogic(logic)) {
 			assertChildMachineBindable(logic, src, stateName, executors, ctx);
 			continue;
 		}
@@ -416,18 +498,16 @@ function unrebindableChildRequestError(childPath, stateName, requestSrc, kind) {
 	return /* @__PURE__ */ new Error(`runAgent: child machine '${childPath}' (state '${stateName}') invokes ${kind} source '${requestSrc}', which has no host execution and is reached through a direct-object invoke src that runAgent cannot rebind. Requests reached through string-keyed actor sources inherit runAgent's generateText/streamText/decide executors automatically; a direct-object child machine does not. Either bind the request with its own executor (requestLogic.withExecutor(...)), or register the child as a string-keyed actor source (machine.provide({ actors: { <child>: childMachine } })) and invoke it by name.`);
 }
 /**
-* True when the snapshot's active states declare a transition for the reserved
-* `'@agent.usage'` type EXPLICITLY. A catch-all `on: { '*': … }` deliberately
-* does not count: a wildcard is a machine's own event vocabulary, not an
-* opt-in to a library-reserved event, and `snapshot.can(event)` alone cannot
-* tell the two apart (it answers "would this event be taken?", which a
-* wildcard makes true for everything). Gating delivery on the explicit
-* declaration is what keeps `@agent.usage` opt-in by construction — and keeps
-* a wildcard machine's context and event log byte-identical to a run without
-* the feature. @internal
+* True when the snapshot's active states declare a transition that would
+* receive the reserved `'@agent.usage'` type — an explicit `on: { '@agent.usage'
+* }` OR a catch-all `on: { '*': … }`. Plain XState semantics apply unmodified:
+* a wildcard matches every event delivered to the machine, reserved ones
+* included. (The MODEL-facing side stays closed: `getAcceptedEvents` drops
+* `@agent.*` before any `allowedEvents` matching, so a wildcard never offers
+* the reserved event as a decision candidate.) @internal
 */
 function declaresUsageTransition(snapshot) {
-	return (0, xstate.getNextTransitions)(snapshot).some((transition) => transition.eventType === require_setup_agent.AGENT_USAGE_EVENT_TYPE);
+	return (0, xstate.getNextTransitions)(snapshot).some((transition) => transition.eventType === "@agent.usage" || transition.eventType === "*");
 }
 /**
 * Builds the ONE place a trace payload is emitted: it hands the payload to the
@@ -494,7 +574,7 @@ function bindTextLogic(logic, runCtx) {
 		const self = selfArg;
 		const { id, src } = selfIdAndSrc(self);
 		const executor = logic.mode === "stream" ? runCtx.streamText : runCtx.generateText;
-		if (!executor) throw new Error(`runAgent: no '${logic.mode === "stream" ? "streamText" : "generateText"}' executor provided.`);
+		if (!executor) throw new Error(`No '${logic.mode === "stream" ? "streamText" : "generateText"}' executor provided.`);
 		const requestWithTools = {
 			...request,
 			tools: request.tools ?? {}
@@ -566,17 +646,22 @@ function bindTextLogic(logic, runCtx) {
 	});
 }
 function createCountingDecide(runCtx, self) {
-	return async (attemptRequest) => {
+	return async (attemptRequest, info) => {
 		runCtx.consumeModelCall();
 		runCtx.emitTrace?.({
 			type: "request.start",
 			request: attemptRequest
 		}, self);
 		try {
+			const { id } = selfIdAndSrc(self);
 			const result = await runCtx.decide(runCtx.runId !== void 0 ? {
 				...attemptRequest,
 				runId: runCtx.runId
-			} : attemptRequest);
+			} : attemptRequest, {
+				...info,
+				...runCtx.runId !== void 0 ? { runId: runCtx.runId } : {},
+				...info?.requestId === void 0 && id !== "" ? { requestId: id } : {}
+			});
 			const usage = require_decision.getCallUsage(result);
 			if (usage) {
 				const { src } = selfIdAndSrc(self);
@@ -622,7 +707,7 @@ function createCountingDecide(runCtx, self) {
 */
 function bindDecisionLogic(logic, runCtx) {
 	const decisionLogic = (0, xstate.createAsyncLogic)({ run: async ({ input, signal, self: selfArg }) => {
-		if (!runCtx.decide) throw new Error("runAgent: no 'decide' executor provided.");
+		if (!runCtx.decide) throw new Error("No 'decide' executor provided.");
 		const self = selfArg;
 		const { id } = selfIdAndSrc(self);
 		const declaredEventTypes = logic.allowedEventTypes?.(input);
@@ -636,7 +721,7 @@ function bindDecisionLogic(logic, runCtx) {
 			...logic.request(input),
 			id,
 			events
-		}, createCountingDecide(runCtx, self), {
+		}, { decide: createCountingDecide(runCtx, self) }, {
 			maxRetries: logic.maxRetries,
 			signal,
 			canTake: (event) => actorRef ? actorRef.getSnapshot().can(event) : true
@@ -681,7 +766,7 @@ function rootTraceState(root) {
 	if (!state) {
 		const logic = root.logic;
 		const machineId = (logic?.config)?.id ?? logic?.id ?? "(machine)";
-		const machineVersion = logic ? require_decision.getMachineStructuralHash(logic) : "";
+		const machineVersion = logic ? require_decision.resolveMachineVersion(logic) : "";
 		state = {
 			runId: `run_${nextProvideRunId++}`,
 			seq: 0,
@@ -753,9 +838,9 @@ function provideBindContext(machine, executors, options) {
 * under a live `createActor` tree) on the `provideExecutors` path.
 *
 * Gating is identical on both: the target snapshot must be active, must declare
-* an `'@agent.usage'` transition EXPLICITLY (see {@link declaresUsageTransition}
-* — a catch-all `on: { '*' }` is not an opt-in), and must be able to take the
-* event. `onDropped` is the run path's straggler gate: it returns `true` for a
+* an `'@agent.usage'` transition — explicitly, or through a catch-all
+* `on: { '*' }` (see {@link declaresUsageTransition}) — and must be able to
+* take the event. `onDropped` is the run path's straggler gate: it returns `true` for a
 * call that settled after the cycle resolved, which drops the event (traced as
 * `usage.dropped`) rather than delivering it. Uncontrolled mode has no cycle to
 * settle, so it passes no gate and has no dropped stragglers.
@@ -797,6 +882,19 @@ function bindDecisionForProvide(machine, logic, executors, options) {
 	return bindDecisionLogic(logic, provideBindContext(machine, executors, options));
 }
 /**
+* Recursively binds an invoked child state machine for {@link provideExecutors},
+* with the same semantics `runAgent` applies ({@link rebindChildMachine}):
+* string-keyed text/decision sources at any depth inherit the host executors,
+* a source that carries its own executor is left alone, and a cycle is
+* returned as-is. Each machine in the tree is bound with its own registered
+* `setupAgent` schemas. Returns the original machine when nothing needed
+* wrapping. @internal
+*/
+function bindChildMachineForProvide(childMachine, executors, options, visited) {
+	const ctxFor = (target) => provideBindContext(target, executors, options);
+	return rebindChildMachine(childMachine, ctxFor(childMachine), visited, ctxFor);
+}
+/**
 * Validates `input` against the machine's registered input schema, returning
 * the schema's output — so defaults are filled and transforms applied before
 * the value reaches `createActor` or the replayable event log.
@@ -830,9 +928,10 @@ function resolveMachineInput(machine, input) {
 * (`executorBoundLogics`) is left as-is: explicit binding shadows inheritance.
 * Cycle-safe via `visited` (a machine that invokes itself is returned as-is).
 */
-function rebindChildMachine(childMachine, runCtx, visited) {
+function rebindChildMachine(childMachine, runCtx, visited, ctxFor) {
 	if (visited.has(childMachine)) return childMachine;
 	const childVisited = new Set([...visited, childMachine]);
+	runCtx = ctxFor ? ctxFor(childMachine) : runCtx;
 	const sources = childMachine.sources.actors;
 	const wrapped = {};
 	for (const [key, logic] of Object.entries(sources)) {
@@ -844,8 +943,8 @@ function rebindChildMachine(childMachine, runCtx, visited) {
 			if (!require_decision.executorBoundLogics.has(logic)) wrapped[key] = bindTextLogic(logic, runCtx);
 			continue;
 		}
-		if (isStateMachine(logic)) {
-			const rebound = rebindChildMachine(logic, runCtx, childVisited);
+		if (isStateMachineLogic(logic)) {
+			const rebound = rebindChildMachine(logic, runCtx, childVisited, ctxFor);
 			if (rebound !== logic) wrapped[key] = rebound;
 			continue;
 		}
@@ -928,7 +1027,7 @@ function createAgentSession(machine, options, lifecycle) {
 	let traceSeq = 0;
 	const resolvedInput = resolveMachineInput(machine, options.input);
 	const machineId = machine.config.id ?? machine.id ?? "(machine)";
-	const machineVersion = options.machineVersion ?? machine.version ?? require_decision.getMachineStructuralHash(machine);
+	const machineVersion = require_decision.resolveMachineVersion(machine);
 	const agentMeta = {
 		machineId,
 		version: machineVersion
@@ -950,10 +1049,10 @@ function createAgentSession(machine, options, lifecycle) {
 		onTransition: options.onTransition
 	});
 	const consumeModelCall = () => {
-		if (budgetExceeded) throw new AgentMaxModelCallsExceededError();
+		if (budgetExceeded) throw new AgentMaxModelCallsExceededError(maxModelCalls);
 		if (modelCallCount + 1 > maxModelCalls) {
 			budgetExceeded = true;
-			throw new AgentMaxModelCallsExceededError();
+			throw new AgentMaxModelCallsExceededError(maxModelCalls);
 		}
 		modelCallCount += 1;
 	};
@@ -1027,19 +1126,20 @@ function createAgentSession(machine, options, lifecycle) {
 			if (!require_decision.executorBoundLogics.has(logic)) wrappedSources[key] = bindTextLogic(logic, runCtx);
 			continue;
 		}
-		if (isStateMachine(logic)) {
+		if (isStateMachineLogic(logic)) {
 			const rebound = rebindChildMachine(logic, runCtx, new Set([machine]));
 			if (rebound !== logic) wrappedSources[key] = rebound;
 			continue;
 		}
 	}
 	const boundMachine = provided.provide({ actors: wrappedSources });
-	const declaredSuspensionPredicate = options.isSuspended ?? require_decision.getMachineSuspensionPredicate(machine);
-	const isSuspended = declaredSuspensionPredicate ?? (() => false);
+	const declaredIdlePredicate = options.isIdle ?? require_decision.getMachineIdlePredicate(machine);
+	const isIdle = declaredIdlePredicate ?? (() => false);
+	const machineDeclaresMigrate = typeof machine.config.migrate === "function";
 	let effectiveSnapshot = options.snapshot;
 	if (effectiveSnapshot !== void 0) {
 		const from = effectiveSnapshot.agentMeta?.version ?? effectiveSnapshot.version;
-		if (from !== void 0 && from !== machineVersion) {
+		if (from !== void 0 && from !== machineVersion && !(machineDeclaresMigrate && !options.migrateSnapshot)) {
 			const info = {
 				from,
 				to: machineVersion
@@ -1058,10 +1158,11 @@ function createAgentSession(machine, options, lifecycle) {
 		effectiveSnapshot = machine.getPersistedSnapshot(replayedSnapshot);
 	}
 	const machineOwnVersion = machine.version;
-	if (effectiveSnapshot !== void 0 && effectiveSnapshot.version !== machineOwnVersion) {
+	if (!machineDeclaresMigrate && effectiveSnapshot !== void 0 && effectiveSnapshot.version !== machineOwnVersion) {
 		const aligned = Object.assign(Object.create(Object.getPrototypeOf(effectiveSnapshot)), effectiveSnapshot);
 		if (machineOwnVersion === void 0) delete aligned.version;
 		else aligned.version = machineOwnVersion;
+		delete aligned.machine;
 		effectiveSnapshot = aligned;
 	}
 	const priorMessages = require_decision.getAgentMessages(effectiveSnapshot);
@@ -1072,7 +1173,7 @@ function createAgentSession(machine, options, lifecycle) {
 		if (!options.getRequests && !options.messages && messages.length === 0) return;
 		snapshot.messages = [...messages];
 	};
-	if (effectiveSnapshot !== void 0 && options.event !== void 0 && (options.onIllegalResumeEvent ?? "throw") === "throw") {
+	if (effectiveSnapshot !== void 0 && options.event !== void 0) {
 		const acceptedTypes = require_decision.getAcceptedEvents((0, xstate.createActor)(boundMachine, { snapshot: effectiveSnapshot }).getSnapshot(), { schemas: runCtx.schemas }).map((descriptor) => descriptor.type);
 		const eventType = options.event.type;
 		if (!acceptedTypes.includes(eventType)) throw new AgentIllegalResumeEventError(eventType, acceptedTypes);
@@ -1218,9 +1319,9 @@ function createAgentSession(machine, options, lifecycle) {
 			const current = actor.getSnapshot();
 			if (isIdleSnapshot(current, { ignoreUserInputChildren: userInputIsPlaceholder })) {
 				if (!maybeInterpret(current)) {
-					if (!declaredSuspensionPredicate && current.status === "active" && !warnedHeuristicIdle && process.env.NODE_ENV !== "production") {
+					if (!declaredIdlePredicate && current.status === "active" && !warnedHeuristicIdle && process.env.NODE_ENV !== "production") {
 						warnedHeuristicIdle = true;
-						console.warn("[@statelyai/agent] runAgent settled idle via the timing heuristic (no suspension predicate declared). This is best-effort; for deterministic idle detection, declare setupAgent({ isSuspended }) or pass runAgent(machine, { isSuspended }), e.g. (s) => s.hasTag('waiting').");
+						console.warn("[@statelyai/agent] runAgent settled idle via the timing heuristic (no idle predicate declared). This is best-effort; for deterministic idle detection, declare setupAgent({ isIdle }) or pass runAgent(machine, { isIdle }), e.g. (s) => s.hasTag('waiting').");
 					}
 					settleIdle(current);
 				}
@@ -1275,11 +1376,11 @@ function createAgentSession(machine, options, lifecycle) {
 				});
 				return;
 			}
-			if (!deliveringResumeEvent && isSuspended(snapshot) && isIdleSnapshot(snapshot, { ignoreUserInputChildren: userInputIsPlaceholder })) {
+			if (!deliveringResumeEvent && isIdle(snapshot) && isIdleSnapshot(snapshot, { ignoreUserInputChildren: userInputIsPlaceholder })) {
 				queueMicrotask(() => {
 					if (settled) return;
 					const current = actor.getSnapshot();
-					if (isSuspended(current) && isIdleSnapshot(current, { ignoreUserInputChildren: userInputIsPlaceholder })) {
+					if (isIdle(current) && isIdleSnapshot(current, { ignoreUserInputChildren: userInputIsPlaceholder })) {
 						if (!maybeInterpret(current)) settleIdle(current);
 					} else scheduleIdleCheck();
 				});
@@ -1576,9 +1677,12 @@ function createAgentRun(machine, options) {
 * Throws at bind time if a source needs an executor kind that `executors` does
 * not provide.
 *
-* `provideExecutors` does not descend into invoked child state machines: a string-keyed child
-* machine source is left untouched, so a child with its own agent invokes needs
-* its own `provideExecutors(...)` (or `runAgent`, which does rebind children).
+* Executor inheritance is RECURSIVE, exactly as in `runAgent`: a string-keyed
+* invoked child machine is rebound too, so its own text/decision requests — at
+* any depth — reach the same host executors. A direct-object invoke `src`
+* cannot be swapped via `.provide`, so nothing under one inherits; bind those
+* with `.withExecutor(...)` or register the child as a string-keyed source. A
+* source that already carries its own executor is never overwritten.
 */
 function provideExecutors(machine, executors, options = {}) {
 	const bindOptions = {
@@ -1592,21 +1696,18 @@ function provideExecutors(machine, executors, options = {}) {
 	const invokedSrcs = getConfiguredInvokeSrcs(provided);
 	for (const [key, logic] of Object.entries(effectiveSources)) {
 		if (key === "agent.userInput") continue;
-		let binding;
-		if (require_decision.isDecisionLogic(logic)) binding = {
-			executorKey: "decide",
-			kind: "decision",
-			bind: () => bindDecisionForProvide(provided, logic, executors, bindOptions)
-		};
-		else if (require_decision.isTextLogic(logic)) {
-			const streaming = logic.mode === "stream";
-			binding = {
-				executorKey: streaming ? "streamText" : "generateText",
-				kind: streaming ? "streaming text" : "text",
-				bind: () => bindTextForProvide(provided, logic, executors, bindOptions)
-			};
+		if (isStateMachineLogic(logic)) {
+			if (invokedSrcs.has(key)) assertChildBindable(logic, executors, key, new Set([provided]));
+			const rebound = bindChildMachineForProvide(logic, executors, bindOptions, new Set([provided]));
+			if (rebound !== logic) wrappedSources[key] = rebound;
+			continue;
 		}
-		if (!binding) continue;
+		const requirement = executorRequirementOf(logic);
+		if (!requirement) continue;
+		const binding = {
+			...requirement,
+			bind: () => require_decision.isDecisionLogic(logic) ? bindDecisionForProvide(provided, logic, executors, bindOptions) : bindTextForProvide(provided, logic, executors, bindOptions)
+		};
 		if (require_decision.executorBoundLogics.has(logic)) continue;
 		if (!executors[binding.executorKey]) {
 			if (invokedSrcs.has(key)) throw missingExecutorError(key, binding.kind, binding.executorKey);
@@ -1616,12 +1717,50 @@ function provideExecutors(machine, executors, options = {}) {
 	}
 	return withActors(provided, wrappedSources);
 }
+/** The executor slot + label an agent logic needs, or `undefined` for a non-agent actor. */
+function executorRequirementOf(logic) {
+	if (require_decision.isDecisionLogic(logic)) return {
+		executorKey: "decide",
+		kind: "decision"
+	};
+	if (require_decision.isTextLogic(logic)) return logic.mode === "stream" ? {
+		executorKey: "streamText",
+		kind: "streaming text"
+	} : {
+		executorKey: "generateText",
+		kind: "text"
+	};
+}
+/**
+* Walks an invoked child machine's own invoked sources (recursively, at any
+* depth) and throws the same missing-executor error `provideExecutors` throws
+* for the top-level machine — before any actor starts. Mirrors runAgent's
+* `assertBindable` for the uncontrolled path. Cycle-safe via `visited`.
+*/
+function assertChildBindable(childMachine, executors, path, visited) {
+	if (visited.has(childMachine)) return;
+	const nextVisited = new Set([...visited, childMachine]);
+	const sources = childMachine.sources.actors;
+	for (const src of getConfiguredInvokeSrcs(childMachine)) {
+		if (src === "agent.userInput") continue;
+		const logic = sources[src];
+		if (!logic) continue;
+		if (isStateMachineLogic(logic)) {
+			assertChildBindable(logic, executors, `${path} > ${src}`, nextVisited);
+			continue;
+		}
+		const requirement = executorRequirementOf(logic);
+		if (!requirement || require_decision.executorBoundLogics.has(logic)) continue;
+		if (!executors[requirement.executorKey]) throw missingExecutorError(`${path} > ${src}`, requirement.kind, requirement.executorKey);
+	}
+}
 function missingExecutorError(src, kind, executor) {
 	return /* @__PURE__ */ new Error(`provideExecutors: actor source '${src}' is a ${kind} source but no '${executor}' executor was provided. Add it to the executors object, or bind the source with its own executor (logic.withExecutor(...)) before calling provideExecutors.`);
 }
 //#endregion
 //#region src/verify.ts
 const DECIDE_SRC = "agent.decide";
+const USER_INPUT_SRC = "agent.userInput";
 function normalizeInvokes(invoke) {
 	if (invoke === void 0 || invoke === null) return [];
 	return Array.isArray(invoke) ? invoke : [invoke];
@@ -1908,11 +2047,23 @@ const LINT_CHECKS = [
 * call this to catch dead states, undeliverable decisions, un-rebindable
 * invoke srcs, and output-contract gaps before ever running it.
 *
+* Pass `{ throw: true }` for the one-liner form used in tests and generation
+* loops: it returns silently when the machine is clean and throws
+* {@link AgentLintError} (findings on `.diagnostics`) on error-severity
+* findings, or on warnings too with `{ throw: true, warnings: true }`.
+*
 * @example
 * ```ts
 * const errors = lintAgentMachine(machine).filter((d) => d.severity === 'error');
 * if (errors.length) throw new Error(errors.map((e) => `${e.path}: ${e.message}`).join('\n'));
 * ```
+*
+* @example Throwing form
+* ```ts
+* test('agent machine is structurally sound', () => {
+*   lintAgentMachine(machine, { throw: true });
+* });
+* ```
 */
 function lintAgentMachine(machine, options = {}) {
 	const config = machine.config ?? {};
@@ -1927,10 +2078,16 @@ function lintAgentMachine(machine, options = {}) {
 		actors: registered.actors ?? machine.sources?.actors ?? {}
 	};
 	const disabled = new Set(options.disable ?? []);
-	return LINT_CHECKS.flatMap((check) => check(ctx)).filter((d) => !disabled.has(d.code));
+	const diagnostics = LINT_CHECKS.flatMap((check) => check(ctx)).filter((d) => !disabled.has(d.code));
+	if (options.throw) {
+		const failing = options.warnings ? diagnostics : diagnostics.filter((d) => d.severity === "error");
+		if (failing.length > 0) throw new AgentLintError(machine.id ?? "(machine)", failing);
+	}
+	return diagnostics;
 }
 /**
-* Thrown by {@link assertAgentMachine} when lint finds failing diagnostics.
+* Thrown by `lintAgentMachine(machine, { throw: true })` when lint finds
+* failing diagnostics.
 * `diagnostics` holds the findings; the message lists them one per finding,
 * so a test runner's failure output reads like the CLI's lint report.
 */
@@ -1943,24 +2100,6 @@ var AgentLintError = class extends require_errors.AgentError {
 		this.diagnostics = diagnostics;
 	}
 };
-/**
-* Asserts a machine passes {@link lintAgentMachine}: returns silently when
-* clean, throws {@link AgentLintError} (with the findings on `.diagnostics`)
-* otherwise. Fails on error-severity findings; set `warnings: true` to fail on
-* warnings too. The one-liner for tests and generation loops:
-*
-* @example
-* ```ts
-* test('agent machine is structurally sound', () => {
-*   assertAgentMachine(machine);
-* });
-* ```
-*/
-function assertAgentMachine(machine, options = {}) {
-	const diagnostics = lintAgentMachine(machine, options);
-	const failing = options.warnings ? diagnostics : diagnostics.filter((d) => d.severity === "error");
-	if (failing.length > 0) throw new AgentLintError(machine.id ?? "(machine)", failing);
-}
 function pendingInvokes(step) {
 	const out = [];
 	for (const action of step.actions) {
@@ -2006,6 +2145,7 @@ async function simulateAgent(machine, options) {
 		decisions: mapValues(options.script.decisions ?? {}, (arr) => [...arr]),
 		invokes: mapValues(options.script.invokes ?? {}, (arr) => [...arr])
 	};
+	if (options.script.userInput?.length) script.invokes[USER_INPUT_SRC] = [...options.script.userInput, ...script.invokes[USER_INPUT_SRC] ?? []];
 	let step = require_setup_agent.initialAgentStep(machine, options.input);
 	const trail = [];
 	for (let i = 0; i < maxSteps; i++) {
@@ -2072,13 +2212,16 @@ function mapValues(obj, fn) {
 }
 function scriptDryError(kind, src, id, request) {
 	const events = request?.kind === "decision" ? ` Candidate events: ${request.events.map((e) => e.type).join(", ") || "(none)"}.` : "";
-	return /* @__PURE__ */ new Error(`simulateAgent: script ran dry on a pending ${kind} request for src '${src}' (id '${id}'). Add a '${kind}' entry for '${src}' to the script.${events}`);
+	const key = kind === "text" ? `text['${src}']` : kind === "decision" ? `decisions['${src}']` : src === USER_INPUT_SRC ? "userInput" : `invokes['${src}']`;
+	return /* @__PURE__ */ new Error(`simulateAgent: script ran dry on a pending ${kind} request for src '${src}' (id '${id}'). Add an entry to the script's \`${key}\` queue.${events}`);
 }
 const MAX_ADVANCE_STEPS = 1e3;
 async function explore(machine, options, stopWhen) {
 	const maxDepth = options.maxDepth ?? 8;
 	const maxPaths = options.maxPaths ?? 200;
-	const textOutputs = options.textOutputs ?? {};
+	const textScript = options.text ?? {};
+	const invokeOutputs = { ...options.invokes ?? {} };
+	if ("userInput" in options) invokeOutputs[USER_INPUT_SRC] = options.userInput;
 	const reachedStates = /* @__PURE__ */ new Set();
 	const reachedValues = [];
 	const terminals = [];
@@ -2103,22 +2246,22 @@ async function explore(machine, options, stopWhen) {
 			if (current.done) return { step: current };
 			const request = current.requests[0];
 			if (request && request.kind === "text") {
-				if (!(request.src in textOutputs)) return {
+				if (!(request.src in textScript)) return {
 					step: current,
 					blockedSrc: request.src
 				};
-				current = require_setup_agent.resolveAgentStep(machine, current, request, textOutputs[request.src]);
+				current = require_setup_agent.resolveAgentStep(machine, current, request, textScript[request.src]);
 				recordState(current.snapshot);
 				continue;
 			}
 			if (request && request.kind === "decision") return { step: current };
 			const [invoke] = pendingInvokes(current);
 			if (invoke) {
-				if (!(invoke.src in textOutputs)) return {
+				if (!(invoke.src in invokeOutputs)) return {
 					step: current,
 					blockedSrc: invoke.src
 				};
-				current = require_setup_agent.resolveAgentStep(machine, current, invoke.id, textOutputs[invoke.src]);
+				current = require_setup_agent.resolveAgentStep(machine, current, invoke.id, invokeOutputs[invoke.src]);
 				recordState(current.snapshot);
 				continue;
 			}
@@ -2210,9 +2353,10 @@ async function explore(machine, options, stopWhen) {
 * depth, model-free, and reports which states are reached and how each path
 * terminates. At each decision request it forks one branch per candidate event
 * (guard-rejected candidates are counted in `prunedByGuard`, not explored); at
-* an idle wait it forks per externally-accepted event. Text/`userInput` invokes
-* are resolved from `textOutputs` (a by-src canned-output map) — a missing src
-* halts that branch with a `needs-output` terminal rather than throwing.
+* an idle wait it forks per externally-accepted event. Text requests resolve
+* from `text`, other invokes from `invokes` (or `userInput` for
+* `agent.userInput`) — all by-src canned-output maps, and a missing src halts
+* that branch with a `needs-output` terminal rather than throwing.
 *
 * Combinatorics are bounded by `maxDepth` (default 8) and `maxPaths` (default
 * 200, reported via `hitPathCap`).
@@ -2228,13 +2372,14 @@ async function explorePaths(machine, options = {}) {
 }
 /**
 * Answers "can the machine reach `statePath`?" by exploring its branches (a
-* thin wrapper over {@link explorePaths}). Returns `{ canReach: true, witness }`
-* with the event sequence that reaches it, or `{ canReach: false }`.
+* thin wrapper over {@link explorePaths}). Returns
+* `{ reachable: true, witness }` with the event sequence that reaches it, or
+* `{ reachable: false }`.
 *
 * @example
 * ```ts
-* const { canReach, witness } = await canReach(refundMachine, 'denied', { input: { request: 'x', amount: 5000 } });
-* // canReach → true; witness → [{ type: 'NEEDS_REVIEW' }, { type: 'DENY' }]
+* const { reachable, witness } = await canReach(refundMachine, 'denied', { input: { request: 'x', amount: 5000 } });
+* // reachable → true; witness → [{ type: 'NEEDS_REVIEW' }, { type: 'DENY' }]
 * ```
 */
 async function canReach(machine, statePath, options = {}) {
@@ -2246,9 +2391,9 @@ async function canReach(machine, statePath, options = {}) {
 		}
 	});
 	return witness !== void 0 ? {
-		canReach: true,
+		reachable: true,
 		witness
-	} : { canReach: false };
+	} : { reachable: false };
 }
 //#endregion
 //#region src/internal/is-record.ts
@@ -2409,7 +2554,8 @@ function matchesTrajectory(actual, expected, options = {}) {
 * Scripted executors — a keyless, deterministic stand-in for a model host.
 *
 * `createScriptedExecutors` builds a full `{ generateText, streamText, decide }`
-* set that plays back canned answers from FIFO queues, so `runAgent` (or
+* set (plus a `userInput` handler) that plays back canned answers from FIFO
+* queues, so `runAgent` (or
 * `provideExecutors`, or a bare `TextLogic.execute`) runs with no API key and no
 * network. It is the fastest way to see a machine run, and the least ceremonial
 * way to test one: same machine, same executor contract, scripted answers.
@@ -2485,15 +2631,27 @@ function emitScriptedChunk(result, info) {
 *   decisions: [(request) => ({ type: request.events[0]!.type })],
 * });
 * ```
+*
+* @example Scripted human input
+* ```ts
+* const scripted = createScriptedExecutors({ userInput: ['ship it'] });
+* await runAgent(machine, { executors: scripted, userInput: scripted.userInput });
+* ```
 */
 function createScriptedExecutors(script = {}) {
 	const decisions = [...script.decisions ?? []];
 	const text = [...script.text ?? []];
+	const userInput = [...script.userInput ?? []];
 	const nextText = async (request, info) => {
 		if (text.length === 0) throw new require_errors.AgentError("scripted-executors-exhausted", `createScriptedExecutors: script ran dry on a pending text request ${describeText(request)}. Add another entry to the script's \`text\` queue.`);
 		return resolveScriptedTextEntry(text.shift(), request, info);
 	};
 	return {
+		userInput: async (input) => {
+			if (userInput.length === 0) throw new require_errors.AgentError("scripted-executors-exhausted", `createScriptedExecutors: script ran dry on a pending userInput request (prompt: ${input.prompt ? `'${input.prompt}'` : "(none)"}). Add another entry to the script's \`userInput\` queue.`);
+			const entry = userInput.shift();
+			return typeof entry === "function" ? await entry(input) : entry;
+		},
 		generateText: nextText,
 		streamText: async (request, info) => {
 			const result = await nextText(request, info);
@@ -2567,22 +2725,22 @@ async function runSeam(machine, options) {
 	const queueKeyOf = (request) => request.name !== void 0 && queues.has(request.name) ? request.name : request.model;
 	/**
 	* Consumes this request's slot in the call plan, or resolves `undefined` when
-	* its queue is dry. The LAST entry repeats: a live seam that branches further
-	* still finds an answer instead of running dry.
+	* its queue is dry. With `repeatLast`, the last entry is replayed instead of
+	* running dry.
 	*/
 	const takeScriptedSlot = async (request, info) => {
 		const queue = queues.get(queueKeyOf(request));
 		if (!queue?.length) return;
-		return resolveScriptedTextEntry(queue.length === 1 ? queue[0] : queue.shift(), request, info);
+		return resolveScriptedTextEntry(options.repeatLast && queue.length === 1 ? queue[0] : queue.shift(), request, info);
 	};
 	const scriptedAnswer = async (request, info) => {
 		const scripted = await takeScriptedSlot(request, info);
-		if (!scripted) throw new require_errors.AgentError("seam-script-exhausted", `runSeam: no scripted answer left for request ${describeText(request)}. Add an entry to \`scripts.${queueKeyOf(request)}\` — its last entry repeats, so one extra answer covers a longer branch.`);
+		if (!scripted) throw new require_errors.AgentError("seam-script-exhausted", `runSeam: no scripted answer left for request ${describeText(request)}. Add an entry to \`scripts.${queueKeyOf(request)}\`, or pass \`repeatLast: true\` to replay its last entry down a longer branch.`);
 		return scripted;
 	};
 	const route = async (request, info) => {
 		const callIndex = calls++;
-		const isSeam = (seam.request !== void 0 ? request.name === seam.request : request.model === seam.model) && seamMatches++ === (seam.occurrence ?? 0);
+		const isSeam = request.name === seam.request && seamMatches++ === (seam.occurrence ?? 0);
 		if (isSeam && candidate) {
 			await takeScriptedSlot(request, info);
 			seamReached = true;
@@ -2620,7 +2778,7 @@ async function runSeam(machine, options) {
 		result = await runAgent(machine, {
 			...snapshot ? { snapshot } : { input: options.input },
 			...event ? { event } : {},
-			...options.isSuspended ? { isSuspended: options.isSuspended } : {},
+			...options.isIdle ? { isIdle: options.isIdle } : {},
 			...options.actors ? { actors: options.actors } : {},
 			events,
 			executors,
@@ -2673,6 +2831,196 @@ async function runSeam(machine, options) {
 	};
 }
 //#endregion
+//#region src/durable.ts
+/**
+* The durable host runner: {@link runDurableAgent} drives an executor-bound
+* agent machine on xstate's `createDurable` execution (`xstate/durable`),
+* with the agent event log as the journal.
+*
+* Where {@link replay} + `getAgentEffects` hand a host an effect list to run
+* itself, `runDurableAgent` owns the whole loop on the durable runtime:
+* invoked actors execute live through xstate's own runtime, every EXTERNAL
+* event (invoke completions included) is appended to the log, and a resume
+* folds the log back through pure transitions — an invoke whose completion is
+* already journaled is never re-started, so recorded model calls are never
+* re-executed. Crash recovery re-runs only the work that was still in flight.
+*
+* @module
+*/
+const DONE_ACTOR_EVENT_TYPE = "xstate.done.actor";
+const ERROR_ACTOR_EVENT_TYPE = "xstate.error.actor";
+function completionActorId(event) {
+	if (event.type !== DONE_ACTOR_EVENT_TYPE && event.type !== ERROR_ACTOR_EVENT_TYPE) return;
+	const actorId = event.actorId;
+	return typeof actorId === "string" ? actorId : void 0;
+}
+function createMailbox() {
+	const queue = [];
+	const waiters = [];
+	return {
+		push(event) {
+			const waiter = waiters.shift();
+			if (waiter) waiter(event);
+			else queue.push(event);
+		},
+		take() {
+			const next = queue.shift();
+			if (next !== void 0) return Promise.resolve(next);
+			return new Promise((resolve) => waiters.push(resolve));
+		},
+		size: () => queue.length
+	};
+}
+/**
+* Runs an agent machine as a durable execution: journal in, journal out.
+*
+* A fresh call starts from `input` and appends a reserved init entry; a
+* resume call folds `entries` through pure transitions first — invokes whose
+* completions are journaled are suppressed (their recorded results replay
+* instead of re-executing), while work that was in flight at the crash
+* re-executes live. After the journal, an optional `options.event` is
+* delivered. The call settles:
+*
+* - `done` when the machine reaches a final state, with `output`;
+* - `idle` when the frontier needs an external event the host has not
+*   supplied (no live work pending, or `isIdle` says the pending work is a
+*   human wait). Persist `entries` and call again with them later.
+*
+* ```ts
+* const first = await runDurableAgent(machine, { input, executors });
+* // ... persist first.entries; later, in a new process:
+* const next = await runDurableAgent(machine, {
+*   entries: first.entries,
+*   event: { type: "APPROVE" },
+*   executors,
+* });
+* ```
+*
+* @experimental Built on xstate's experimental `xstate/durable` entrypoint.
+*/
+async function runDurableAgent(machine, options = {}) {
+	const bound = options.executors ? provideExecutors(machine, options.executors, {
+		actors: options.actors,
+		onChunk: options.onChunk,
+		onTrace: options.onTrace
+	}) : options.actors ? machine.provide({ actors: options.actors }) : machine;
+	const machineId = machine.config.id ?? machine.id ?? "(machine)";
+	const machineVersion = options.machineVersion ?? require_decision.resolveMachineVersion(machine);
+	const priorEntries = options.entries ?? [];
+	if (priorEntries.length > 0) require_setup_agent.validateReplayEntries(priorEntries, {
+		machineId,
+		machineVersion
+	}, "Durable journal entries");
+	const hasInit = priorEntries[0]?.event.type === require_setup_agent.AGENT_INIT_EVENT_TYPE;
+	const input = hasInit ? priorEntries[0].event.input : options.input;
+	const journal = priorEntries.slice(hasInit ? 1 : 0).map((entry) => entry.event);
+	const journaledCompletions = /* @__PURE__ */ new Map();
+	for (const event of journal) {
+		const actorId = completionActorId(event);
+		if (actorId !== void 0) journaledCompletions.set(actorId, (journaledCompletions.get(actorId) ?? 0) + 1);
+	}
+	const mailbox = createMailbox();
+	const rootAddress = machineId;
+	const suppressedChildren = /* @__PURE__ */ new WeakSet();
+	const startsSeen = /* @__PURE__ */ new Map();
+	const liveInFlight = /* @__PURE__ */ new Set();
+	const findChildRef = (effect) => {
+		const raw = effect;
+		const candidates = [raw.actor, ...Array.isArray(raw.args) ? raw.args : []];
+		for (const candidate of candidates) {
+			const ref = candidate;
+			if (ref && typeof ref.sessionId === "string" && typeof ref.id === "string") return ref;
+		}
+	};
+	let replaying = journal.length > 0;
+	const execution = (0, xstate_durable.createDurable)(bound, {
+		sendEvent(source, target, event) {
+			if (target.address === rootAddress) {
+				mailbox.push(event);
+				return;
+			}
+			(0, xstate.deliverEvent)(source, target, event);
+		},
+		runtime(_metadata, effect) {
+			const type = effect.type;
+			if (type === "@xstate.spawn" || type === "@xstate.start") {
+				const child = findChildRef(effect);
+				if (!child) return {};
+				if (type === "@xstate.spawn") {
+					const seen = (startsSeen.get(child.id) ?? 0) + 1;
+					startsSeen.set(child.id, seen);
+					if (seen <= (journaledCompletions.get(child.id) ?? 0)) suppressedChildren.add(child);
+					else liveInFlight.add(child.id);
+				}
+				if (suppressedChildren.has(child)) return {
+					spawnActor() {},
+					startActor() {}
+				};
+			}
+			return {};
+		},
+		executeAction(action) {
+			if (replaying) return;
+			action.exec?.();
+		},
+		waitForEvent() {
+			return mailbox.take();
+		}
+	});
+	const entries = [...priorEntries];
+	const entryOptions = {
+		machineVersion,
+		verification: options.verification ?? false
+	};
+	const appendEntry = (event) => {
+		const entry = require_setup_agent.createReplayEntry(machine, entries, event, entryOptions);
+		entries.push(entry);
+		options.onEntry?.(entry);
+	};
+	if (!hasInit) {
+		const entry = require_setup_agent.initEntry(machine, input, entryOptions);
+		entries.push(entry);
+		options.onEntry?.(entry);
+	}
+	const sessions = /* @__PURE__ */ new Map();
+	let journalIndex = 0;
+	let liveEventConsumed = false;
+	let [snapshot, effects] = execution.initialTransition(input);
+	for (;;) {
+		const captured = await execution.executeEffects(effects);
+		for (const rootEvent of captured) mailbox.push(rootEvent.event);
+		const machineSnapshot = snapshot;
+		if (machineSnapshot.status === "done") return {
+			status: "done",
+			output: machineSnapshot.output,
+			snapshot,
+			entries
+		};
+		if (machineSnapshot.status === "error") throw machineSnapshot.error;
+		let event;
+		let fromJournal = false;
+		if (journalIndex < journal.length) {
+			event = require_setup_agent.rebindActorSession(journal[journalIndex], machineSnapshot, sessions);
+			journalIndex++;
+			fromJournal = true;
+			replaying = journalIndex < journal.length;
+		} else if (mailbox.size() > 0) event = await mailbox.take();
+		else if (liveInFlight.size > 0 && !(options.isIdle?.(snapshot) ?? false)) event = await mailbox.take();
+		else if (!liveEventConsumed && options.event !== void 0) {
+			event = options.event;
+			liveEventConsumed = true;
+		} else return {
+			status: "idle",
+			snapshot,
+			entries
+		};
+		const completedId = completionActorId(event);
+		if (completedId !== void 0) liveInFlight.delete(completedId);
+		if (!fromJournal) appendEntry(event);
+		[snapshot, effects] = execution.transition(snapshot, event);
+	}
+}
+//#endregion
 exports.AGENT_EVENT_SCHEMA_VERSION = require_event_log_store.AGENT_EVENT_SCHEMA_VERSION;
 exports.AGENT_INIT_EVENT_TYPE = require_setup_agent.AGENT_INIT_EVENT_TYPE;
 exports.AGENT_TRACE_SCHEMA_VERSION = AGENT_TRACE_SCHEMA_VERSION;
@@ -2683,13 +3031,13 @@ exports.AgentEventLogConflictError = require_event_log_store.AgentEventLogConfli
 exports.AgentIdleError = AgentIdleError;
 exports.AgentIllegalResumeEventError = AgentIllegalResumeEventError;
 exports.AgentLintError = AgentLintError;
+exports.AgentMaxModelCallsExceededError = AgentMaxModelCallsExceededError;
 exports.AgentReplayDivergenceError = require_setup_agent.AgentReplayDivergenceError;
 exports.AgentReplayMachineMismatchError = require_setup_agent.AgentReplayMachineMismatchError;
 exports.AgentSnapshotVersionMismatchError = AgentSnapshotVersionMismatchError;
 exports.NonSerializableAgentEventError = require_event_log_store.NonSerializableAgentEventError;
 exports.appendMessages = require_setup_agent.appendMessages;
 exports.assertAgentLogEntry = require_event_log_store.assertAgentLogEntry;
-exports.assertAgentMachine = assertAgentMachine;
 exports.assertEventLogStoreConformance = require_event_log_store.assertEventLogStoreConformance;
 exports.assertJsonSerializable = require_event_log_store.assertJsonSerializable;
 exports.assistantMessage = require_decision.assistantMessage;
@@ -2716,6 +3064,8 @@ exports.getCallUsage = require_decision.getCallUsage;
 exports.getJsonSchema = require_decision.getJsonSchema;
 exports.getJsonSchemaSync = require_decision.getJsonSchemaSync;
 exports.getMachineStructuralHash = require_decision.getMachineStructuralHash;
+exports.getSnapshotNodes = getSnapshotNodes;
+exports.getSnapshotRequests = getSnapshotRequests;
 exports.getStateMeta = require_decision.getStateMeta;
 exports.initEntry = require_setup_agent.initEntry;
 exports.inspectTransitions = inspectTransitions;
@@ -2727,12 +3077,12 @@ exports.parseAgentEvent = require_decision.parseAgentEvent;
 exports.parseModelRef = require_decision.parseModelRef;
 exports.parseOutput = require_decision.parseOutput;
 exports.parseStructuredEnvelope = require_decision.parseStructuredEnvelope;
-exports.persistSnapshot = require_decision.persistSnapshot;
 exports.provideExecutors = provideExecutors;
 exports.renderDecisionAttempts = require_decision.renderDecisionAttempts;
 exports.replay = require_setup_agent.replay;
 exports.resolveDecision = require_decision.resolveDecision;
 exports.runAgent = runAgent;
+exports.runDurableAgent = runDurableAgent;
 exports.runSeam = runSeam;
 exports.serializeTraceEvent = serializeTraceEvent;
 Object.defineProperty(exports, "setupAgent", {
@@ -2746,4 +3096,3 @@ exports.systemMessage = require_decision.systemMessage;
 exports.toolMessage = require_decision.toolMessage;
 exports.traceTransitions = traceTransitions;
 exports.userMessage = require_decision.userMessage;
-exports.verifyReplay = require_setup_agent.verifyReplay;