@statelyai/agent 2.0.0-alpha.19 → 2.0.0-alpha.21

package/dist/index.mjs

@@ -1,8 +1,9 @@
 import { t as AgentError } from "./errors-CeSXQx0v.mjs";
-import { _ as resolveAgentStep, a as AGENT_USAGE_EVENT_TYPE, b as messagesSchema, c as createReplayEntry, d as initEntry, f as replay, g as initialAgentStep, h as getInvokeEffectMetadata, i as AGENT_INIT_EVENT_TYPE, l as diffEventLogs, m as executeAgentRequest, n as getAgentSchemas, o as AgentReplayDivergenceError, p as validateReplayEntries, r as setupAgent, s as AgentReplayMachineMismatchError, t as createAgentSchemas, u as getAgentEffects, v as transitionAgentStep, y as appendMessages } from "./setup-agent-CPFPN06s.mjs";
-import { A as isUnboundPlaceholder, B as getMachineStructuralHash, C as parseStructuredEnvelope, D as getMachineIdlePredicate, E as executorBoundLogics, G as toolMessage, H as isStandardSchema, I as findNonSerializableContextPaths, K as userMessage, L as getAgentMessages, O as getMachineStaticTransitionTargets, P as assistantMessage, R as getJsonSchema, S as parseOutput, U as resolveMachineVersion, V as getStateMeta, W as systemMessage, _ as getAgentOutputMode, a as resolveDecision, b as normalizeGeneratorResult, c as AGENT_USAGE_TOKEN_FIELDS, f as bindRequestExecutor, h as createTextLogic, i as renderDecisionAttempts, k as getRegisteredAgentExecutionOptions, o as getAcceptedEvents, p as buildEnvelopeSchema, q as validateSchemaSync, r as isDecisionLogic, s as parseAgentEvent, t as AgentDecisionExhaustedError, u as INTERPRET_SOURCE, v as getCallUsage, x as parseModelRef, y as isTextLogic, z as getJsonSchemaSync } from "./decision-DsIkEuHz.mjs";
+import { _ as resolveAgentStep, a as AGENT_USAGE_EVENT_TYPE, b as messagesSchema, c as createReplayEntry, d as initEntry, f as replay, g as initialAgentStep, h as getInvokeEffectMetadata, i as AGENT_INIT_EVENT_TYPE, l as diffEventLogs, m as executeAgentRequest, n as getAgentSchemas, o as AgentReplayDivergenceError, p as validateReplayEntries, r as setupAgent, s as AgentReplayMachineMismatchError, t as createAgentSchemas, u as getAgentEffects, v as transitionAgentStep, y as appendMessages } from "./setup-agent-DqqdcdNh.mjs";
+import { A as getMachineStaticTransitionTargets, B as getJsonSchema, C as parseModelRef, G as resolveMachineVersion, H as getMachineStructuralHash, I as assistantMessage, J as userMessage, K as systemMessage, M as isUnboundPlaceholder, O as executorBoundLogics, R as findNonSerializableContextPaths, S as normalizeGeneratorResult, T as parseStructuredEnvelope, U as getStateMeta, V as getJsonSchemaSync, W as isStandardSchema, Y as validateSchemaSync, _ as createTextLogic, a as resolveDecision, b as getCallUsage, c as AGENT_USAGE_TOKEN_FIELDS, d as INTERPRET_SOURCE, h as buildEnvelopeSchema, i as renderDecisionAttempts, j as getRegisteredAgentExecutionOptions, k as getMachineIdlePredicate, m as bindRequestExecutor, o as getAcceptedEvents, q as toolMessage, r as isDecisionLogic, s as parseAgentEvent, t as AgentDecisionExhaustedError, w as parseOutput, x as isTextLogic, y as getAgentOutputMode, z as getAgentMessages } from "./decision-JWx6n3xR.mjs";
 import { a as assertJsonSerializable, i as assertAgentLogEntry, n as AgentEventLogConflictError, o as createInMemoryEventLogStore, r as NonSerializableAgentEventError, s as assertEventLogStoreConformance, t as AGENT_EVENT_SCHEMA_VERSION } from "./event-log-store-DmIDosD6.mjs";
-import { createActor, createAsyncLogic, getNextTransitions, isMachineSnapshot } from "xstate";
+import { createActor, createAsyncLogic, deliverEvent, getNextTransitions, isMachineSnapshot } from "xstate";
+import { createDurable } from "xstate/durable";
 //#region src/internal/state-request-pass.ts
 async function runTextPhase(stateRequest, baseMessages, deps) {
 	const { model, system } = stateRequest;
@@ -284,7 +285,7 @@ function serializeTraceEvent(event, options = {}) {
 	return out;
 }
 function snapshotNodes(snapshot) {
-	return (snapshot._nodes ?? []).map((raw) => {
+	return (snapshot.nodes ?? []).map((raw) => {
 		const node = raw;
 		return {
 			id: node.id ?? "",
@@ -567,9 +568,13 @@ function invokingActorOf(self, runCtx) {
 * identical event shapes by construction. @internal
 */
 function bindTextLogic(logic, runCtx) {
-	return logic.withExecutor(async ({ request, self: selfArg, signal }) => {
+	return logic.withExecutor(async ({ request: rawRequest, self: selfArg, signal }) => {
 		const self = selfArg;
 		const { id, src } = selfIdAndSrc(self);
+		const request = rawRequest.name === void 0 && src !== "" && src !== "agent.generateText" && src !== "agent.streamText" ? {
+			...rawRequest,
+			name: src
+		} : rawRequest;
 		const executor = logic.mode === "stream" ? runCtx.streamText : runCtx.generateText;
 		if (!executor) throw new Error(`No '${logic.mode === "stream" ? "streamText" : "generateText"}' executor provided.`);
 		const requestWithTools = {
@@ -1159,6 +1164,7 @@ function createAgentSession(machine, options, lifecycle) {
 		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 = getAgentMessages(effectiveSnapshot);
@@ -2082,8 +2088,8 @@ function lintAgentMachine(machine, options = {}) {
 	return diagnostics;
 }
 /**
-* Thrown by `lintAgentMachine(machine, { throw: true })` when lint finds
-* failing diagnostics.
+* Thrown by `lintAgentMachine(machine, { throw: true })` (and its
+* {@link assertAgentMachine} alias) 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.
 */
@@ -2096,6 +2102,26 @@ var AgentLintError = class extends AgentError {
 		this.diagnostics = diagnostics;
 	}
 };
+/**
+* Asserts a machine passes {@link lintAgentMachine}: returns silently when
+* clean, throws {@link AgentLintError} (with the findings on `.diagnostics`)
+* otherwise — sugar for `lintAgentMachine(machine, { ...options, throw: true })`.
+* 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 = {}) {
+	lintAgentMachine(machine, {
+		...options,
+		throw: true
+	});
+}
 function pendingInvokes(step) {
 	const out = [];
 	for (const action of step.actions) {
@@ -2122,6 +2148,21 @@ function takeFromQueue(channel, src) {
 * the real transition logic. Returns the terminal `status`, final `snapshot`,
 * and a `trail` of every step taken.
 *
+* Decisions run through the live run's own validation/retry core,
+* {@link resolveDecision}, with the script standing in for the model: each
+* attempt consumes the next queued {@link ChosenEvent} for that src, so an
+* unknown, payload-invalid, or guard-rejected event is NOT silently swallowed
+* — the next queued decision is tried, exactly as a live run re-asks the
+* model. The decision logic's `maxRetries` caps attempts as it would live;
+* when retries continue past the end of the queue, the last queued decision
+* repeats (a scripted model that insists). The repeat applies only within one
+* decision request's retries — each new decision request must have its own
+* queued entry, or the dry-script error throws as usual. Exhausting all
+* attempts delivers
+* the resulting {@link AgentDecisionExhaustedError} to the machine as the
+* decision invoke's error (so an `onError` transition observes it, as it
+* would live); with no `onError` to catch it, it is thrown.
+*
 * Throws a descriptive error when the script runs dry mid-request, naming the
 * pending request's kind, src, and id so the missing scripted response is
 * obvious.
@@ -2130,7 +2171,10 @@ function takeFromQueue(channel, src) {
 * ```ts
 * const { status, snapshot } = simulateAgent(machine, {
 *   input: { topic: 'state machines' },
-*   script: { decisions: { 'agent.decide': [{ type: 'END' }] } },
+*   script: {
+*     decisions: { 'agent.decide': [{ type: 'ESCALATE' }] },
+*     events: [{ type: 'APPROVE' }], // crosses the human gate
+*   },
 * });
 * ```
 */
@@ -2139,11 +2183,12 @@ async function simulateAgent(machine, options) {
 	const script = {
 		text: mapValues(options.script.text ?? {}, (arr) => [...arr]),
 		decisions: mapValues(options.script.decisions ?? {}, (arr) => [...arr]),
-		invokes: mapValues(options.script.invokes ?? {}, (arr) => [...arr])
+		invokes: mapValues(options.script.invokes ?? {}, (arr) => [...arr]),
+		events: [...options.script.events ?? []]
 	};
 	if (options.script.userInput?.length) script.invokes[USER_INPUT_SRC] = [...options.script.userInput, ...script.invokes[USER_INPUT_SRC] ?? []];
 	let step = initialAgentStep(machine, options.input);
-	const trail = [];
+	const trail = [{ state: step.snapshot.value }];
 	for (let i = 0; i < maxSteps; i++) {
 		if (step.done) return {
 			status: "done",
@@ -2153,14 +2198,10 @@ async function simulateAgent(machine, options) {
 		const request = step.requests[0];
 		if (request) {
 			if (request.kind === "decision") {
-				const decisionSrc = new Map(pendingInvokes(step).map((invoke) => [invoke.id, invoke.src])).get(request.id) ?? request.id;
-				const taken = takeFromQueue(script.decisions, decisionSrc);
-				if (!taken.found) throw scriptDryError("decision", decisionSrc, request.id, request);
-				step = transitionAgentStep(machine, step, taken.value);
-				trail.push({
-					state: step.snapshot.value,
-					appliedEvent: taken.value
-				});
+				const invokeMeta = findInvokeMetadata(step, request.id);
+				const src = invokeMeta?.src ?? request.id;
+				const decisionSrc = src in (script.decisions ?? {}) ? src : request.id in (script.decisions ?? {}) ? request.id : src;
+				step = await applyScriptedDecision(machine, step, request, decisionSrc, invokeMeta?.logic, script, trail);
 				continue;
 			}
 			const taken = takeFromQueue(script.text, request.src);
@@ -2191,6 +2232,18 @@ async function simulateAgent(machine, options) {
 			});
 			continue;
 		}
+		const external = script.events;
+		if (external.length > 0) {
+			const event = external.shift();
+			if (!step.snapshot.can(event)) throw new Error(`simulateAgent: scripted external event '${event.type}' cannot be taken in state ${JSON.stringify(step.snapshot.value)} (no handler, or its guard rejected it). A live run's send would be silently dropped here; fix the script's \`events\` queue.`);
+			step = transitionAgentStep(machine, step, event);
+			trail.push({
+				state: step.snapshot.value,
+				appliedEvent: event,
+				external: true
+			});
+			continue;
+		}
 		return {
 			status: "idle",
 			snapshot: step.snapshot,
@@ -2203,6 +2256,66 @@ async function simulateAgent(machine, options) {
 		trail
 	};
 }
+async function applyScriptedDecision(machine, step, request, decisionSrc, invokeLogic, script, trail) {
+	const dequeued = [];
+	const decide = async () => {
+		const taken = takeFromQueue(script.decisions, decisionSrc);
+		if (taken.found) {
+			dequeued.push(taken.value);
+			return { event: taken.value };
+		}
+		if (dequeued.length === 0) throw scriptDryError("decision", decisionSrc, request.id, request);
+		return { event: dequeued[dequeued.length - 1] };
+	};
+	const maxRetries = (isDecisionLogic(invokeLogic) ? invokeLogic : resolveRegisteredDecisionLogic(machine, decisionSrc))?.maxRetries;
+	let chosen;
+	try {
+		chosen = await resolveDecision(request, { decide }, {
+			maxRetries,
+			canTake: (event) => step.snapshot.can(event)
+		});
+	} catch (error) {
+		if (!(error instanceof AgentDecisionExhaustedError)) throw error;
+		const next = transitionAgentStep(machine, step, {
+			type: "xstate.error.actor",
+			actorId: request.id,
+			...sessionIdOf(step.snapshot, request.id),
+			error
+		});
+		if (next.snapshot.status === "error") throw error;
+		trail.push({
+			state: next.snapshot.value,
+			rejectedEvents: dequeued
+		});
+		return next;
+	}
+	const next = transitionAgentStep(machine, step, chosen);
+	const rejected = dequeued.slice(0, -1);
+	trail.push({
+		state: next.snapshot.value,
+		appliedEvent: chosen,
+		...rejected.length > 0 ? { rejectedEvents: rejected } : {}
+	});
+	return next;
+}
+function findInvokeMetadata(step, id) {
+	for (const action of step.actions) {
+		const metadata = getInvokeEffectMetadata(action);
+		if (metadata?.id !== id) continue;
+		return {
+			...typeof metadata.src === "string" ? { src: metadata.src } : {},
+			logic: metadata.logic ?? (typeof metadata.src === "object" ? metadata.src : void 0)
+		};
+	}
+}
+function resolveRegisteredDecisionLogic(machine, src) {
+	const candidate = getRegisteredAgentExecutionOptions(machine).actors?.[src] ?? machine.sources?.actors?.[src];
+	return isDecisionLogic(candidate) ? candidate : void 0;
+}
+function sessionIdOf(snapshot, id) {
+	const child = snapshot.children[id];
+	return typeof child?.sessionId === "string" ? { sessionId: child.sessionId } : {};
+}
 function mapValues(obj, fn) {
 	return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, fn(value)]));
 }
@@ -2239,6 +2352,10 @@ async function explore(machine, options, stopWhen) {
 	const advance = (step) => {
 		let current = step;
 		for (let i = 0; i < MAX_ADVANCE_STEPS; i++) {
+			if (stopWhen?.(current.snapshot)) return {
+				step: current,
+				hit: true
+			};
 			if (current.done) return { step: current };
 			const request = current.requests[0];
 			if (request && request.kind === "text") {
@@ -2271,8 +2388,8 @@ async function explore(machine, options, stopWhen) {
 			hitPathCap = true;
 			return;
 		}
-		const { step: settled, blockedSrc } = advance(step);
-		if (stopWhen?.(settled.snapshot)) {
+		const { step: settled, blockedSrc, hit } = advance(step);
+		if (hit) {
 			witness = path;
 			return;
 		}
@@ -2367,8 +2484,11 @@ async function explorePaths(machine, options = {}) {
 	return (await explore(machine, options)).report;
 }
 /**
-* Answers "can the machine reach `statePath`?" by exploring its branches (a
-* thin wrapper over {@link explorePaths}). Returns
+* Answers "can the machine reach this?" by exploring its branches (a thin
+* wrapper over {@link explorePaths}). The target is either a state path string
+* (`snapshot.matches(...)` semantics) or a snapshot predicate — the predicate
+* form checks any property (a context invariant, a tag, a state+context
+* combination) without reifying a sentinel state for it. Returns
 * `{ reachable: true, witness }` with the event sequence that reaches it, or
 * `{ reachable: false }`.
 *
@@ -2377,11 +2497,21 @@ async function explorePaths(machine, options = {}) {
 * const { reachable, witness } = await canReach(refundMachine, 'denied', { input: { request: 'x', amount: 5000 } });
 * // reachable → true; witness → [{ type: 'NEEDS_REVIEW' }, { type: 'DENY' }]
 * ```
+*
+* @example Predicate target — a violation property, no sentinel state needed
+* ```ts
+* const violation = await canReach(
+*   refundMachine,
+*   (snapshot) => snapshot.matches('issued') && !snapshot.context.approved,
+*   { input: { amount: 5000 } },
+* );
+* // violation.reachable → false is the safety proof
+* ```
 */
-async function canReach(machine, statePath, options = {}) {
-	const { witness } = await explore(machine, options, (snapshot) => {
+async function canReach(machine, target, options = {}) {
+	const { witness } = await explore(machine, options, typeof target === "function" ? target : (snapshot) => {
 		try {
-			return snapshot.matches(statePath);
+			return snapshot.matches(target);
 		} catch {
 			return false;
 		}
@@ -2713,6 +2843,8 @@ async function runSeam(machine, options) {
 	let calls = 0;
 	let seamMatches = 0;
 	let seamOutput;
+	let seamUsage;
+	const callLog = [];
 	let seamReached = false;
 	let callsBeforeSeam = -1;
 	let seamStateAt = 0;
@@ -2737,6 +2869,15 @@ async function runSeam(machine, options) {
 	const route = async (request, info) => {
 		const callIndex = calls++;
 		const isSeam = request.name === seam.request && seamMatches++ === (seam.occurrence ?? 0);
+		const ledger = (source) => {
+			callLog.push({
+				...request.name !== void 0 ? { name: request.name } : {},
+				model: request.model,
+				key: queueKeyOf(request),
+				source,
+				seam: isSeam
+			});
+		};
 		if (isSeam && candidate) {
 			await takeScriptedSlot(request, info);
 			seamReached = true;
@@ -2745,15 +2886,19 @@ async function runSeam(machine, options) {
 			seamEventAt = liveEvents;
 			const result = await candidate(request, info);
 			seamOutput = await seamOutputOf(result, request);
+			seamUsage = getCallUsage(result);
+			ledger("candidate");
 			return result;
 		}
 		const scripted = await scriptedAnswer(request, info);
+		ledger("script");
 		if (!isSeam) return scripted;
 		seamReached = true;
 		callsBeforeSeam = callIndex;
 		seamStateAt = statePath.length;
 		seamEventAt = liveEvents;
 		seamOutput = scripted.output;
+		seamUsage = scripted.usage;
 		return scripted;
 	};
 	const executors = {
@@ -2815,7 +2960,9 @@ async function runSeam(machine, options) {
 	return {
 		result,
 		seamOutput,
+		...seamUsage !== void 0 ? { seamUsage } : {},
 		callsBeforeSeam,
+		calls: callLog,
 		before: {
 			statePath: statePath.slice(0, splitStateAt),
 			events: events.slice(0, splitAt)
@@ -2827,4 +2974,209 @@ async function runSeam(machine, options) {
 	};
 }
 //#endregion
-export { AGENT_EVENT_SCHEMA_VERSION, AGENT_INIT_EVENT_TYPE, AGENT_TRACE_SCHEMA_VERSION, AGENT_USAGE_EVENT_TYPE, AgentDecisionExhaustedError, AgentError, AgentEventLogConflictError, AgentIdleError, AgentIllegalResumeEventError, AgentLintError, AgentMaxModelCallsExceededError, AgentReplayDivergenceError, AgentReplayMachineMismatchError, AgentSnapshotVersionMismatchError, NonSerializableAgentEventError, appendMessages, assertAgentLogEntry, assertEventLogStoreConformance, assertJsonSerializable, assistantMessage, bindRequestExecutor, buildEnvelopeSchema, canReach, createAgentActor, createAgentRun, createAgentSchemas, createInMemoryEventLogStore, createReplayEntry, createScriptedExecutors, createTextLogic, diffEventLogs, executeAgentRequest, explorePaths, generateResult, getAcceptedEvents, getAgentEffects, getAgentMessages, getAgentOutputMode, getAgentSchemas, getCallUsage, getJsonSchema, getJsonSchemaSync, getMachineStructuralHash, getSnapshotNodes, getSnapshotRequests, getStateMeta, initEntry, inspectTransitions, isStandardSchema, lintAgentMachine, matchesTrajectory, messagesSchema, parseAgentEvent, parseModelRef, parseOutput, parseStructuredEnvelope, provideExecutors, renderDecisionAttempts, replay, resolveDecision, runAgent, runSeam, serializeTraceEvent, setupAgent, simulateAgent, systemMessage, toolMessage, traceTransitions, userMessage };
+//#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;
+}
+/** Thrown by the adapter's `waitForEvent` when nothing can produce an event. */
+const IDLE = Symbol("agent.durable.idle");
+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 ?? resolveMachineVersion(machine);
+	const priorEntries = options.entries ?? [];
+	if (priorEntries.length > 0) validateReplayEntries(priorEntries, {
+		machineId,
+		machineVersion
+	}, "Durable journal entries");
+	const hasInit = priorEntries[0]?.event.type === 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 storedExecutionId = hasInit ? priorEntries[0].metadata?.executionId : void 0;
+	const executionId = typeof storedExecutionId === "string" ? storedExecutionId : hasInit ? priorEntries[0].id : crypto.randomUUID();
+	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;
+	let liveEventConsumed = false;
+	let latestSnapshot;
+	const execution = createDurable(bound, {
+		executionId,
+		sendEvent(source, target, event) {
+			if (target.address === rootAddress) {
+				mailbox.push(event);
+				return;
+			}
+			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?.();
+		},
+		async waitForEvent() {
+			if (mailbox.size() > 0) return await mailbox.take();
+			if (liveInFlight.size > 0 && !(options.isIdle?.(latestSnapshot) ?? false)) return await mailbox.take();
+			if (!liveEventConsumed && options.event !== void 0) {
+				liveEventConsumed = true;
+				return options.event;
+			}
+			throw IDLE;
+		}
+	});
+	const entries = [...priorEntries];
+	const entryOptions = {
+		machineVersion,
+		verification: options.verification ?? false
+	};
+	const appendEntry = (event) => {
+		const entry = createReplayEntry(machine, entries, event, entryOptions);
+		entries.push(entry);
+		options.onEntry?.(entry);
+	};
+	if (!hasInit) {
+		const entry = initEntry(machine, input, {
+			...entryOptions,
+			metadata: { executionId }
+		});
+		entries.push(entry);
+		options.onEntry?.(entry);
+	}
+	let journalIndex = 0;
+	let [snapshot, effects] = execution.initialTransition(input);
+	latestSnapshot = snapshot;
+	for (;;) {
+		await execution.executeEffects(effects);
+		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 = journal[journalIndex];
+			journalIndex++;
+			fromJournal = true;
+			replaying = journalIndex < journal.length;
+		} else try {
+			event = await execution.waitForEvent();
+		} catch (error) {
+			if (error === IDLE) return {
+				status: "idle",
+				snapshot,
+				entries
+			};
+			throw error;
+		}
+		const completedId = completionActorId(event);
+		if (completedId !== void 0) liveInFlight.delete(completedId);
+		if (!fromJournal) appendEntry(event);
+		[snapshot, effects] = execution.transition(snapshot, event);
+		latestSnapshot = snapshot;
+	}
+}
+//#endregion
+export { AGENT_EVENT_SCHEMA_VERSION, AGENT_INIT_EVENT_TYPE, AGENT_TRACE_SCHEMA_VERSION, AGENT_USAGE_EVENT_TYPE, AgentDecisionExhaustedError, AgentError, AgentEventLogConflictError, AgentIdleError, AgentIllegalResumeEventError, AgentLintError, AgentMaxModelCallsExceededError, AgentReplayDivergenceError, AgentReplayMachineMismatchError, AgentSnapshotVersionMismatchError, NonSerializableAgentEventError, appendMessages, assertAgentLogEntry, assertAgentMachine, assertEventLogStoreConformance, assertJsonSerializable, assistantMessage, bindRequestExecutor, buildEnvelopeSchema, canReach, createAgentActor, createAgentRun, createAgentSchemas, createInMemoryEventLogStore, createReplayEntry, createScriptedExecutors, createTextLogic, diffEventLogs, executeAgentRequest, explorePaths, generateResult, getAcceptedEvents, getAgentEffects, getAgentMessages, getAgentOutputMode, getAgentSchemas, getCallUsage, getJsonSchema, getJsonSchemaSync, getMachineStructuralHash, getSnapshotNodes, getSnapshotRequests, getStateMeta, initEntry, inspectTransitions, isStandardSchema, lintAgentMachine, matchesTrajectory, messagesSchema, parseAgentEvent, parseModelRef, parseOutput, parseStructuredEnvelope, provideExecutors, renderDecisionAttempts, replay, resolveDecision, runAgent, runDurableAgent, runSeam, serializeTraceEvent, setupAgent, simulateAgent, systemMessage, toolMessage, traceTransitions, userMessage };

package/dist/machines.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_setup_agent = require("./setup-agent-BFA4VKpN.cjs");
+const require_setup_agent = require("./setup-agent-91FSuZbB.cjs");
 //#region src/machines/internal.ts
 /** The builtin inline text request every preset lowers a request entry to. */
 const GENERATE_TEXT_SRC = "agent.generateText";

package/dist/machines.d.cts

@@ -1,4 +1,4 @@
-import { c as AgentTools, v as StandardSchemaV1 } from "./types-pJ5Hn8fv.cjs";
+import { c as AgentTools, v as StandardSchemaV1 } from "./types-DSdj2tGs.cjs";
 import { AnyStateMachine } from "xstate";
 
 //#region src/machines/tool-loop.d.ts

package/dist/machines.d.mts

@@ -1,4 +1,4 @@
-import { c as AgentTools, v as StandardSchemaV1 } from "./types-DYpK3QF4.mjs";
+import { c as AgentTools, v as StandardSchemaV1 } from "./types-CvWRGFxP.mjs";
 import { AnyStateMachine } from "xstate";
 
 //#region src/machines/tool-loop.d.ts

package/dist/machines.mjs

@@ -1,4 +1,4 @@
-import { r as setupAgent } from "./setup-agent-CPFPN06s.mjs";
+import { r as setupAgent } from "./setup-agent-DqqdcdNh.mjs";
 //#region src/machines/internal.ts
 /** The builtin inline text request every preset lowers a request entry to. */
 const GENERATE_TEXT_SRC = "agent.generateText";

package/dist/otel.d.cts

@@ -1,4 +1,4 @@
-import { d as AgentTraceEvent } from "./run-agent--4bbms-D.cjs";
+import { d as AgentTraceEvent } from "./run-agent-Do094mGu.cjs";
 import { Attributes, Tracer, TracerProvider } from "@opentelemetry/api";
 
 //#region src/otel/index.d.ts

package/dist/otel.d.mts

@@ -1,4 +1,4 @@
-import { d as AgentTraceEvent } from "./run-agent-CwmzAZwj.mjs";
+import { d as AgentTraceEvent } from "./run-agent-DBNI8ETM.mjs";
 import { Attributes, Tracer, TracerProvider } from "@opentelemetry/api";
 
 //#region src/otel/index.d.ts

package/dist/{run-agent-CwmzAZwj.d.mts → run-agent-DBNI8ETM.d.mts}

@@ -1,6 +1,6 @@
-import { T as WithAgentInputSchema, c as AgentTools, d as ChosenEvent, h as InferInput, n as AgentMessage, v as StandardSchemaV1 } from "./types-DYpK3QF4.mjs";
+import { T as WithAgentInputSchema, c as AgentTools, d as ChosenEvent, h as InferInput, n as AgentMessage, v as StandardSchemaV1 } from "./types-CvWRGFxP.mjs";
 import { t as AgentError } from "./errors-C9rxnWbX.mjs";
-import { H as AgentRequestSource, N as AgentDecisionRequest, V as AgentRequestOptions, d as AgentTextRequest, f as AgentUsage, l as AgentRequestExecutors, p as AgentUserInput, t as AgentCallUsage, u as AgentRequestMode, z as AgentEventDescriptor } from "./text-logic-Er5KkTX6.mjs";
+import { H as AgentRequestSource, N as AgentDecisionRequest, V as AgentRequestOptions, d as AgentTextRequest, f as AgentUsage, l as AgentRequestExecutors, p as AgentUserInput, t as AgentCallUsage, u as AgentRequestMode, z as AgentEventDescriptor } from "./text-logic-BR5twXCv.mjs";
 import { i as AgentLogEntry, o as JsonValue } from "./event-log-store-hrA1vqtN.mjs";
 import { AnyActorLogic, AnyActorRef, AnyMachineSnapshot, AnyStateMachine, AsyncActorLogic, EmittedFrom, EventFromLogic, EventObject, ExecutableActionObject, InputFrom, InspectionEvent, OutputFrom, Snapshot, SnapshotFrom, createActor } from "xstate";
 
@@ -934,7 +934,7 @@ declare class AgentMaxModelCallsExceededError extends AgentError {
  * declared input schema — and machines reached through `.provide(...)`, which
  * drops the brand — fall back to xstate's `InputFrom`.
  */
-type AgentInputFrom<TMachine extends AnyStateMachine> = InputFrom<TMachine> extends WithAgentInputSchema<infer TInputSchema> ? [TInputSchema] extends [StandardSchemaV1] ? InferInput<TInputSchema> : InputFrom<TMachine> : InputFrom<TMachine>;
+type AgentInputFrom<TMachine extends AnyStateMachine> = [NonNullable<InputFrom<TMachine>>] extends [WithAgentInputSchema<infer TInputSchema>] ? [TInputSchema] extends [StandardSchemaV1] ? InferInput<TInputSchema> : InputFrom<TMachine> : InputFrom<TMachine>;
 /**
  * Runs an agent machine to completion or idle: a `createActor` host that
  * binds `options`' host executors onto the machine's `agent.*`/`TextLogic`/

package/dist/{run-agent--4bbms-D.d.cts → run-agent-Do094mGu.d.cts}

@@ -1,6 +1,6 @@
-import { T as WithAgentInputSchema, c as AgentTools, d as ChosenEvent, h as InferInput, n as AgentMessage, v as StandardSchemaV1 } from "./types-pJ5Hn8fv.cjs";
+import { T as WithAgentInputSchema, c as AgentTools, d as ChosenEvent, h as InferInput, n as AgentMessage, v as StandardSchemaV1 } from "./types-DSdj2tGs.cjs";
 import { t as AgentError } from "./errors-BQRk9eiZ.cjs";
-import { H as AgentRequestSource, N as AgentDecisionRequest, V as AgentRequestOptions, d as AgentTextRequest, f as AgentUsage, l as AgentRequestExecutors, p as AgentUserInput, t as AgentCallUsage, u as AgentRequestMode, z as AgentEventDescriptor } from "./text-logic-Cavva1W6.cjs";
+import { H as AgentRequestSource, N as AgentDecisionRequest, V as AgentRequestOptions, d as AgentTextRequest, f as AgentUsage, l as AgentRequestExecutors, p as AgentUserInput, t as AgentCallUsage, u as AgentRequestMode, z as AgentEventDescriptor } from "./text-logic-Mmbgb2jy.cjs";
 import { i as AgentLogEntry, o as JsonValue } from "./event-log-store-Bz7HDBkE.cjs";
 import { AnyActorLogic, AnyActorRef, AnyMachineSnapshot, AnyStateMachine, AsyncActorLogic, EmittedFrom, EventFromLogic, EventObject, ExecutableActionObject, InputFrom, InspectionEvent, OutputFrom, Snapshot, SnapshotFrom, createActor } from "xstate";
 
@@ -934,7 +934,7 @@ declare class AgentMaxModelCallsExceededError extends AgentError {
  * declared input schema — and machines reached through `.provide(...)`, which
  * drops the brand — fall back to xstate's `InputFrom`.
  */
-type AgentInputFrom<TMachine extends AnyStateMachine> = InputFrom<TMachine> extends WithAgentInputSchema<infer TInputSchema> ? [TInputSchema] extends [StandardSchemaV1] ? InferInput<TInputSchema> : InputFrom<TMachine> : InputFrom<TMachine>;
+type AgentInputFrom<TMachine extends AnyStateMachine> = [NonNullable<InputFrom<TMachine>>] extends [WithAgentInputSchema<infer TInputSchema>] ? [TInputSchema] extends [StandardSchemaV1] ? InferInput<TInputSchema> : InputFrom<TMachine> : InputFrom<TMachine>;
 /**
  * Runs an agent machine to completion or idle: a `createActor` host that
  * binds `options`' host executors onto the machine's `agent.*`/`TextLogic`/

package/dist/{setup-agent-BFA4VKpN.cjs → setup-agent-91FSuZbB.cjs}

@@ -1,5 +1,5 @@
 const require_errors = require("./errors-DUBBzRLP.cjs");
-const require_decision = require("./decision-t26zsnSR.cjs");
+const require_decision = require("./decision-BnTCsuJv.cjs");
 const require_event_log_store = require("./event-log-store-a_TKy1gk.cjs");
 require("./validate.cjs");
 let xstate = require("xstate");
@@ -919,7 +919,7 @@ function createRequestsFromWorkflowConfig(config, compileSchema) {
 		messages: resolver(request.messages),
 		tools: request.tools,
 		toolChoice: request.toolChoice,
-		reasoning: request.reasoning,
+		includeReasoning: request.includeReasoning,
 		temperature: resolver(request.temperature),
 		maxOutputTokens: resolver(request.maxOutputTokens),
 		topP: resolver(request.topP),