@statelyai/agent 2.0.0-alpha.23 → 2.0.0-alpha.25

package/dist/index.cjs

@@ -1,8 +1,140 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_decision = require("./decision-Cv6SfNWl.cjs");
-const require_setup_agent = require("./setup-agent-Dl2VELLi.cjs");
-require("./validate.cjs");
-let xstate = require("xstate");
+const require_text_logic = require("./text-logic-C8xyr6Ag.cjs");
+const require_decision = require("./decision-CM9CYZ6t.cjs");
+const require_usage = require("./usage-efOQPdf_.cjs");
+const require_setup_agent = require("./setup-agent-CPf7MxnG.cjs");
+const require_run_agent = require("./run-agent-Cb1-LS5P.cjs");
+const require_event_log_store = require("./event-log-store-DQmImLYk.cjs");
+//#region src/messages.ts
+const KNOWN_PART_TYPES = new Set([
+	"text",
+	"image",
+	"file",
+	"tool-call",
+	"tool-result"
+]);
+const USER_PART_TYPES = new Set([
+	"text",
+	"image",
+	"file"
+]);
+const ASSISTANT_PART_TYPES = new Set([
+	"text",
+	"file",
+	"tool-call",
+	"tool-result"
+]);
+const TOOL_PART_TYPES = new Set(["tool-result"]);
+const TOOL_RESULT_CONTENT_PART_TYPES = new Set(["text", "image"]);
+function isKnownPart(part) {
+	const type = part && typeof part === "object" ? part.type : void 0;
+	return typeof type === "string" && KNOWN_PART_TYPES.has(type);
+}
+function requireString(part, type, field) {
+	return typeof part[field] === "string" ? void 0 : `${type} part requires a string "${field}"`;
+}
+function isMediaData(value) {
+	return typeof value === "string" || value instanceof Uint8Array || value instanceof ArrayBuffer || value instanceof URL;
+}
+function requireMediaData(part, type, field) {
+	return isMediaData(part[field]) ? void 0 : `${type} part requires "${field}" to be a string, Uint8Array, ArrayBuffer, or URL`;
+}
+const TOOL_RESULT_OUTPUT_TYPES = new Set([
+	"text",
+	"json",
+	"error-text",
+	"error-json",
+	"content"
+]);
+function validateToolResultOutput(output) {
+	if (!output || typeof output !== "object" || Array.isArray(output)) return "tool-result part requires an \"output\" object";
+	const record = output;
+	const outputType = record.type;
+	if (typeof outputType !== "string" || !TOOL_RESULT_OUTPUT_TYPES.has(outputType)) return `Unknown tool-result output type: ${JSON.stringify(outputType)}`;
+	if (outputType === "text" || outputType === "error-text") {
+		if (typeof record.value !== "string") return `tool-result output of type "${outputType}" requires a string "value"`;
+		return;
+	}
+	if (outputType === "content") {
+		if (!Array.isArray(record.value)) return "tool-result output of type \"content\" requires an array \"value\"";
+		for (const contentPart of record.value) {
+			const error = validatePart(contentPart, TOOL_RESULT_CONTENT_PART_TYPES, "tool-result output content");
+			if (error) return error;
+		}
+		return;
+	}
+	return record.value !== void 0 ? void 0 : `tool-result output of type "${outputType}" requires a "value"`;
+}
+function validatePart(part, allowedTypes, location) {
+	if (!isKnownPart(part)) {
+		const type = part && typeof part === "object" ? part.type : void 0;
+		return `Unknown message part type: ${JSON.stringify(type)}`;
+	}
+	if (!allowedTypes.has(part.type)) return `${location} does not allow "${part.type}" parts`;
+	const record = part;
+	switch (record.type) {
+		case "text": return requireString(record, "text", "text");
+		case "image": return requireMediaData(record, "image", "image");
+		case "file": return requireMediaData(record, "file", "data") ?? requireString(record, "file", "mediaType");
+		case "tool-call": return requireString(record, "tool-call", "toolCallId") ?? requireString(record, "tool-call", "toolName") ?? ("input" in record ? void 0 : "tool-call part requires an \"input\" value");
+		case "tool-result": return requireString(record, "tool-result", "toolCallId") ?? requireString(record, "tool-result", "toolName") ?? validateToolResultOutput(record.output);
+		default: return;
+	}
+}
+function validatePartsArray(content, allowedTypes, location) {
+	if (!Array.isArray(content)) return "Expected content to be a string or an array of parts";
+	for (const part of content) {
+		const error = validatePart(part, allowedTypes, location);
+		if (error) return error;
+	}
+}
+/**
+* A {@link StandardSchemaV1} validating an `AgentMessage[]` context field —
+* checks that every message has a known `role` (`system`/`user`/`assistant`/
+* `tool`) and that `content` is either a string (where the role allows it) or
+* an array of role-appropriate parts whose required fields and media payloads
+* have the right runtime types (extra fields are allowed). Use it directly as
+* a context schema's `messages` field when authoring with `createAgentSchemas`
+* or `fromConfig`. A zod object cannot nest a Standard Schema, so in a zod
+* context schema write `z.custom<AgentMessage[]>(isAgentMessages)`, which runs
+* this same validator (see {@link isAgentMessages}).
+*/
+const messagesSchema = { "~standard": {
+	version: 1,
+	vendor: "statelyai-agent",
+	validate(value) {
+		if (!Array.isArray(value)) return { issues: [{ message: "Expected an array of agent messages" }] };
+		for (const message of value) {
+			if (!message || typeof message !== "object") return { issues: [{ message: "Expected an array of agent messages" }] };
+			const role = message.role;
+			const content = message.content;
+			if (role !== "system" && role !== "user" && role !== "assistant" && role !== "tool") return { issues: [{ message: `Unknown message role: ${JSON.stringify(role)}` }] };
+			if (role === "system") {
+				if (typeof content !== "string") return { issues: [{ message: "system message content must be a string" }] };
+				continue;
+			}
+			if (role === "tool") {
+				const error = validatePartsArray(content, TOOL_PART_TYPES, "tool message content");
+				if (error) return { issues: [{ message: error }] };
+				continue;
+			}
+			if (typeof content === "string") continue;
+			const error = validatePartsArray(content, role === "user" ? USER_PART_TYPES : ASSISTANT_PART_TYPES, `${role} message content`);
+			if (error) return { issues: [{ message: error }] };
+		}
+		return { value };
+	}
+} };
+/**
+* Type guard over {@link messagesSchema}: `true` when `value` is a valid
+* `AgentMessage[]`. The one-liner for zod context schemas:
+* `messages: z.custom<AgentMessage[]>(isAgentMessages)`.
+*/
+function isAgentMessages(value) {
+	const result = messagesSchema["~standard"].validate(value);
+	return !(result instanceof Promise) && !("issues" in result && result.issues);
+}
+//#endregion
 //#region src/interaction.ts
 function issue(message, path) {
 	return {
@@ -25,9 +157,10 @@ function validateEventMeta(value, path) {
 * A {@link StandardSchemaV1} for the state metadata {@link getInteraction}
 * reads: an object whose optional `interaction` declares a `label` (a string
 * with `{context.path}` interpolation, or a function of the context), an
-* `events` map of choices, and a `textEvent` for free-text answers. Pass it
-* straight to `createAgentSchemas({ meta: interactionMetaSchema })` instead of
-* restating the shape per machine.
+* `events` map of choices, and a `textEvent` for free-text answers. This is
+* the default `meta` type `setupAgent` gives a machine; pass it to
+* `createAgentSchemas({ meta: interactionMetaSchema })` only when building a
+* schema pack by hand.
 */
 const interactionMetaSchema = { "~standard": {
 	version: 1,
@@ -68,13 +201,13 @@ function interpolate(label, context, preserveWhitespace) {
 /** Reads the active state's interaction metadata and filters it through the
 * events XState currently accepts. Returns `undefined` when none is declared. */
 function getInteraction(snapshot, options = {}) {
-	const interaction = require_decision.getStateMeta(snapshot).interaction;
+	const interaction = require_text_logic.getStateMeta(snapshot).interaction;
 	if (!interaction) return void 0;
 	const preserveWhitespace = options.preserveWhitespace ?? false;
-	const schemas = require_decision.getAgentExecutionOptions(snapshot.machine)?.schemas;
+	const schemas = require_text_logic.getAgentExecutionOptions(snapshot.machine)?.schemas;
 	const accepted = new Set(require_decision.getAcceptedEvents(snapshot).map((event) => event.type));
 	const label = typeof interaction.label === "function" ? interaction.label({ context: snapshot.context }) : interaction.label ?? "";
-	const events = Object.entries(interaction.events ?? {}).filter(([type]) => accepted.has(type)).map(([type, config]) => {
+	const events = Object.entries(interaction.events ?? {}).filter((entry) => entry[1] !== void 0 && accepted.has(entry[0])).map(([type, config]) => {
 		return [type, typeof config === "string" ? { label: config } : config];
 	}).filter(([type, descriptor]) => {
 		try {
@@ -124,4329 +257,353 @@ function eventFromInteraction(snapshot, choice) {
 	return require_decision.parseAgentEvent(snapshot, event);
 }
 //#endregion
-//#region src/steps.ts
-/**
-* The step envelope: an INTERNAL, per-model-call-checkpoint view of an agent
-* machine (`AgentStep` = snapshot + actions + discovered requests + done). It
-* once backed a public step API; the public step path is now the thin
-* effect/replay loop in `./effects.ts` (re-exported from `@statelyai/agent`).
-* These helpers survive as internals that `runAgent`, `verify.ts`, and the
-* effect path build on — the only symbol still on the public surface is
-* {@link executeAgentRequest} (the `text`-effect resolver).
-* @module
-*/
-/** @internal Normalizes current and legacy XState invoke effect shapes. */
-function getInvokeEffectMetadata(action) {
-	if (action.type === "@xstate.spawn") return action;
-	if (action.type === "xstate.spawnChild") {
-		const params = action.params;
-		return params ? {
-			...params,
-			logic: action.logic
-		} : void 0;
-	}
-	if (action.type === "@xstate.start" && typeof action.src === "string") return action;
-}
+//#region src/agent-run.ts
 /**
-* The invokes a snapshot is still waiting on, lowered to the same spawn-effect
-* shape {@link getAgentRequests} reads. Derived from the snapshot's live
-* children rather than the last transition's actions, so a state that invokes
-* several actors at once (an `invoke: [...]` array, or parallel regions each
-* invoking) keeps reporting the siblings after the first one settles —
-* including when the settled invoke's `onDone` is targetless and starts
-* nothing new.
-*
-* Entries are ordered by invoke id, so a walker that resolves one invoke per
-* step is deterministic.
+* Wraps {@link runAgent} in a canonical run-stream handle: the run's trace
+* events as a pull-based {@link AgentRun.events} async iterator, alongside the
+* unchanged {@link AgentRun.result} promise.
 *
-* @internal
-*/
-function getPendingInvokes(snapshot) {
-	const children = snapshot.children ?? {};
-	return Object.keys(children).sort().flatMap((id) => {
-		const child = children[id];
-		const childSnapshot = child?.getSnapshot?.();
-		if (!child || childSnapshot?.status !== "active") return [];
-		return [{
-			type: "@xstate.spawn",
-			id,
-			src: child.src,
-			input: childSnapshot.input,
-			logic: child.logic
-		}];
-	});
-}
-/**
-* Scans a set of executable actions (as returned by xstate's `transition`/
-* `initialTransition`) for spawned `TextLogic`/`DecisionLogic` invokes and
-* lowers each into an {@link AgentStepRequest}. Pass `options.machine` to
-* pre-fill `schemas`/`actors` from the machine's registered `setupAgent`
-* options instead of passing them by hand.
-* `options.snapshot` is required to resolve a decision's candidate events
-* (intersecting declared `allowedEvents` with what's currently legal) — omit
-* it and decision requests report an empty `events` list.
+* Semantics:
 *
-* @internal
+* 1. **Starts immediately.** The underlying `runAgent` is invoked on this call,
+*    not on the first `events` iteration — work is already in flight when
+*    `createAgentRun` returns.
+* 2. **Buffer, don't stall.** Events are queued in an unbounded in-memory
+*    buffer as the run emits them; a slow or absent consumer never applies
+*    backpressure to the run. Once `run.end` is delivered, the iterator
+*    completes.
+* 3. **Composes `onTrace`.** If `options.onTrace` is passed, it still fires for
+*    every event — the wrapper adds queue delivery, it does not replace the
+*    caller's sink.
+* 4. **`result` mirrors `runAgent`.** Same resolution and rejection behavior
+*    (see {@link AgentRun.result}). A no-op rejection handler is attached
+*    internally so a caller who reads only `events` never trips an unhandled
+*    rejection on a bind-time throw; the returned promise still rejects for a
+*    caller who awaits it.
+* 5. **Resume is identical.** Options pass straight through, so starting from a
+*    persisted `snapshot` (+ resume `event`) streams that run's events from its
+*    own `run.start`, exactly as `runAgent` would run it.
+* 6. **Early termination does not cancel the run.** Breaking out of a
+*    `for await` (or calling `events.return()`) stops delivery, but the run
+*    keeps going and `result` still settles. Cancelling the run itself is
+*    future work — pass `options.signal` to abort it.
+* 7. **`events` is single-consumer.** See {@link AgentRun.events}.
 */
-function getAgentRequests(actions, { machine, ...options } = {}) {
-	if (machine) options = {
-		...require_decision.getRegisteredAgentExecutionOptions(machine),
-		...options
+function createAgentRun(machine, options) {
+	const buffer = [];
+	const resolvers = [];
+	let closed = false;
+	let stopped = false;
+	const push = (event) => {
+		if (closed || stopped) return;
+		const resolve = resolvers.shift();
+		if (resolve) resolve({
+			value: event,
+			done: false
+		});
+		else buffer.push(event);
+	};
+	const drain = () => {
+		while (resolvers.length > 0) resolvers.shift()({
+			value: void 0,
+			done: true
+		});
+	};
+	const close = () => {
+		if (closed) return;
+		closed = true;
+		drain();
 	};
-	return actions.flatMap((action) => {
-		const params = getInvokeEffectMetadata(action);
-		if (!params || typeof params.src !== "string") return [];
-		if (typeof params.id !== "string" || params.id.length === 0) throw new Error(`Agent invoke '${params.src}' must define a durable string id.`);
-		const registeredLogic = require_decision.isTextLogic(params.logic) || require_decision.isDecisionLogic(params.logic) ? params.logic : options.actors?.[params.src];
-		if (require_decision.isDecisionLogic(registeredLogic)) {
-			const decisionRequest = registeredLogic.request(params.input);
-			const allowedEventTypes = registeredLogic.allowedEventTypes?.(params.input);
-			const events = options.snapshot ? require_decision.getAcceptedEvents(options.snapshot, {
-				events: options.events,
-				schemas: options.schemas,
-				eventTypes: allowedEventTypes,
-				eventToolName: options.eventToolName
-			}) : [];
-			return [{
-				...decisionRequest,
-				id: params.id,
-				events
-			}];
+	const userOnTrace = options.onTrace;
+	const result = require_run_agent.runAgent(machine, {
+		...options,
+		onTrace: (event) => {
+			push(event);
+			userOnTrace?.(event);
+			if (event.type === "run.end") close();
 		}
-		const textLogic = require_decision.isTextLogic(registeredLogic) ? registeredLogic : void 0;
-		const input = textLogic ? textLogic.request(params.input) : void 0;
-		if (!input) return [];
-		return [{
-			kind: "text",
-			id: params.id,
-			src: params.src,
-			...textLogic ? { mode: textLogic.mode } : {},
-			input,
-			tools: input.tools ?? {},
-			events: []
-		}];
 	});
-}
-/**
-* Builds the canonical `xstate.done.actor` event xstate's `transition()`
-* expects to resolve a spawned invoke — including the child session identity
-* that rejects a stale completion from an earlier incarnation.
-*
-* @internal
-*/
-function doneEvent(snapshot, request, output) {
-	const id = typeof request === "string" ? request : request.id;
-	const child = snapshot.children[id];
+	result.then(close, close);
 	return {
-		type: "xstate.done.actor",
-		actorId: id,
-		...typeof child?.sessionId === "string" ? { sessionId: child.sessionId } : {},
-		output
+		events: {
+			next() {
+				if (buffer.length > 0) return Promise.resolve({
+					value: buffer.shift(),
+					done: false
+				});
+				if (closed || stopped) return Promise.resolve({
+					value: void 0,
+					done: true
+				});
+				return new Promise((resolve) => {
+					resolvers.push(resolve);
+				});
+			},
+			return() {
+				stopped = true;
+				buffer.length = 0;
+				drain();
+				return Promise.resolve({
+					value: void 0,
+					done: true
+				});
+			},
+			[Symbol.asyncIterator]() {
+				return this;
+			}
+		},
+		result
 	};
 }
-/**
-* The `xstate.error.actor` counterpart of {@link doneEvent} — the event a
-* failed invoke delivers, which `onError` transitions observe. Carries the
-* same child session identity, so xstate does not discard it as stale.
-*
-* @internal
-*/
-function errorEvent(snapshot, request, error) {
-	const id = typeof request === "string" ? request : request.id;
-	const child = snapshot.children[id];
+function requestIdentity(request) {
+	const candidate = request;
+	const id = candidate.id ?? candidate.name ?? "agent.request";
 	return {
-		type: "xstate.error.actor",
-		actorId: id,
-		...typeof child?.sessionId === "string" ? { sessionId: child.sessionId } : {},
-		error
+		name: candidate.kind === "text" ? candidate.input?.name ?? id : candidate.name ?? id,
+		id
 	};
 }
 /**
-* Applies a request's `output` as a done event (or, with `outcome: 'error'`,
-* its `output` as the invoke's error) via `transition(...)`, returning the raw
-* `[snapshot, actions]` tuple. Lower-level than {@link resolveAgentStep} /
-* {@link rejectAgentStep} — those helpers wrap this and also run
-* {@link getAgentRequests} to produce the next {@link AgentStep}.
-*
-* @internal
-*/
-function transitionResult(logic, snapshot, request, output, outcome = "output") {
-	const event = outcome === "error" ? errorEvent(snapshot, request, output) : doneEvent(snapshot, request, output);
-	const result = (0, xstate.transition)(logic, snapshot, event);
-	applyFinalStateOutput(logic, result[0], event);
-	return result;
-}
-/**
-* Starts a machine and returns its first {@link AgentStep} — the step-path
-* equivalent of `initialTransition` plus request discovery. Begins the
-* durable/per-model-call-checkpoint loop: resolve each `step.requests` entry
-* (via {@link executeAgentRequest} for `kind: 'text'`, or
-* {@link resolveDecision} for `kind: 'decision'`), then advance with
-* {@link resolveAgentStep} or {@link transitionAgentStep}.
-*/
-function initialAgentStep(machine, input, options) {
-	const [snapshot, actions] = (0, xstate.initialTransition)(machine, input);
-	return createAgentStep(machine, snapshot, actions, require_decision.getRegisteredAgentExecutionOptions(machine, options));
-}
-/**
-* Applies an externally-sent event (e.g. a decision's chosen event, or a
-* human's reply) and returns the next {@link AgentStep}. Accepts **either**
-* a raw snapshot **or** a prior `AgentStep` as the second argument —
-* `.snapshot` is unwrapped automatically, so callers can thread the whole
-* step object through without manually plucking the snapshot out.
-*/
-function transitionAgentStep(machine, snapshotOrStep, event, options) {
-	const [nextSnapshot, actions] = (0, xstate.transition)(machine, isAgentStep(snapshotOrStep) ? snapshotOrStep.snapshot : snapshotOrStep, event);
-	return createAgentStep(machine, nextSnapshot, actions, require_decision.getRegisteredAgentExecutionOptions(machine, options));
-}
-/**
-* Applies a resolved text request's output (a `kind: 'text'`
-* {@link AgentRequest} — not a decision) as a done event and returns the
-* next {@link AgentStep}. For decisions, resolve with `resolveDecision`
-* (which returns a {@link ChosenEvent}) and apply it with
-* {@link transitionAgentStep} instead — a decision has no output value of
-* its own to feed here.
-*/
-function resolveAgentStep(machine, step, request, output, options) {
-	const [snapshot, actions] = transitionResult(machine, step.snapshot, request, output);
-	return createAgentStep(machine, snapshot, actions, require_decision.getRegisteredAgentExecutionOptions(machine, options));
-}
-/**
-* Rejects a pending invoke — the failure counterpart of
-* {@link resolveAgentStep}. Delivers `error` as the invoke's
-* `xstate.error.actor` event, so the machine takes that invoke's `onError`
-* transition and returns the next {@link AgentStep}. With no `onError` in
-* scope the returned step's snapshot has `status: 'error'`, exactly as a live
-* run's failed invoke does.
-*
-* A durable host replays a failed call with this: the log says the call
-* failed, so the replay rejects the invoke instead of resolving it. Scripted
-* playthroughs use it too — see `simulateAgent`'s `script.errors`.
-*
-* `error` can be any value. An `Error` instance is the usual one, but a plain
-* object (`{ code: 'truncated' }`) reaches the `onError` transition as
-* `event.error` untouched, so a machine that branches on a failure code is
-* testable without constructing a provider's error class.
+* Streams one {@link runAgent} call as agent-level events. The machine remains
+* the single artifact; this function only projects its requests, chunks,
+* transitions, emitted events, and terminal result into an async iterable.
 */
-function rejectAgentStep(machine, step, request, error, options) {
-	const [snapshot, actions] = transitionResult(machine, step.snapshot, request, error, "error");
-	return createAgentStep(machine, snapshot, actions, require_decision.getRegisteredAgentExecutionOptions(machine, options));
-}
-async function executeAgentRequest(requestOrEffect, executors) {
-	if (requestOrEffect.kind === "decision") throw new Error("executeAgentRequest(...) is text-only. Resolve a 'decision' request with resolveDecision(request, executors, ...) instead.");
-	const request = "requestId" in requestOrEffect ? {
-		kind: "text",
-		id: requestOrEffect.requestId,
-		src: "",
-		mode: requestOrEffect.mode,
-		input: requestOrEffect.request,
-		tools: requestOrEffect.request.tools ?? {},
-		events: []
-	} : requestOrEffect;
-	assertTextExecutor(request, executors);
-	const { output, raw } = await require_decision.executeAgentTextRequest(request.mode ?? "generate", request.id, request.input, executors, request.tools);
-	return {
-		output: request.input.outputSchema ? require_decision.validateSchemaSync(request.input.outputSchema, output) : output,
-		raw
+async function* runAgentStream(machine, options) {
+	const run = createAgentRun(machine, options);
+	for await (const event of run.events) switch (event.type) {
+		case "request.start":
+			yield {
+				kind: "request",
+				phase: "start",
+				...requestIdentity(event.request),
+				request: event.request
+			};
+			break;
+		case "request.end":
+			yield {
+				kind: "request",
+				phase: "end",
+				...requestIdentity(event.request),
+				request: event.request,
+				output: event.output,
+				raw: event.raw
+			};
+			break;
+		case "request.error":
+			yield {
+				kind: "request",
+				phase: "error",
+				...requestIdentity(event.request),
+				request: event.request,
+				error: event.error
+			};
+			break;
+		case "stream.chunk":
+			yield {
+				kind: "chunk",
+				...requestIdentity(event.request),
+				delta: event.chunk
+			};
+			break;
+		case "machine.transition":
+			yield {
+				kind: "transition",
+				value: event.snapshot.value,
+				event: event.event
+			};
+			break;
+		case "emit":
+			yield {
+				kind: "emit",
+				event: event.event
+			};
+			break;
+	}
+	const result = await run.result;
+	if (result.status === "done") yield {
+		kind: "done",
+		result
 	};
-}
-function assertTextExecutor(request, executors) {
-	const mode = request.mode ?? "generate";
-	const kind = mode === "stream" ? "streamText" : "generateText";
-	if (!(mode === "stream" ? executors.streamText : executors.generateText)) throw new Error(`this step's text request '${request.src}' needs a '${kind}' executor but none was provided.`);
-}
-function createAgentStep(machine, snapshot, actions, options) {
-	applyFinalStateOutput(machine, snapshot);
-	return {
-		snapshot,
-		actions,
-		requests: getAgentRequests(getPendingInvokes(snapshot), {
-			...options,
-			snapshot
-		}),
-		done: snapshot.status === "done"
+	else if (result.status === "idle") yield {
+		kind: "idle",
+		result
+	};
+	else yield {
+		kind: "error",
+		result
 	};
-}
-function resolveStateValueConfig(config, value) {
-	if (typeof value === "string") return config.states?.[value];
-	if (!value || typeof value !== "object") return;
-	for (const [key, childValue] of Object.entries(value)) {
-		const childConfig = config.states?.[key];
-		if (!childConfig) continue;
-		if (childConfig.type === "final") return childConfig;
-		const nested = resolveStateValueConfig(childConfig, childValue);
-		if (nested) return nested;
-	}
-}
-function applyFinalStateOutput(logic, snapshot, event) {
-	const machineSnapshot = snapshot;
-	if (machineSnapshot.status !== "done" || machineSnapshot.output !== void 0 || !("config" in logic)) return;
-	const config = logic.config;
-	if (!config) return;
-	const output = resolveStateValueConfig(config, machineSnapshot.value)?.output;
-	if (output === void 0) return;
-	machineSnapshot.output = typeof output === "function" ? output({
-		context: machineSnapshot.context,
-		event
-	}) : output;
-}
-function isAgentStep(value) {
-	return !!value && typeof value === "object" && "snapshot" in value && "actions" in value && "requests" in value;
 }
 //#endregion
-//#region src/event-log.ts
+//#region src/provide-executors.ts
 /**
-* The event log: an append-only journal of the EXTERNAL inputs a machine
-* consumed, and the pure fold ({@link replay}) that turns that journal back
-* into a snapshot without executing anything.
+* Binds a machine's agent actor sources to a set of host `executors` in one
+* call, returning a `machine.provide(...)`-ed copy ready for a plain
+* `createActor(...)` — the uncontrolled-mode counterpart to {@link runAgent}.
+* No run loop, no idle settling: the returned machine drives itself, so
 *
-* A journaled entry is always an external input — an invoke completion
-* (`xstate.done.actor`/`xstate.error.actor` carrying its output inline), a
-* user-sent event, a timer firing, a reserved `@agent.usage` record. Never a
-* raised/internal event: replay re-derives those from the machine's own logic,
-* so journaling them would double-apply them.
+* ```ts
+* const actor = createActor(provideExecutors(machine, { generateText, decide }), { input });
+* actor.start();
+* ```
 *
-* A log is self-contained: its reserved first entry ({@link initEntry}) carries
-* either the machine `input` (a fresh start) or a persisted snapshot (a
-* continuation across a machine version, or from a log-less legacy snapshot),
-* so {@link replay} needs no side channel.
-* @module
-*/
-/** The durable entry envelope version. */
-const AGENT_EVENT_SCHEMA_VERSION = 1;
-/**
-* The reserved event type of the first entry of every log. It carries the
-* machine `input` (fresh start) or a persisted `snapshot` (continuation), so a
-* log replays with no side channel. Lives in the reserved `@agent.*` namespace
-* so it can never collide with a machine's own vocabulary; it is consumed by
-* {@link replay} and never fed to `transition`.
-*/
-const AGENT_INIT_EVENT_TYPE = "@agent.init";
-/** A malformed or internally inconsistent log. */
-var AgentEventLogError = class extends require_decision.AgentError {
-	constructor(message) {
-		super("invalid-event-log", message);
-		this.name = "AgentEventLogError";
-	}
-};
-/** A precise failure when an entry would not survive a JSON round-trip. */
-var NonSerializableAgentEventError = class extends require_decision.AgentError {
-	path;
-	valueType;
-	constructor(path, valueType) {
-		super("non-serializable-event", `Agent event field '${path}' is not JSON-serializable (${valueType}).`);
-		this.name = "NonSerializableAgentEventError";
-		this.path = path;
-		this.valueType = valueType;
-	}
-};
-/** Replay reached a state that does not match the entry's recorded hash. */
-var AgentReplayDivergenceError = class extends require_decision.AgentError {
-	constructor(eventId, index, kind, expected, actual) {
-		super("replay-diverged", kind === "missing-verification" ? `Replay entry '${eventId}' at index ${index} has no recorded verification hash.` : `Replay diverged after '${eventId}' at index ${index}: expected state hash '${expected}', got '${actual}'.`);
-		this.eventId = eventId;
-		this.index = index;
-		this.kind = kind;
-		this.expected = expected;
-		this.actual = actual;
-		this.name = "AgentReplayDivergenceError";
-	}
-};
-/**
-* An entry was recorded against a different machine (id) or a different
-* machine version than the one replaying it. An init-with-snapshot entry is
-* exempt: that entry IS the bridge from the old version to the new one.
-*/
-var AgentMachineVersionMismatchError = class extends require_decision.AgentError {
-	constructor(eventId, index, expected, actual) {
-		super("machine-version-mismatch", `Event log entry '${eventId}' at index ${index} targets machine '${actual.machineId}'@'${actual.machineVersion}', expected '${expected.machineId}'@'${expected.machineVersion}'.`);
-		this.eventId = eventId;
-		this.index = index;
-		this.expected = expected;
-		this.actual = actual;
-		this.name = "AgentMachineVersionMismatchError";
-	}
-};
-function assertNoHiddenKeys(value, path, isOwnKey) {
-	const symbols = Object.getOwnPropertySymbols(value);
-	if (symbols.length > 0) throw new NonSerializableAgentEventError(`${path}.[${String(symbols[0])}]`, "symbol key");
-	const hiddenKey = Object.getOwnPropertyNames(value).find((key) => !isOwnKey?.(key) && !Object.getOwnPropertyDescriptor(value, key)?.enumerable);
-	if (hiddenKey !== void 0) throw new NonSerializableAgentEventError(`${path}.${hiddenKey}`, "non-enumerable property");
-}
-const arrayIndexPattern = /^(?:0|[1-9]\d*)$/;
-/**
-* Rejects values JSON would drop or coerce. Unlike `JSON.stringify`, this does
-* not silently erase `undefined`/functions or turn non-finite numbers into
-* `null`; durable entries contain only plain JSON values.
-*/
-function assertJsonSerializable(value, path = "entry", ancestors = /* @__PURE__ */ new WeakSet()) {
-	if (value === null || typeof value === "string" || typeof value === "boolean") return;
-	if (typeof value === "number") {
-		if (!Number.isFinite(value) || Object.is(value, -0)) throw new NonSerializableAgentEventError(path, Object.is(value, -0) ? "-0" : String(value));
-		return;
-	}
-	if (typeof value !== "object") throw new NonSerializableAgentEventError(path, typeof value);
-	if (ancestors.has(value)) throw new NonSerializableAgentEventError(path, "circular reference");
-	ancestors.add(value);
-	try {
-		if (Array.isArray(value)) {
-			for (let index = 0; index < value.length; index++) {
-				if (!Object.hasOwn(value, index)) throw new NonSerializableAgentEventError(`${path}[${index}]`, "array hole");
-				assertJsonSerializable(value[index], `${path}[${index}]`, ancestors);
-			}
-			const extraKey = Object.keys(value).find((key) => !arrayIndexPattern.test(key) || Number(key) >= value.length);
-			if (extraKey !== void 0) throw new NonSerializableAgentEventError(`${path}.${extraKey}`, "array property");
-			assertNoHiddenKeys(value, path, (key) => key === "length" || arrayIndexPattern.test(key));
-			return;
-		}
-		const prototype = Object.getPrototypeOf(value);
-		if (prototype !== Object.prototype && prototype !== null) throw new NonSerializableAgentEventError(path, value.constructor?.name ?? "object");
-		assertNoHiddenKeys(value, path);
-		for (const [key, child] of Object.entries(value)) assertJsonSerializable(child, `${path}.${key}`, ancestors);
-	} finally {
-		ancestors.delete(value);
-	}
-}
-function requireNonEmptyString(value, label, qualifier = "") {
-	if (typeof value !== "string" || !value) throw new AgentEventLogError(`Agent event ${label} must be a non-empty string${qualifier}.`);
-}
-/** Validates the complete durable envelope before append/export/replay. */
-function assertAgentLogEntry(entry) {
-	if (entry === null || typeof entry !== "object" || Array.isArray(entry)) throw new AgentEventLogError("Agent event entry must be an object.");
-	assertJsonSerializable(entry);
-	const candidate = entry;
-	if (candidate.schemaVersion !== 1) throw new AgentEventLogError(`Unsupported agent event schema version '${String(candidate.schemaVersion)}'; expected '1'.`);
-	if (!Number.isInteger(candidate.index) || candidate.index < 0) throw new AgentEventLogError(`Agent event entry.index must be a non-negative integer; got ${String(candidate.index)}.`);
-	for (const field of [
-		"id",
-		"machineId",
-		"machineVersion"
-	]) requireNonEmptyString(candidate[field], `entry.${field}`);
-	if (typeof candidate.recordedAt !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(candidate.recordedAt) || Number.isNaN(Date.parse(candidate.recordedAt))) throw new AgentEventLogError(`Agent event entry.recordedAt is not RFC 3339: '${String(candidate.recordedAt)}'.`);
-	if (candidate.event === null || typeof candidate.event !== "object" || Array.isArray(candidate.event) || typeof candidate.event.type !== "string" || !candidate.event.type) throw new AgentEventLogError("Agent event entry.event requires a non-empty string type.");
-	if (candidate.causationId !== void 0) requireNonEmptyString(candidate.causationId, "entry.causationId", " when present");
-	if (candidate.metadata !== void 0 && (candidate.metadata === null || typeof candidate.metadata !== "object" || Array.isArray(candidate.metadata))) throw new AgentEventLogError("Agent event entry.metadata must be an object when present.");
-	if (candidate.verification !== void 0 && (candidate.verification === null || typeof candidate.verification !== "object" || typeof candidate.verification.stateHash !== "string" || !candidate.verification.stateHash)) throw new AgentEventLogError("Agent event entry.verification requires a non-empty stateHash string.");
-}
-/**
-* Replaces `Error` instances with plain `{ name, message, cause? }` objects so
-* an `xstate.error.actor` payload survives the log's JSON round-trip. Cycles
-* are preserved by identity; non-plain objects are left alone (and are then
-* rejected by {@link assertJsonSerializable}).
-*/
-function normalizeEventErrors(value, seen = /* @__PURE__ */ new WeakMap()) {
-	if (value instanceof Error) {
-		const normalized = {
-			name: value.name,
-			message: value.message
-		};
-		seen.set(value, normalized);
-		if (value.cause !== void 0) normalized.cause = normalizeEventErrors(value.cause, seen);
-		return normalized;
-	}
-	if (value === null || typeof value !== "object") return value;
-	const existing = seen.get(value);
-	if (existing !== void 0) return existing;
-	if (Array.isArray(value)) {
-		const result = [];
-		seen.set(value, result);
-		for (const item of value) result.push(normalizeEventErrors(item, seen));
-		return result;
-	}
-	const prototype = Object.getPrototypeOf(value);
-	if (prototype !== Object.prototype && prototype !== null) return value;
-	const result = {};
-	seen.set(value, result);
-	for (const [key, item] of Object.entries(value)) result[key] = normalizeEventErrors(item, seen);
-	return result;
-}
-const SNAPSHOT_VOLATILE_KEYS = new Set([
-	"sessionId",
-	"_nextTimerId",
-	"_nextActorIds"
-]);
-const CHILD_VOLATILE_KEYS = new Set(["sessionId"]);
-function positionOf(parent, key) {
-	if (parent === "snapshot") return key === "children" ? "children" : "data";
-	if (parent === "children") return "child";
-	if (parent === "child") return key === "snapshot" ? "snapshot" : "data";
-	return "data";
-}
-function canonicalizeForHash(value, seen = /* @__PURE__ */ new WeakSet(), position = "snapshot") {
-	if (value === void 0) return "[undefined]";
-	if (typeof value === "function") return "[function]";
-	if (typeof value === "bigint") return `[bigint:${String(value)}]`;
-	if (typeof value === "symbol") return `[symbol:${String(value)}]`;
-	if (value === null || typeof value !== "object") return value;
-	if (value instanceof Date) return `[Date:${value.toISOString()}]`;
-	if (value instanceof Error) {
-		if (seen.has(value)) return "[circular]";
-		seen.add(value);
-		try {
-			return {
-				errorName: value.name,
-				message: value.message,
-				...value.cause !== void 0 ? { cause: canonicalizeForHash(value.cause, seen, "data") } : {}
-			};
-		} finally {
-			seen.delete(value);
-		}
-	}
-	if (seen.has(value)) return "[circular]";
-	seen.add(value);
-	try {
-		if (value instanceof Set) return [...value].map((item) => canonicalizeForHash(item, seen, "data")).sort((a, b) => stableJson(a).localeCompare(stableJson(b)));
-		if (value instanceof Map) return [...value.entries()].map(([key, item]) => [canonicalizeForHash(key, seen, "data"), canonicalizeForHash(item, seen, "data")]).sort(([a], [b]) => stableJson(a).localeCompare(stableJson(b)));
-		if (Array.isArray(value)) return value.map((item) => canonicalizeForHash(item, seen, "data"));
-		const volatileKeys = position === "snapshot" ? SNAPSHOT_VOLATILE_KEYS : position === "child" ? CHILD_VOLATILE_KEYS : void 0;
-		const result = {};
-		for (const key of Object.keys(value).sort()) {
-			if (volatileKeys?.has(key)) continue;
-			const child = value[key];
-			if (child === void 0) continue;
-			result[key] = canonicalizeForHash(child, seen, positionOf(position, key));
-		}
-		return result;
-	} finally {
-		seen.delete(value);
-	}
-}
-/**
-* Key-sorted JSON for comparing two events by content: key insertion order
-* does not count, so an entry read back from storage equals the one that was
-* appended.
-* @internal
-*/
-function canonicalEventJson(event) {
-	return stableJson(canonicalizeForHash(event, /* @__PURE__ */ new Set(), "data"));
-}
-function stableJson(value) {
-	return JSON.stringify(sortJson(value));
-}
-function sortJson(value) {
-	if (Array.isArray(value)) return value.map(sortJson);
-	if (value && typeof value === "object") return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sortJson(value[key])]));
-	return value;
-}
-/**
-* The canonical hash of a PERSISTED snapshot (`machine.getPersistedSnapshot()`,
-* or {@link replay}'s `persistedSnapshot`) — the value recorded in an entry's
-* `verification.stateHash`.
-*
-* Stripped before hashing, because they are re-minted on every fold and would
-* otherwise make two identical runs hash differently: `sessionId`,
-* `_nextTimerId` and `_nextActorIds` at the snapshot root, `sessionId` on each
-* `children[*]` entry (recursively, through nested child snapshots), and
-* `undefined`-valued properties (so a snapshot hashes the same before and
-* after a JSON round-trip). Stripping is confined to those structural
-* positions: a `sessionId` inside `context`, `output`, `error` or an event
-* payload is application data and is hashed. Object keys are sorted, so key
-* order is irrelevant.
-*
-* A change detector, not a cryptographic digest.
-*/
-function getSnapshotStateHash(snapshot) {
-	return require_decision.djb2Hex(stableJson(canonicalizeForHash(snapshot)));
-}
-function machineIdOf(machine) {
-	return machine.config.id ?? machine.id ?? "(machine)";
-}
-function toPersisted(machine, snapshot) {
-	return typeof snapshot.matches === "function" ? machine.getPersistedSnapshot(snapshot) : snapshot;
-}
-/**
-* Creates a JSON-safe, self-describing entry for `event` appended after
-* `entries` (which must be the complete prefix, so `index` and the recorded
-* state hash line up).
-*/
-function createReplayEntry(machine, entries, event, options = {}) {
-	const index = entries.length;
-	const machineVersion = options.machineVersion ?? require_decision.resolveMachineVersion(machine);
-	const entry = {
-		schemaVersion: 1,
-		id: options.id ?? `evt_${String(index).padStart(8, "0")}`,
-		index,
-		recordedAt: options.recordedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-		machineId: machineIdOf(machine),
-		machineVersion,
-		event: normalizeEventErrors(event),
-		...options.causationId !== void 0 ? { causationId: options.causationId } : {},
-		...options.metadata !== void 0 ? { metadata: options.metadata } : {}
-	};
-	assertAgentLogEntry(entry);
-	if (options.verification !== false) entry.verification = { stateHash: getSnapshotStateHash(options.snapshot ? toPersisted(machine, options.snapshot) : replay(machine, [...entries, entry], {
-		machineVersion,
-		verify: false
-	}).persistedSnapshot) };
-	return entry;
-}
-function pruneUndefined(value) {
-	if (Array.isArray(value)) return value.map(pruneUndefined);
-	if (value === null || typeof value !== "object") return value;
-	if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return value;
-	const result = {};
-	for (const [key, child] of Object.entries(value)) {
-		if (child === void 0) continue;
-		result[key] = pruneUndefined(child);
-	}
-	return result;
-}
-/**
-* The reserved first entry of a log. Pass EXACTLY one of:
+* behaves like a normal XState actor whose agent invokes now reach real models.
 *
-* - `{ input }` — a fresh start; replay folds from `initialTransition`.
-* - `{ snapshot }` — a continuation from a persisted snapshot: a version
-*   bridge, or a legacy snapshot that predates the log. Replay restores it
-*   purely (no actors started) and folds the rest of the log onto it.
+* Binding pass over `machine.sources.actors` (after merging
+* `options.actors`):
+* - `mode: 'generate'` text source → `executors.generateText`
+* - `mode: 'stream'` text source → `executors.streamText`
+* - decision / `agent.decide` source → `executors.decide` (snapshot-driven
+*   candidate events, guard `canTake`, and auto-delivery of the chosen event,
+*   mirroring `runAgent` but without its model-call counting)
 *
-* `options.metadata.executionId` names the lineage; this library always sets
-* one, and readers must tolerate its absence in logs written elsewhere.
-*/
-function initEntry(machine, init = {}, options = {}) {
-	const hasSnapshot = init.snapshot !== void 0;
-	if (hasSnapshot && init.input !== void 0) throw new AgentEventLogError("initEntry accepts exactly one of `input` (fresh start) or `snapshot` (continuation).");
-	return createReplayEntry(machine, [], {
-		type: AGENT_INIT_EVENT_TYPE,
-		...hasSnapshot ? { snapshot: pruneUndefined(init.snapshot) } : init.input !== void 0 ? { input: init.input } : {}
-	}, options);
-}
-/** Whether `entry` is the reserved init entry. */
-function isInitEntry(entry) {
-	return entry?.event?.type === AGENT_INIT_EVENT_TYPE;
-}
-/** Whether `entry` is the version-bridging init-with-snapshot entry. */
-function isSnapshotInitEntry(entry) {
-	return isInitEntry(entry) && entry.event.snapshot !== void 0;
-}
-/**
-* The log's execution id: the lineage identity pinned in the init entry's
-* `metadata.executionId`.
+* Pass `options.onTrace` to observe request-level trace events (identical in
+* shape to `runAgent`'s); pair it with {@link traceTransitions} on the actor's
+* `inspect` to also capture `machine.transition` events in the same stream.
 *
-* Minted once per run and inherited verbatim by every resume of that log, so
-* it names one lineage rather than one process. Entry ids cannot serve this
-* role — the built-in ids are index-derived, so every log's init entry is
-* `evt_00000000`. A fork copies the init entry, so it shares its parent's
-* execution id by construction.
+* A source that already carries its own executor (`.withExecutor(...)`) is left
+* as-is.
+* itself, so supply a handler via `options.actors` if the machine uses it.
+* Non-agent actors are untouched.
 *
-* Returns `undefined` for a log with no init entry and for one written without
-* the field — callers must treat the id as optional.
-*/
-function getLogExecutionId(entries) {
-	const executionId = (entries.find((entry) => isInitEntry(entry))?.metadata)?.executionId;
-	return typeof executionId === "string" ? executionId : void 0;
-}
-/**
-* Validates a log before replay or append: every envelope well-formed, indices
-* contiguous from 0, ids unique, the first entry the reserved init entry, and
-* one consistent machine identity throughout.
+* Throws at bind time if a source needs an executor kind that `executors` does
+* not provide.
 *
-* With `machine`, entries are also checked against that machine's id and
-* resolved version — a mismatch throws {@link AgentMachineVersionMismatchError}.
-* An init-with-snapshot entry is exempt from the version check: that entry is
-* itself the bridge from whatever version produced the snapshot.
+* 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 validateReplayEntries(entries, options = {}) {
-	if (entries.length === 0) return;
-	const reference = entries.find((entry) => !isSnapshotInitEntry(entry)) ?? entries[0];
-	const expected = options.machine ? {
-		machineId: machineIdOf(options.machine),
-		machineVersion: options.machineVersion ?? require_decision.resolveMachineVersion(options.machine)
-	} : {
-		machineId: reference.machineId,
-		machineVersion: options.machineVersion ?? reference.machineVersion
+function provideExecutors(machine, executors, options = {}) {
+	const bindOptions = {
+		onChunk: options.onChunk,
+		onTrace: options.onTrace
 	};
-	const ids = /* @__PURE__ */ new Set();
-	for (let index = 0; index < entries.length; index++) {
-		const entry = entries[index];
-		assertAgentLogEntry(entry);
-		if (entry.index !== index) throw new AgentEventLogError(`Event log must be contiguous from index 0; found entry.index ${entry.index} at position ${index}.`);
-		if (ids.has(entry.id)) throw new AgentEventLogError(`Event log contains duplicate entry id '${entry.id}'.`);
-		ids.add(entry.id);
-		if (index === 0 && !isInitEntry(entry)) throw new AgentEventLogError(`Event log must start with the reserved '${AGENT_INIT_EVENT_TYPE}' entry; found '${entry.event.type}'.`);
-		if (index > 0 && isInitEntry(entry)) throw new AgentEventLogError(`Event log has a second '${AGENT_INIT_EVENT_TYPE}' entry at index ${index}.`);
-		const versionMatches = entry.machineVersion === expected.machineVersion;
-		if (entry.machineId !== expected.machineId || !versionMatches && !isSnapshotInitEntry(entry)) throw new AgentMachineVersionMismatchError(entry.id, entry.index, expected, {
-			machineId: entry.machineId,
-			machineVersion: entry.machineVersion
-		});
-	}
-}
-/**
-* The prefix `[0, upToIndex)` of a log, as a new log. `upToIndex` is exclusive
-* and must leave the init entry in place, so the fork is still self-contained.
-*/
-function forkEventLog(entries, upToIndex) {
-	if (!Number.isInteger(upToIndex) || upToIndex < 1 || upToIndex > entries.length) throw new AgentEventLogError(`forkEventLog: upToIndex must be an integer in [1, ${entries.length}]; got ${String(upToIndex)}.`);
-	const forked = entries.slice(0, upToIndex);
-	if (!isInitEntry(forked[0])) throw new AgentEventLogError(`forkEventLog: the forked prefix must start with the reserved '${AGENT_INIT_EVENT_TYPE}' entry.`);
-	return forked;
-}
-const DONE_ACTOR_EVENT_TYPE = "xstate.done.actor";
-const ERROR_ACTOR_EVENT_TYPE = "xstate.error.actor";
-/** Normalizes a mixed `EventObject | AgentLogEntry` history into bare events. */
-function toEvents(history) {
-	if (!history) return [];
-	return history.map((item) => {
-		const candidate = item;
-		return candidate?.schemaVersion === 1 && typeof candidate.index === "number" && candidate.event !== null && typeof candidate.event === "object" ? candidate.event : item;
-	});
-}
-/**
-* The 1-based occurrence `n` for the NEXT call at invoke site `siteId`:
-* `1 + completions`, where a completion is a journaled `xstate.done.actor` OR
-* `xstate.error.actor` for that `actorId` (an error is a semantic completion).
-* The one counting rule behind every `${siteId}#${n}` call key, so a live run
-* and a replay derive the same `n` by construction.
-*/
-function agentCallOccurrence(history, siteId) {
-	let count = 0;
-	for (const event of toEvents(history)) if ((event.type === DONE_ACTOR_EVENT_TYPE || event.type === ERROR_ACTOR_EVENT_TYPE) && event.actorId === siteId) count++;
-	return count + 1;
-}
-/**
-* Folds the reserved `@agent.usage` entries of a log into one cumulative usage
-* total. The log is the source of truth, so the totals are a pure projection of
-* it: replay a log, fold it, and you get the numbers the run reported with no
-* host-side accumulator in between.
-*
-* Accepts entries or bare events. Token fields are partial sums: a field stays
-* `undefined` until some entry reports it, and non-finite values are ignored.
-*/
-function getUsageFromEvents(entries) {
-	const totals = {};
-	for (const event of toEvents(entries)) {
-		if (event.type !== "@agent.usage") continue;
-		const usage = event.usage;
-		if (!usage || typeof usage !== "object") continue;
-		for (const field of require_decision.AGENT_USAGE_TOKEN_FIELDS) {
-			const value = usage[field];
-			if (typeof value === "number" && Number.isFinite(value)) totals[field] = (totals[field] ?? 0) + value;
+	const withActors = (target, actors) => target.provide({ actors });
+	const provided = options.actors ? withActors(machine, options.actors) : machine;
+	const effectiveSources = provided.sources.actors;
+	const wrappedSources = {};
+	const invokedSrcs = require_run_agent.getConfiguredInvokeSrcs(provided);
+	for (const [key, logic] of Object.entries(effectiveSources)) {
+		if (require_run_agent.isStateMachineLogic(logic)) {
+			if (invokedSrcs.has(key)) assertChildBindable(logic, executors, key, new Set([provided]));
+			const rebound = require_run_agent.bindChildMachineForProvide(logic, executors, bindOptions, new Set([provided]));
+			if (rebound !== logic) wrappedSources[key] = rebound;
+			continue;
 		}
+		const requirement = executorRequirementOf(logic);
+		if (!requirement) continue;
+		const binding = {
+			...requirement,
+			bind: () => require_decision.isDecisionLogic(logic) ? require_run_agent.bindDecisionForProvide(provided, logic, executors, bindOptions) : require_run_agent.bindTextForProvide(provided, logic, executors, bindOptions)
+		};
+		if (require_text_logic.executorBoundLogics.has(logic)) continue;
+		if (!executors[binding.executorKey]) {
+			if (invokedSrcs.has(key)) throw missingExecutorError(key, binding.kind, binding.executorKey);
+			continue;
+		}
+		wrappedSources[key] = binding.bind();
 	}
-	return totals;
-}
-/**
-* Rewrites a journaled `xstate.done.actor`/`xstate.error.actor` event's
-* `sessionId` to the session the CURRENT fold minted for that `actorId`.
-*
-* Session ids are re-minted on every fold, and XState drops a completion event
-* whose `sessionId` does not match the live child — silently, as a no-op
-* transition. Rebinding is what makes a journaled completion replayable at all.
-* `sessions` caches the mapping per fold, so a later event referring to the
-* recorded session of an already-stopped child still resolves.
-*/
-function rebindActorSession(event, snapshot, sessions) {
-	const actorEvent = event;
-	if (typeof actorEvent.actorId !== "string" || typeof actorEvent.sessionId !== "string") return event;
-	const key = `${actorEvent.actorId}\0${actorEvent.sessionId}`;
-	let sessionId = sessions.get(key);
-	if (!sessionId) {
-		const child = snapshot.children[actorEvent.actorId];
-		if (typeof child?.sessionId !== "string") return event;
-		sessionId = child.sessionId;
-		sessions.set(key, sessionId);
-	}
-	return {
-		...event,
-		sessionId
-	};
-}
-function verifyEntry(entry, persisted, mode) {
-	if (mode === false) return;
-	if (!entry.verification) {
-		if (mode === "strict") throw new AgentReplayDivergenceError(entry.id, entry.index, "missing-verification");
-		return;
-	}
-	const actual = getSnapshotStateHash(persisted);
-	if (actual !== entry.verification.stateHash) throw new AgentReplayDivergenceError(entry.id, entry.index, "state", entry.verification.stateHash, actual);
-}
-/**
-* Folds a log through XState's pure `initialTransition`/`transition` WITHOUT
-* executing anything: no actor is started, no action runs, no model is called.
-* A journaled `xstate.done.actor` entry carries the completed actor's output
-* inline, so the invoke it belongs to is never re-run. Crash recovery, fork
-* resume, and time travel in one call.
-*
-* The first entry is the reserved {@link initEntry}: `input` folds from
-* `initialTransition`, `snapshot` restores the persisted snapshot purely
-* (`machine.restoreSnapshot`) and folds the rest of the log onto it.
-*/
-function replay(machine, entries, options = {}) {
-	validateReplayEntries(entries, {
-		machine,
-		machineVersion: options.machineVersion ?? require_decision.resolveMachineVersion(machine)
-	});
-	if (entries.length === 0) throw new AgentEventLogError(`Cannot replay an empty event log; it must start with a '${AGENT_INIT_EVENT_TYPE}' entry.`);
-	const initEvent = entries[0].event;
-	let snapshot = initEvent.snapshot !== void 0 ? machine.restoreSnapshot(initEvent.snapshot) : (0, xstate.initialTransition)(machine, initEvent.input)[0];
-	let persisted = machine.getPersistedSnapshot(snapshot);
-	verifyEntry(entries[0], persisted, options.verify);
-	const sessions = /* @__PURE__ */ new Map();
-	for (let index = 1; index < entries.length; index++) {
-		const entry = entries[index];
-		const event = rebindActorSession(entry.event, snapshot, sessions);
-		[snapshot] = (0, xstate.transition)(machine, snapshot, event);
-		persisted = machine.getPersistedSnapshot(snapshot);
-		verifyEntry(entry, persisted, options.verify);
-	}
-	return {
-		snapshot,
-		persistedSnapshot: persisted
-	};
+	return withActors(provided, wrappedSources);
 }
-//#endregion
-//#region src/event-log-store.ts
-/**
-* Durable storage for {@link AgentLogEntry} logs: the one interface a host
-* implements, plus the in-memory reference implementation the conformance
-* suite is written against.
-* @module
-*/
-/**
-* Rejection from {@link AgentEventLogStore.append} when the thread's stored
-* length is not the `expectedIndex` the writer held — a concurrent writer
-* appended first. `actualIndex` is the next index the store would accept.
-*/
-var AgentEventLogConflictError = class extends require_decision.AgentError {
-	threadId;
-	expectedIndex;
-	actualIndex;
-	constructor(threadId, expectedIndex, actualIndex) {
-		super("event-log-conflict", `AgentEventLogStore.append: index conflict on thread "${threadId}": expected index ${expectedIndex} but found ${actualIndex} — a concurrent writer won.`);
-		this.name = "AgentEventLogConflictError";
-		this.threadId = threadId;
-		this.expectedIndex = expectedIndex;
-		this.actualIndex = actualIndex;
-	}
-};
-/**
-* In-memory reference store, and the baseline the conformance suite runs
-* against. Per-thread entries are held in a contiguous, index-ordered list;
-* append's check-and-push runs synchronously (no `await` between reading the
-* length and writing), so two appends racing on the same `expectedIndex`
-* resolve to exactly one winner. Every stored and returned entry is
-* `structuredClone`d, so a caller can neither mutate stored state through a
-* value it appended nor through a value it read.
-*/
-function createInMemoryEventLogStore() {
-	const threads = /* @__PURE__ */ new Map();
-	const clone = (value) => structuredClone(value);
-	return {
-		async append({ threadId, expectedIndex, entries }) {
-			for (const entry of entries) assertAgentLogEntry(entry);
-			for (let i = 0; i < entries.length; i++) if (entries[i].index !== expectedIndex + i) throw new Error(`AgentEventLogStore.append: entry.index (${entries[i].index}) must be contiguous from expectedIndex (${expectedIndex}); expected ${expectedIndex + i} at position ${i} on thread "${threadId}".`);
-			const list = threads.get(threadId);
-			const length = list ? list.length : 0;
-			if (length !== expectedIndex) throw new AgentEventLogConflictError(threadId, expectedIndex, length);
-			const ids = new Set((list ?? []).map((entry) => entry.id));
-			for (const entry of entries) {
-				if (ids.has(entry.id)) throw new Error(`AgentEventLogStore.append: duplicate event id "${entry.id}" in thread "${threadId}".`);
-				ids.add(entry.id);
-			}
-			const cloned = entries.map((entry) => clone(entry));
-			if (list) for (const entry of cloned) list.push(entry);
-			else threads.set(threadId, cloned);
-		},
-		async read(threadId, options) {
-			const list = threads.get(threadId) ?? [];
-			const from = options?.from ?? 0;
-			return list.slice(from).map((entry) => clone(entry));
-		},
-		async length(threadId) {
-			return threads.get(threadId)?.length ?? 0;
-		},
-		async fork({ threadId, newThreadId, upToIndex }) {
-			if ((threads.get(newThreadId)?.length ?? 0) > 0) throw new Error(`AgentEventLogStore.fork: newThreadId "${newThreadId}" already has entries.`);
-			const source = threads.get(threadId);
-			if (!source) throw new Error(`AgentEventLogStore.fork: unknown source thread "${threadId}".`);
-			const upTo = upToIndex ?? source.length;
-			if (!Number.isInteger(upTo) || upTo < 1 || upTo > source.length) throw new Error(`AgentEventLogStore.fork: upToIndex must be an integer in [1, ${source.length}] on thread "${threadId}"; got ${String(upTo)}.`);
-			threads.set(newThreadId, source.slice(0, upTo).map((entry) => clone(entry)));
-		}
+/** 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"
 	};
-}
-//#endregion
-//#region src/event-log-store-conformance.ts
-/**
-* The runner-agnostic conformance suite for {@link AgentEventLogStore}
-* implementations. Split out of `event-log-store.ts` so the store contract and
-* the reference implementation stay readable.
-*
-* Every case throws a descriptive `Error` on the first violation, so any test
-* runner (or a plain script) can drive it against its own store. Pass a
-* `{ describe, it }` harness to register one test per case instead.
-* @module
-*/
-function fail(message) {
-	throw new Error(`event-log-store conformance: ${message}`);
-}
-function entry(index, type, metadata) {
-	return {
-		schemaVersion: 1,
-		id: `evt_${index}`,
-		index,
-		recordedAt: "2026-01-01T00:00:00.000Z",
-		machineId: "conformance",
-		machineVersion: "v1",
-		event: {
-			type,
-			seq: index
-		},
-		...metadata !== void 0 ? { metadata } : {}
+	if (require_text_logic.isTextLogic(logic)) return logic.mode === "stream" ? {
+		executorKey: "streamText",
+		kind: "streaming text"
+	} : {
+		executorKey: "generateText",
+		kind: "text"
 	};
 }
-function entriesFrom(start, count) {
-	return Array.from({ length: count }, (_unused, i) => entry(start + i, `e${start + i}`));
-}
-function assertJsonEqual(actual, expected, message) {
-	const a = JSON.stringify(actual);
-	const b = JSON.stringify(expected);
-	if (a !== b) fail(`${message} (expected ${b}, got ${a})`);
-}
-const cases = [
-	{
-		name: "an unknown thread reads empty and has length 0",
-		async run(create) {
-			const store = await create();
-			assertJsonEqual(await store.read("missing"), [], "read of an unknown thread must be empty");
-			if (await store.length("missing") !== 0) fail("length of an unknown thread must be 0");
-		}
-	},
-	{
-		name: "a single append reads back verbatim",
-		async run(create) {
-			const store = await create();
-			const e = entry(0, "start", { label: "first" });
-			await store.append({
-				threadId: "t",
-				expectedIndex: 0,
-				entries: [e]
-			});
-			assertJsonEqual(await store.read("t"), [e], "read must return the appended entry");
-			if (await store.length("t") !== 1) fail("length after a single append must be 1");
-		}
-	},
-	{
-		name: "a second append extends the log in order",
-		async run(create) {
-			const store = await create();
-			await store.append({
-				threadId: "t",
-				expectedIndex: 0,
-				entries: entriesFrom(0, 3)
-			});
-			await store.append({
-				threadId: "t",
-				expectedIndex: 3,
-				entries: entriesFrom(3, 2)
-			});
-			if (await store.length("t") !== 5) fail("length after appending 3 then 2 entries must be 5");
-			assertJsonEqual((await store.read("t")).map((e) => e.index), [
-				0,
-				1,
-				2,
-				3,
-				4
-			], "reads must return entries in contiguous log order");
-		}
-	},
-	{
-		name: "a non-contiguous entry.index is misuse, not a race",
-		async run(create) {
-			const store = await create();
-			let caught;
-			try {
-				await store.append({
-					threadId: "t",
-					expectedIndex: 0,
-					entries: [entry(1, "gap")]
-				});
-			} catch (error) {
-				caught = error;
-			}
-			if (!(caught instanceof Error) || caught instanceof AgentEventLogConflictError) fail("a non-contiguous entry.index must throw a plain Error, not a conflict");
-		}
-	},
-	{
-		name: "a stale expectedIndex conflicts with correct fields",
-		async run(create) {
-			const store = await create();
-			await store.append({
-				threadId: "t",
-				expectedIndex: 0,
-				entries: [entry(0, "a")]
-			});
-			let caught;
-			try {
-				await store.append({
-					threadId: "t",
-					expectedIndex: 0,
-					entries: [entry(0, "b")]
-				});
-			} catch (error) {
-				caught = error;
-			}
-			if (!(caught instanceof AgentEventLogConflictError)) fail("a stale expectedIndex must throw AgentEventLogConflictError");
-			if (caught.threadId !== "t" || caught.expectedIndex !== 0 || caught.actualIndex !== 1) fail("conflict error must carry threadId, expectedIndex, and the actual index");
-		}
-	},
-	{
-		name: "entry ids are unique within a thread",
-		async run(create) {
-			const store = await create();
-			await store.append({
-				threadId: "t",
-				expectedIndex: 0,
-				entries: [entry(0, "a")]
-			});
-			let caught;
-			try {
-				await store.append({
-					threadId: "t",
-					expectedIndex: 1,
-					entries: [{
-						...entry(1, "b"),
-						id: "evt_0"
-					}]
-				});
-			} catch (error) {
-				caught = error;
-			}
-			if (!(caught instanceof Error) || caught instanceof AgentEventLogConflictError) fail("a duplicate event id within a thread must throw a plain Error");
-		}
-	},
-	{
-		name: "concurrent appends at the same index have exactly one winner",
-		async run(create) {
-			const store = await create();
-			await store.append({
-				threadId: "t",
-				expectedIndex: 0,
-				entries: [entry(0, "a")]
-			});
-			const results = await Promise.allSettled([store.append({
-				threadId: "t",
-				expectedIndex: 1,
-				entries: [entry(1, "w-a")]
-			}), store.append({
-				threadId: "t",
-				expectedIndex: 1,
-				entries: [entry(1, "w-b")]
-			})]);
-			const winners = results.filter((r) => r.status === "fulfilled");
-			const conflicts = results.filter((r) => r.status === "rejected" && r.reason instanceof AgentEventLogConflictError);
-			if (winners.length !== 1) fail(`exactly one racing append must win, got ${winners.length}`);
-			if (conflicts.length !== 1) fail(`exactly one racing append must reject with a conflict, got ${conflicts.length}`);
-			if (await store.length("t") !== 2) fail("after the race the log length must be 2");
-		}
-	},
-	{
-		name: "read({ from }) is incrementally correct",
-		async run(create) {
-			const store = await create();
-			await store.append({
-				threadId: "t",
-				expectedIndex: 0,
-				entries: entriesFrom(0, 5)
-			});
-			assertJsonEqual((await store.read("t", { from: 2 })).map((e) => e.index), [
-				2,
-				3,
-				4
-			], "read({ from }) must skip entries below `from`");
-			assertJsonEqual(await store.read("t", { from: 5 }), [], "read({ from }) at the log length must be empty");
-		}
-	},
-	{
-		name: "threads are isolated and grow independently",
-		async run(create) {
-			const store = await create();
-			await store.append({
-				threadId: "a",
-				expectedIndex: 0,
-				entries: [entry(0, "x")]
-			});
-			if (await store.length("b") !== 0) fail("an append to one thread must not create another");
-			await store.append({
-				threadId: "b",
-				expectedIndex: 0,
-				entries: entriesFrom(0, 2)
-			});
-			if (await store.length("a") !== 1 || await store.length("b") !== 2) fail("threads must grow independently");
-		}
-	},
-	{
-		name: "metadata round-trips verbatim",
-		async run(create) {
-			const store = await create();
-			const metadata = {
-				source: "user",
-				nested: { attempt: 2 },
-				tags: ["x", "y"]
-			};
-			await store.append({
-				threadId: "t",
-				expectedIndex: 0,
-				entries: [entry(0, "e", metadata)]
-			});
-			assertJsonEqual((await store.read("t"))[0].metadata, metadata, "metadata must round-trip verbatim");
-		}
-	},
-	{
-		name: "stored entries are isolated from caller mutation",
-		async run(create) {
-			const store = await create();
-			const e = entry(0, "e", { tags: ["a"] });
-			await store.append({
-				threadId: "t",
-				expectedIndex: 0,
-				entries: [e]
-			});
-			e.metadata.tags.push("mutated-after-append");
-			e.event.seq = 999;
-			const read = await store.read("t");
-			read[0].metadata.tags.push("mutated-after-read");
-			read[0].event.seq = 888;
-			const reread = await store.read("t");
-			assertJsonEqual(reread[0].metadata, { tags: ["a"] }, "stored entry must be isolated from post-append and post-read mutation");
-			assertJsonEqual(reread[0].event, {
-				type: "e",
-				seq: 0
-			}, "stored event must be isolated from mutation of an appended or read copy");
-		}
-	},
-	{
-		name: "fork copies a prefix and then diverges independently",
-		async run(create) {
-			const store = await create();
-			await store.append({
-				threadId: "src",
-				expectedIndex: 0,
-				entries: entriesFrom(0, 3)
-			});
-			await store.fork({
-				threadId: "src",
-				newThreadId: "fork-full"
-			});
-			if (await store.length("fork-full") !== 3) fail("fork with the default upToIndex must copy the full log");
-			await store.fork({
-				threadId: "src",
-				newThreadId: "fork-1",
-				upToIndex: 1
-			});
-			assertJsonEqual((await store.read("fork-1")).map((e) => e.index), [0], "fork with upToIndex 1 must copy only entry 0");
-			await store.fork({
-				threadId: "src",
-				newThreadId: "fork-2",
-				upToIndex: 2
-			});
-			assertJsonEqual((await store.read("fork-2")).map((e) => e.id), ["evt_0", "evt_1"], "fork with upToIndex 2 must copy entries 0 and 1 only");
-			await store.append({
-				threadId: "fork-1",
-				expectedIndex: 1,
-				entries: [entry(1, "branch")]
-			});
-			assertJsonEqual((await store.read("fork-1")).map((e) => e.event.type), ["e0", "branch"], "a forked thread must append independently from its copied length");
-			if (await store.length("src") !== 3) fail("appending to a fork must not touch the source thread");
-		}
-	},
-	{
-		name: "fork rejects a non-empty target, an unknown source, and an out-of-range cutoff (0 included)",
-		async run(create) {
-			const store = await create();
-			await store.append({
-				threadId: "src",
-				expectedIndex: 0,
-				entries: entriesFrom(0, 3)
-			});
-			await store.fork({
-				threadId: "src",
-				newThreadId: "fork-full"
-			});
-			let caughtExisting;
-			try {
-				await store.fork({
-					threadId: "src",
-					newThreadId: "fork-full"
-				});
-			} catch (error) {
-				caughtExisting = error;
-			}
-			if (!(caughtExisting instanceof Error) || caughtExisting instanceof AgentEventLogConflictError) fail("forking onto a non-empty thread must reject with a plain Error");
-			let caughtUnknown;
-			try {
-				await store.fork({
-					threadId: "nope",
-					newThreadId: "fork-nope"
-				});
-			} catch (error) {
-				caughtUnknown = error;
-			}
-			if (!(caughtUnknown instanceof Error) || caughtUnknown instanceof AgentEventLogConflictError) fail("forking an unknown source thread must reject with a plain Error");
-			let caughtRange;
-			try {
-				await store.fork({
-					threadId: "src",
-					newThreadId: "fork-range",
-					upToIndex: 99
-				});
-			} catch (error) {
-				caughtRange = error;
-			}
-			if (!(caughtRange instanceof Error) || caughtRange instanceof AgentEventLogConflictError) fail("forking past the source length must reject with a plain Error");
-			let caughtZero;
-			try {
-				await store.fork({
-					threadId: "src",
-					newThreadId: "fork-zero",
-					upToIndex: 0
-				});
-			} catch (error) {
-				caughtZero = error;
-			}
-			if (!(caughtZero instanceof Error) || caughtZero instanceof AgentEventLogConflictError) fail("forking with upToIndex 0 must reject with a plain Error");
-			if (await store.length("fork-zero") !== 0) fail("a rejected fork must not create the target thread");
-		}
-	}
-];
-/**
-* Validates a store against the reference's semantics: empty read + zero length
-* for unknown threads; single and multi-entry append; contiguity misuse guard;
-* stale-`expectedIndex` conflict with correct fields; an interleaved concurrent
-* append race (exactly one winner); entry-id uniqueness; `read({ from })`
-* incremental correctness; thread isolation; metadata round-trip; deep-copy
-* isolation on append and read; and the full fork contract.
-*
-* Without a `harness`, every case runs in sequence and the first violation
-* throws. With one, each case is registered as its own test:
-*
-* ```ts
-* import { describe, it } from 'vitest';
-* assertEventLogStoreConformance(createMyStore, { describe, it });
-* ```
-*/
-async function assertEventLogStoreConformance(create, harness) {
-	if (harness) {
-		harness.describe("AgentEventLogStore conformance", () => {
-			for (const testCase of cases) harness.it(testCase.name, () => testCase.run(create));
-		});
-		return;
-	}
-	for (const testCase of cases) await testCase.run(create);
-}
-//#endregion
-//#region src/run-agent.ts
-/**
-* Thrown by {@link runAgent} when a resume is given BOTH an `events` log and a
-* `snapshot` that claims a position in that log (`agentMeta.logIndex`), and the
-* two disagree about the state at that position. The log is the source of
-* truth, so this is a host bug (a snapshot cached from a different lineage, or
-* a snapshot mutated out of band), not a recoverable resume: pass the log
-* alone, or the matching snapshot.
-*/
-var AgentSnapshotDivergedError = class extends require_decision.AgentError {
-	constructor(expected, actual, logIndex) {
-		super("snapshot-diverged", `runAgent: the resume snapshot disagrees with the event log at index ${logIndex}: the log replays to state hash '${expected}', the snapshot hashes '${actual}'.`);
-		this.expected = expected;
-		this.actual = actual;
-		this.logIndex = logIndex;
-		this.name = "AgentSnapshotDivergedError";
-	}
-};
-function hashResumeSnapshot(snapshot) {
-	if (snapshot !== null && typeof snapshot === "object" && "agentMeta" in snapshot) {
-		const rest = {};
-		for (const [key, value] of Object.entries(snapshot)) if (key !== "agentMeta") rest[key] = value;
-		return getSnapshotStateHash(rest);
-	}
-	return getSnapshotStateHash(snapshot);
-}
-function readAgentMeta(snapshot) {
-	const meta = snapshot?.agentMeta;
-	return meta !== null && typeof meta === "object" ? meta : void 0;
-}
-/**
-* The version of the {@link AgentTraceEvent} envelope every trace event carries
-* as `schemaVersion`. Bumped only on a breaking change to the envelope or any
-* payload shape, so a consumer can gate on it. Emitted identically by
-* {@link runAgent}, {@link provideExecutors}' `onTrace`, and
-* {@link traceTransitions}.
-*/
-const AGENT_TRACE_SCHEMA_VERSION = 1;
-const TRACE_ENVELOPE_KEYS = [
-	"schemaVersion",
-	"runId",
-	"seq",
-	"timestamp",
-	"machineId",
-	"machineVersion",
-	"type",
-	"status",
-	"cause",
-	"reasoning",
-	"finishReason",
-	"chunk"
-];
-/**
-* Best-effort JSON projection of an arbitrary value. Never throws: functions,
-* symbols, `undefined`, and cyclic back-references are DROPPED (array holes
-* become `null`), non-finite numbers become `null`, `bigint`s become strings,
-* `Error`s become `{ name, message, stack?, code? }`, and anything with a
-* `toJSON()` (e.g. `Date`) is projected through it — the same losses a
-* `JSON.parse(JSON.stringify(...))` round-trip incurs, minus the throws.
-*/
-function toJsonValue(value, ancestors) {
-	if (value === null) return null;
-	const type = typeof value;
-	if (type === "string" || type === "boolean") return value;
-	if (type === "number") return Number.isFinite(value) ? value : null;
-	if (type === "bigint") return value.toString();
-	if (type !== "object") return;
-	const object = value;
-	if (ancestors.includes(object)) return;
-	const nextAncestors = [...ancestors, object];
-	if (object instanceof Error) {
-		const serialized = {
-			name: object.name,
-			message: object.message
-		};
-		if (typeof object.stack === "string") serialized.stack = object.stack;
-		const code = object.code;
-		if (typeof code === "string") serialized.code = code;
-		const cause = toJsonValue(object.cause, nextAncestors);
-		if (cause !== void 0) serialized.cause = cause;
-		return serialized;
-	}
-	const toJSON = object.toJSON;
-	if (typeof toJSON === "function") return toJsonValue(toJSON.call(object), nextAncestors);
-	if (Array.isArray(object)) return object.map((item) => toJsonValue(item, nextAncestors) ?? null);
-	const out = {};
-	for (const [key, item] of Object.entries(object)) {
-		const serializedItem = toJsonValue(item, nextAncestors);
-		if (serializedItem !== void 0) out[key] = serializedItem;
-	}
-	return out;
-}
 /**
-* Projects an {@link AgentTraceEvent} into a guaranteed JSON-safe envelope —
-* the form the trace stream is actually sold for (one `JSON.stringify` per line
-* 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 `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
-*   else.
-* - Non-serializable values anywhere (functions, symbols, `undefined`, cyclic
-*   back-references) are dropped; `Error`s become `{ name, message, stack?,
-*   code? }` instead of `{}`. Nothing throws.
-*
-* @example
-* ```ts
-* await appendFile('trace.jsonl', JSON.stringify(serializeTraceEvent(event)) + '\n');
-* ```
+* 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 serializeTraceEvent(event, options = {}) {
-	const out = {};
-	for (const [key, value] of Object.entries(event)) {
-		if (key === "raw" && !options.includeRaw) continue;
-		if (TRACE_ENVELOPE_KEYS.includes(key)) {
-			if (value !== void 0) out[key] = value;
+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 require_run_agent.getConfiguredInvokeSrcs(childMachine)) {
+		const logic = sources[src];
+		if (!logic) continue;
+		if (require_run_agent.isStateMachineLogic(logic)) {
+			assertChildBindable(logic, executors, `${path} > ${src}`, nextVisited);
 			continue;
 		}
-		const serialized = toJsonValue(value, []);
-		if (serialized !== void 0) out[key] = serialized;
-	}
-	return out;
-}
-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_decision.AgentError {
-	/** 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) {
-	let current = error;
-	for (let depth = 0; depth < 10 && current != null; depth++) {
-		if (current instanceof require_decision.AgentDecisionExhaustedError) return true;
-		current = current.cause;
-	}
-	return false;
-}
-/**
-* Recursively collects every invoke's `src` from raw machine config (spike
-* S6: `machine.config` preserves authored srcs; the built `machine.root`
-* normalizes object srcs to synthetic string ids and loses the distinction
-* this walk needs). Function-valued `src` resolvers are dynamic and are not
-* statically analyzable, so they are skipped (pass-through, like any other
-* non-agent actor).
-*/
-function collectConfiguredInvokeSrcs(stateConfig, stateName, out) {
-	if (!stateConfig) return;
-	const invokes = stateConfig.invoke === void 0 ? [] : Array.isArray(stateConfig.invoke) ? stateConfig.invoke : [stateConfig.invoke];
-	for (const invokeConfig of invokes) {
-		const src = invokeConfig?.src;
-		if (typeof src === "string" || src && typeof src === "object") out.push({
-			stateName,
-			src
-		});
+		const requirement = executorRequirementOf(logic);
+		if (!requirement || require_text_logic.executorBoundLogics.has(logic)) continue;
+		if (!executors[requirement.executorKey]) throw missingExecutorError(`${path} > ${src}`, requirement.kind, requirement.executorKey);
 	}
-	for (const [childName, childConfig] of Object.entries(stateConfig.states ?? {})) collectConfiguredInvokeSrcs(childConfig, `${stateName}.${childName}`, out);
 }
-/**
-* Duck-types a state machine actor logic (an invoked child machine) vs. any
-* other actor logic. xstate's `StateMachine` carries `.config`, `.root`, and
-* a `.provide(...)` method plus a `sources.actors` map — this
-* combination is unique to machines and survives the dual-package/version
-* boundary an `instanceof` check would not. Used to descend the bind-time
-* walk into invoked child machines (their internal agent requests are opaque
-* to the parent-level source walk otherwise).
-*/
-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;
-}
-/**
-* Fails fast (throws) at bind time — before any actor runs — when the
-* machine invokes an agent actor `runAgent` cannot execute. See §3.2 point 2.
-*
-* Recurses into invoked child state machines (arbitrarily deep). A child
-* machine's agent requests reached through string-keyed invoke srcs DO inherit
-* the parent runAgent's `generateText`/`streamText`/`decide` executors —
-* runAgent rebinds them with the same host-backed wrappers (see
-* {@link rebindChildMachine}) — so the only remaining bind-time errors are: a
-* required executor kind missing entirely (naming the invoke chain and src),
-* and an unbound request reached through a direct-object invoke src that can't
-* be rebound ({@link unrebindableChildRequestError}). A request that carries
-* its own executor (`.withExecutor(...)`, tracked in `executorBoundLogics`)
-* always runs itself; explicit binding shadows inheritance.
-*/
-function assertBindable(machine, effectiveSources, executors) {
-	assertMachineBindable(machine, effectiveSources, executors, {
-		isChild: false,
-		childPath: "",
-		rebindable: true,
-		visited: new Set([machine])
-	});
-}
-function assertMachineBindable(machine, effectiveSources, executors, ctx) {
-	const invokes = [];
-	collectConfiguredInvokeSrcs(machine.config, machine.config.id ?? "(root)", invokes);
-	const where = ctx.isChild ? `child machine '${ctx.childPath}' state` : "state";
-	for (const { stateName, src } of invokes) {
-		if (typeof src !== "string") {
-			if (isStateMachineLogic(src)) {
-				assertChildMachineBindable(src, src, stateName, executors, ctx);
-				continue;
-			}
-			if ((require_decision.isTextLogic(src) || require_decision.isDecisionLogic(src)) && !require_decision.executorBoundLogics.has(src)) throw new Error(`runAgent: ${where} '${stateName}' invokes a direct-object actor logic (kind: '${src.kind}'). Direct-object invoke srcs cannot be rebound by runAgent — either call '.withExecutor(...)' on the logic before invoking it, or register it as a string-keyed actor source instead (machine.provide({ actors: { name: logic } })) and invoke it by name.`);
-			continue;
-		}
-		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 (isStateMachineLogic(logic)) {
-			assertChildMachineBindable(logic, src, stateName, executors, ctx);
-			continue;
-		}
-		if (src === "agent.userInput") continue;
-		if (require_decision.isDecisionLogic(logic)) {
-			if (require_decision.executorBoundLogics.has(logic)) continue;
-			if (!ctx.rebindable) throw unrebindableChildRequestError(ctx.childPath, stateName, src, "decision");
-			if (!executors.decide) throw new Error(`runAgent: ${where} '${stateName}' invokes decision source '${src}' but no 'decide' executor was provided to runAgent(...).`);
-			continue;
-		}
-		if (require_decision.isTextLogic(logic)) {
-			if (require_decision.executorBoundLogics.has(logic)) continue;
-			if (!ctx.rebindable) throw unrebindableChildRequestError(ctx.childPath, stateName, src, logic.mode === "stream" ? "streaming text" : "text");
-			if (logic.mode === "stream" && !executors.streamText) throw new Error(`runAgent: ${where} '${stateName}' invokes streaming text source '${src}' but no 'streamText' executor was provided to runAgent(...).`);
-			if (logic.mode !== "stream" && !executors.generateText) throw new Error(`runAgent: ${where} '${stateName}' invokes text source '${src}' but no 'generateText' executor was provided to runAgent(...).`);
-			continue;
-		}
-		if (require_decision.isUnboundPlaceholder(logic)) throw new Error(`runAgent: ${where} '${stateName}' invokes actor source '${src}', which has no host execution. Provide it via machine.provide({ actors: { '${src}': ... } }) or runAgent(machine, { actors: { '${src}': ... } }).`);
-	}
-}
-/** Descends the bind-time walk into an invoked child state machine, guarding
-* against a machine that (transitively) invokes itself. */
-function assertChildMachineBindable(childMachine, childSrc, stateName, executors, ctx) {
-	if (ctx.visited.has(childMachine)) return;
-	const childName = typeof childSrc === "string" ? childSrc : childMachine.config.id ?? "(child machine)";
-	const childPath = ctx.childPath ? `${ctx.childPath} > ${childName}` : childName;
-	const childSources = childMachine.sources.actors;
-	assertMachineBindable(childMachine, childSources, executors, {
-		isChild: true,
-		childPath,
-		rebindable: ctx.rebindable && typeof childSrc === "string",
-		visited: new Set([...ctx.visited, childMachine])
-	});
-}
-/** The loud bind-time error for an unbound agent request reached under a
-* direct-object invoke src, which runAgent cannot rebind (only string-keyed
-* sources can be swapped via `.provide`). Names the invoke chain AND the
-* request src, and spells out the `.withExecutor`/string-keyed remedy. Note:
-* requests reachable through string-keyed srcs at any depth DO inherit
-* runAgent's executors — this error is only for the unrebindable direct-object
-* case. */
-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 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 === "@agent.usage" || transition.eventType === "*");
-}
-/**
-* Builds the ONE place a trace payload is emitted: it hands the payload to the
-* envelope-stamping trace sink and, from that same payload, invokes the sugar
-* callbacks that are projections of it — {@link RunAgentOptions.onChunk},
-* {@link RunAgentOptions.onResult}, {@link RunAgentOptions.onTransition}. Each
-* keeps its historical position relative to the trace: `onResult` fires just
-* BEFORE its `request.end`, `onChunk`/`onTransition` just AFTER their
-* `stream.chunk`/`machine.transition`. Sugar dispatch never depends on whether
-* a trace sink is present, and the trace sink is never called when it is
-* absent — so an `onTrace`-less run still mints no envelope (and advances no
-* `seq`). @internal
-*/
-function createTraceDispatch(sinks) {
-	return (payload, self) => {
-		switch (payload.type) {
-			case "stream.chunk":
-				sinks.onTrace?.(payload, self);
-				sinks.onChunk?.(payload.chunk, { request: payload.request });
-				return;
-			case "request.end":
-				sinks.onResult?.(payload.request, {
-					output: payload.output,
-					raw: payload.raw
-				});
-				sinks.onTrace?.(payload, self);
-				return;
-			case "machine.transition":
-				sinks.onTrace?.(payload, self);
-				sinks.onTransition?.(payload.snapshot, payload.event);
-				return;
-			default: sinks.onTrace?.(payload, self);
-		}
-	};
-}
-/** Reads the durable invoke id/src off the async actor's own ref (`self`). */
-function selfIdAndSrc(self) {
-	return {
-		id: typeof self?.id === "string" ? self.id : "",
-		src: typeof self?.src === "string" ? self.src : ""
-	};
-}
-/**
-* The machine actor that INVOKED a decision request — the actor whose
-* live snapshot supplies the candidate events and drives `canTake`/`send`.
-* For a top-level request this is the root actor (identity-equal to
-* `runCtx.actorHolder.actorRef`); for a request inside an invoked child
-* machine it is that child's actor, so a child decision reads and drives
-* the CHILD's snapshot — not the root's. Read off `self._parent`, with the
-* root actor as a fallback.
-*/
-function invokingActorOf(self, runCtx) {
-	return self?._parent ?? runCtx.actorHolder.actorRef;
-}
-/**
-* The shared text/stream emission helper: binds a {@link TextLogic} to
-* `runCtx`'s executor and constructs the `request.start` / `stream.chunk` /
-* `request.end` (incl. the lifted `reasoning`) / `request.error` trace payloads.
-* Used by both `runAgent` and `provideExecutors` so the two paths produce
-* identical event shapes by construction. @internal
-*/
-function bindTextLogic(logic, runCtx) {
-	return logic.withExecutor(async ({ request: rawRequest, self: selfArg, signal }) => {
-		const self = selfArg;
-		const { id, src } = selfIdAndSrc(self);
-		const request = {
-			...rawRequest,
-			name: rawRequest.name ?? (src !== "" && src !== "agent.generateText" && src !== "agent.streamText" ? src : id || src)
-		};
-		const executor = logic.mode === "stream" ? runCtx.streamText : runCtx.generateText;
-		if (!executor) throw new Error(`No '${logic.mode === "stream" ? "streamText" : "generateText"}' executor provided.`);
-		const requestWithTools = {
-			...request,
-			tools: request.tools ?? {}
-		};
-		const agentRequest = {
-			kind: "text",
-			id,
-			src,
-			mode: logic.mode,
-			input: request,
-			tools: requestWithTools.tools,
-			events: []
-		};
-		runCtx.consumeModelCall();
-		runCtx.emitTrace?.({
-			type: "request.start",
-			request: agentRequest
-		}, self);
-		try {
-			const callKey = id !== "" ? runCtx.callKey?.(id, self) : void 0;
-			await runCtx.awaitJournal?.();
-			const raw = await executor(requestWithTools, {
-				onChunk: (chunk) => {
-					runCtx.emitTrace?.({
-						type: "stream.chunk",
-						request: agentRequest,
-						chunk
-					}, self);
-				},
-				signal,
-				...runCtx.runId !== void 0 ? { runId: runCtx.runId } : {},
-				...id !== "" ? { requestId: id } : {},
-				...callKey !== void 0 ? { callKey } : {}
-			});
-			const output = await require_decision.normalizeGeneratorResult(raw, id, {
-				request,
-				onChunk: (chunk) => {
-					runCtx.emitTrace?.({
-						type: "stream.chunk",
-						request: agentRequest,
-						chunk
-					}, self);
-				}
-			});
-			const responseMessages = raw?.messages;
-			if (Array.isArray(responseMessages) && responseMessages.length > 0) {
-				const parent = invokingActorOf(self, runCtx);
-				const event = {
-					type: require_decision.AGENT_MESSAGES_EVENT_TYPE,
-					request: request.name,
-					actorId: id,
-					messages: responseMessages
-				};
-				if ((parent?.getSnapshot())?.can(event)) parent?.send(event);
-			}
-			const rawReasoning = raw?.reasoning;
-			const reasoning = typeof rawReasoning === "string" ? rawReasoning : void 0;
-			const usage = require_decision.getCallUsage(raw);
-			const finishReason = require_decision.getCallFinishReason(raw);
-			if (usage) runCtx.recordUsage?.(usage, {
-				kind: "text",
-				...id !== "" ? { id } : {},
-				...src !== "" ? { src } : {},
-				model: request.model,
-				...request.name !== void 0 ? { name: request.name } : {}
-			}, self);
-			runCtx.emitTrace?.({
-				type: "request.end",
-				request: agentRequest,
-				output,
-				raw,
-				...reasoning !== void 0 ? { reasoning } : {},
-				...usage !== void 0 ? { usage } : {},
-				...finishReason !== void 0 ? { finishReason } : {}
-			}, self);
-			return { output };
-		} catch (error) {
-			runCtx.emitTrace?.({
-				type: "request.error",
-				request: agentRequest,
-				error
-			}, self);
-			throw error;
-		}
-	});
-}
-function createCountingDecide(runCtx, self) {
-	return async (attemptRequest, info) => {
-		runCtx.consumeModelCall();
-		runCtx.emitTrace?.({
-			type: "request.start",
-			request: attemptRequest
-		}, self);
-		try {
-			const { id } = selfIdAndSrc(self);
-			const invokeCallKey = id !== "" ? runCtx.callKey?.(id, self) : void 0;
-			const callKey = invokeCallKey === void 0 ? void 0 : `${invokeCallKey}.${attemptRequest.attempts?.length ?? 0}`;
-			await runCtx.awaitJournal?.();
-			const result = await runCtx.decide(runCtx.runId !== void 0 ? {
-				...attemptRequest,
-				runId: runCtx.runId
-			} : attemptRequest, {
-				...info,
-				...runCtx.runId !== void 0 ? { runId: runCtx.runId } : {},
-				...info?.requestId === void 0 && id !== "" ? { requestId: id } : {},
-				...info?.callKey === void 0 && callKey !== void 0 ? { callKey } : {}
-			});
-			const usage = require_decision.getCallUsage(result);
-			const finishReason = require_decision.getCallFinishReason(result);
-			if (usage) {
-				const { src } = selfIdAndSrc(self);
-				runCtx.recordUsage?.(usage, {
-					kind: "decision",
-					...attemptRequest.id ? { id: attemptRequest.id } : {},
-					...src !== "" ? { src } : {},
-					model: attemptRequest.model
-				}, self);
-			}
-			runCtx.emitTrace?.({
-				type: "request.end",
-				request: attemptRequest,
-				output: result.event,
-				raw: result,
-				...usage !== void 0 ? { usage } : {},
-				...finishReason !== void 0 ? { finishReason } : {}
-			}, self);
-			return result;
-		} catch (error) {
-			runCtx.emitTrace?.({
-				type: "request.error",
-				request: attemptRequest,
-				error
-			}, self);
-			throw error;
-		}
-	};
-}
-/**
-* Builds the decision actor logic runAgent installs in place of a
-* `DecisionLogic`/`agent.decide` source. `DecisionLogic.withExecutor(...)`
-* can only swap the innermost per-attempt executor — the `resolveDecision(...)`
-* call (and its `canTake`) is hardwired inside the original logic's `run`.
-* To supply `canTake` (mode-3, §2.6), runAgent instead builds a fresh async
-* logic here that calls `resolveDecision` itself, reusing `logic.request(...)`
-* to build the request the same way the original logic would have.
-*
-* On success it SENDS the chosen event to the invoking actor (auto-delivery)
-* and then completes with that event
-* as its output — so callers never wire an `onDone` to deliver it. See the
-* send-then-complete note inside `run` for how exit-cancels-invoke interacts
-* with `onDone`.
-*/
-function bindDecisionLogic(logic, runCtx) {
-	const decisionLogic = (0, xstate.createAsyncLogic)({ run: async ({ input, signal, self: selfArg }) => {
-		if (!runCtx.decide) throw new Error("No 'decide' executor provided.");
-		const self = selfArg;
-		const { id } = selfIdAndSrc(self);
-		const declaredEventTypes = logic.allowedEventTypes?.(input);
-		await Promise.resolve();
-		const actorRef = invokingActorOf(self, runCtx);
-		const events = actorRef ? require_decision.getAcceptedEvents(actorRef.getSnapshot(), {
-			schemas: runCtx.schemas,
-			eventTypes: declaredEventTypes
-		}) : [];
-		const lowered = logic.request(input);
-		const chosen = await require_decision.resolveDecision({
-			...lowered,
-			id,
-			name: lowered.name ?? id,
-			input,
-			events
-		}, { decide: createCountingDecide(runCtx, self) }, {
-			maxRetries: logic.maxRetries,
-			signal,
-			canTake: (event) => actorRef ? actorRef.getSnapshot().can(event) : true
-		});
-		actorRef?.send(chosen);
-		await Promise.resolve();
-		return chosen;
-	} });
-	return Object.assign(decisionLogic, {
-		kind: "statelyai.decisionLogic",
-		maxRetries: logic.maxRetries,
-		request: logic.request,
-		withExecutor: (nextExecute) => bindDecisionLogic(logic.withExecutor(nextExecute), runCtx)
-	});
-}
-/**
-* The set of string-keyed actor `src`s the machine's own config invokes
-* (top-level, recursing into child STATES but not into invoked child
-* machines). {@link provideExecutors} uses it to require an executor only for a
-* source the machine actually invokes — the always-registered `agent.*`
-* builtins that go unused must not force their executors to be supplied.
-* @internal
-*/
-function getConfiguredInvokeSrcs(machine) {
-	const invokes = [];
-	collectConfiguredInvokeSrcs(machine.config, machine.config.id ?? "(root)", invokes);
-	const srcs = /* @__PURE__ */ new Set();
-	for (const { src } of invokes) if (typeof src === "string") srcs.add(src);
-	return srcs;
-}
-const rootTraceRegistry = /* @__PURE__ */ new WeakMap();
-let nextProvideRunId = 1;
-/** Walks `self._parent` from an invoked async leaf actor up to its root actor. */
-function rootActorOf(self) {
-	let ref = self;
-	while (ref?._parent) ref = ref._parent;
-	return ref;
-}
-/** The per-root envelope state, minted on first use (runId `run_<n>`, matching runAgent). */
-function rootTraceState(root) {
-	let state = rootTraceRegistry.get(root);
-	if (!state) {
-		const logic = root.logic;
-		const machineId = (logic?.config)?.id ?? logic?.id ?? "(machine)";
-		const machineVersion = logic ? require_decision.resolveMachineVersion(logic) : "";
-		state = {
-			runId: `run_${nextProvideRunId++}`,
-			seq: 0,
-			machineId,
-			machineVersion
-		};
-		rootTraceRegistry.set(root, state);
-	}
-	return state;
-}
-/** Stamps a per-root-actor envelope onto a bare trace payload. */
-function stampRootTrace(root, payload) {
-	const state = rootTraceState(root);
-	return {
-		schemaVersion: 1,
-		runId: state.runId,
-		seq: ++state.seq,
-		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-		machineId: state.machineId,
-		machineVersion: state.machineVersion,
-		...payload
-	};
-}
-/** Adapts a public `onTrace` into the payload-level trace sink a {@link TraceDispatch} fans out to. */
-function provideTraceSink(onTrace) {
-	if (!onTrace) return;
-	return (payload, self) => {
-		const root = rootActorOf(self);
-		if (root) onTrace(stampRootTrace(root, payload));
-	};
-}
-/**
-* A minimal {@link RunAgentBindContext} for `provideExecutors` (uncontrolled
-* `createActor`): the same wrappers runAgent installs, MINUS the run-scoped
-* model-call counter. `consumeModelCall` is a no-op (no budget), and
-* `actorHolder.actorRef` is left undefined — the wrappers read the invoking
-* actor off `self._parent`, always present under a live `createActor` tree.
-* `onTrace` (when given) mints a per-root-actor envelope. `schemas` come from
-* the machine's registered `setupAgent` execution options.
-*
-* `recordUsage` has no run-level aggregate to fold into here (there is no
-* run), so it does one thing: deliver the reserved `@agent.usage` event, gated
-* exactly like runAgent's — see {@link deliverUsageEvent}.
-*/
-function provideBindContext(machine, executors, options) {
-	const traceSink = provideTraceSink(options.onTrace);
-	const onChunk = options.onChunk;
-	return {
-		generateText: executors.generateText,
-		streamText: executors.streamText,
-		decide: executors.decide,
-		emitTrace: traceSink || onChunk ? createTraceDispatch({
-			onTrace: traceSink,
-			onChunk: onChunk ? (chunk) => onChunk(chunk) : void 0
-		}) : void 0,
-		consumeModelCall: () => {},
-		recordUsage: (usage, source, self) => {
-			deliverUsageEvent({
-				type: require_setup_agent.AGENT_USAGE_EVENT_TYPE,
-				...source,
-				usage
-			}, () => self?._parent);
-		},
-		actorHolder: { actorRef: void 0 },
-		schemas: require_decision.getRegisteredAgentExecutionOptions(machine).schemas
-	};
-}
-/**
-* The single reserved-`@agent.usage` DELIVERY seam, shared by both bind paths:
-* after a bound call settles with reported usage, send the prebuilt `event` to
-* the machine actor `resolveActorRef` names — the run's root actor on the `runAgent` path,
-* the settling request actor's `self._parent` (always the invoking machine
-* under a live `createActor` tree) on the `provideExecutors` path.
-*
-* Journaling is separate and unconditional (see `recordUsage`): a call's tokens
-* are recorded in the event log whether or not the machine reacts to them.
-*
-* Gating is identical on both: the target snapshot must be active, must declare
-* 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.
-*
-* Delivery follows each path's binding boundary: only sources IT bound report
-* here, so an invoked child machine that was not itself passed through
-* `provideExecutors` reports nothing. @internal
-*/
-function deliverUsageEvent(event, resolveActorRef, onDropped) {
-	const actorRef = resolveActorRef();
-	if (!actorRef) return;
-	const snapshot = actorRef.getSnapshot();
-	if (snapshot?.status !== "active" || !declaresUsageTransition(snapshot)) return;
-	if (onDropped?.(event)) return;
-	if (!snapshot.can(event)) return;
-	actorRef.send(event);
-}
-/**
-* Host-binds one text/stream source for {@link provideExecutors} using the SAME
-* emission helper as `runAgent` ({@link bindTextLogic}), so a bound
-* text request emits request.start/stream.chunk/request.end/request.error with
-* identical shapes. @internal
-*/
-function bindTextForProvide(machine, logic, executors, options) {
-	return bindTextLogic(logic, provideBindContext(machine, executors, options));
-}
-/**
-* Host-binds one `DecisionLogic`/`agent.decide` source for
-* {@link provideExecutors}: runAgent's decision wrapper (snapshot-driven
-* candidate events, `canTake`, auto-delivery of the chosen event) with the same
-* request-level tracing runAgent emits, minus run-scoped counting. @internal
-*/
-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.
-*
-* Standard Schema only (no validation library is referenced), so this works for
-* whatever the machine was declared with. Omitted input stays omitted rather
-* than being validated as `{}`: "started with no input" keeps meaning what it
-* has always meant, instead of newly failing schemas with required fields.
-*/
-function resolveMachineInput(machine, input) {
-	if (input === void 0) return input;
-	const schema = require_decision.getRegisteredAgentExecutionOptions(machine).schemas?.input;
-	if (!require_decision.isStandardSchema(schema)) return input;
-	try {
-		return require_decision.validateSchemaSync(schema, input);
-	} catch (error) {
-		throw new require_decision.AgentError("invalid-machine-input", `runAgent: machine input failed validation against the declared input schema: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-	}
-}
-/**
-* Recursively rebinds an invoked child machine's own agent sources with the
-* SAME host-backed wrappers runAgent applies to the top-level machine, so a
-* child's text/stream/decision requests inherit runAgent's executors and
-* participate in maxModelCalls counting, onTrace/onChunk/onResult exactly like
-* parent requests. Returns the child machine to invoke: a `.provide`-rebound
-* copy when any inner source needed wrapping, else the original untouched.
-*
-* Only string-keyed sources are visited — a direct-object invoke src cannot be
-* swapped via `.provide` (assertBindable already rejected an unbound request
-* under one). A source that already carries its own executor
-* (`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, 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)) {
-		if (require_decision.isDecisionLogic(logic)) {
-			if (!require_decision.executorBoundLogics.has(logic)) wrapped[key] = bindDecisionLogic(logic, runCtx);
-			continue;
-		}
-		if (require_decision.isTextLogic(logic)) {
-			if (!require_decision.executorBoundLogics.has(logic)) wrapped[key] = bindTextLogic(logic, runCtx);
-			continue;
-		}
-		if (isStateMachineLogic(logic)) {
-			const rebound = rebindChildMachine(logic, runCtx, childVisited, ctxFor);
-			if (rebound !== logic) wrapped[key] = rebound;
-			continue;
-		}
-	}
-	return Object.keys(wrapped).length > 0 ? childMachine.provide({ actors: wrapped }) : childMachine;
-}
-/**
-* Runs an agent machine to completion or idle: a `createActor` host that
-* binds `options`' host executors onto the machine's `agent.*`/`TextLogic`/
-* `DecisionLogic` actor sources, starts (or resumes) the actor, and drives
-* it until it settles — {@link RunAgentResult} `done | idle | error`. Unlike
-* the step helpers ({@link initialAgentStep} etc — a pure
-* transition-at-a-time path for durable hosts), `runAgent` owns a live actor
-* internally; there is no continuation callback, so **idle always settles**
-* and the caller resumes explicitly by passing the settled `{ snapshot,
-* event }` back in. The actor is stopped on every settle path (`done`,
-* `idle`, and `error` alike) — resume is always by snapshot, never by
-* holding a reference to a live actor.
-*
-* Binding happens **before** the actor starts: every invoke the machine
-* could reach is walked and checked against the effective actor sources
-* (`options.actors` merged onto the machine), so a missing
-* `streamText`/`decide` executor or any other unbound actor source throws
-* immediately — a bind-time error, not a mid-run failure. The one exception
-* is `agent.userInput`: unhandled, it binds as a pending placeholder that
-* settles the run idle (with `pendingUserInputs`) instead of erroring.
-*
-* @example
-* ```ts
-* const executors = createAiSdkExecutors({ models });
-* let r = await runAgent(machine, { input, executors });
-* while (r.status === 'idle') {
-*   const event = await promptUser(getAcceptedEvents(r.snapshot));
-*   r = await runAgent(machine, { snapshot: r.snapshot, event, executors });
-* }
-* if (r.status !== 'done') throw new Error(`Run did not complete: ${r.status}`);
-* console.log(r.output);
-* ```
-*
-* The `executors`' `generateText`/`streamText` accept the raw Vercel AI SDK
-* functions directly (`executors: { generateText, streamText }` with them
-* imported from `ai`) — their `{ text }`/`{ textStream }` results are unwrapped
-* natively. `decide` cannot be a raw AI SDK function: the tool-per-event mapping
-* lives in an adapter — use `createAiSdkExecutors` from '@statelyai/agent/ai-sdk'.
-*/
-async function runAgent(machine, options) {
-	const store = options.store;
-	if (store === void 0) return createAgentSession(machine, options).settled();
-	const threadId = options.threadId;
-	if (threadId === void 0 || threadId === "") throw new require_decision.AgentError("missing-thread-id", "runAgent: `threadId` is required when `store` is given — it names the log thread to read and append to.");
-	if (options.events !== void 0) {
-		const storedThread = await store.read(threadId);
-		if (storedThread.length !== options.events.length) throw new AgentEventLogConflictError(threadId, options.events.length, storedThread.length);
-		assertThreadMatchesEvents(threadId, storedThread, options.events);
-		return createAgentSession(machine, options).settled();
-	}
-	const stored = await store.read(threadId);
-	return createAgentSession(machine, stored.length > 0 ? {
-		...options,
-		events: stored
-	} : options).settled();
-}
-/**
-* Entry-by-entry check that the caller's `events` IS the store's thread. Equal
-* lengths prove nothing: a fork, a rolled-back replay, or a concurrent writer
-* that appended and truncated all produce a divergent log of the same size,
-* and appending this run's entries onto it would splice two lineages together.
-*/
-function assertThreadMatchesEvents(threadId, stored, events) {
-	for (let index = 0; index < stored.length; index++) {
-		const storedEntry = stored[index];
-		const givenEntry = events[index];
-		const storedHash = storedEntry.verification?.stateHash;
-		const givenHash = givenEntry.verification?.stateHash;
-		if (!(storedEntry.id === givenEntry.id && storedEntry.index === givenEntry.index && canonicalEventJson(storedEntry.event) === canonicalEventJson(givenEntry.event) && (storedHash === void 0 || givenHash === void 0 || storedHash === givenHash))) throw new require_decision.AgentError("event-log-conflict", `runAgent: the given \`events\` diverge from thread "${threadId}" at index ${index} (stored entry '${storedEntry.id}', given '${givenEntry.id}') — the log passed in is not this thread's log.`);
-	}
-}
-function createAgentSession(machine, options) {
-	const maxModelCalls = options.maxModelCalls ?? 100;
-	let modelCallCount = 0;
-	let budgetExceeded = false;
-	let warnedNonSerializable = false;
-	const runId = `run_${nextRunAgentTraceId++}`;
-	let traceSeq = 0;
-	const resolvedInput = resolveMachineInput(machine, options.input);
-	const machineId = machine.config.id ?? machine.id ?? "(machine)";
-	const machineVersion = require_decision.resolveMachineVersion(machine);
-	const onTrace = createTraceDispatch({
-		onTrace: (payload) => {
-			options.onTrace?.({
-				schemaVersion: 1,
-				runId,
-				seq: ++traceSeq,
-				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-				machineId,
-				machineVersion,
-				...payload
-			});
-		},
-		onChunk: options.onChunk,
-		onResult: options.onResult,
-		onTransition: options.onTransition
-	});
-	const consumeModelCall = () => {
-		if (budgetExceeded) throw new AgentMaxModelCallsExceededError(maxModelCalls);
-		if (modelCallCount + 1 > maxModelCalls) {
-			budgetExceeded = true;
-			throw new AgentMaxModelCallsExceededError(maxModelCalls);
-		}
-		modelCallCount += 1;
-	};
-	const cycleGate = { isResolved: () => false };
-	const logEntries = [];
-	const store = options.store;
-	const threadId = options.threadId;
-	if (store !== void 0 && (threadId === void 0 || threadId === "")) throw new require_decision.AgentError("missing-thread-id", "runAgent: `threadId` is required when `store` is given — it names the log thread to read and append to.");
-	let journalChain = Promise.resolve();
-	let journalPending = 0;
-	let journalError;
-	const journalEntry = (entry) => {
-		if (store === void 0) return;
-		journalPending++;
-		journalChain = journalChain.then(async () => {
-			if (journalError !== void 0) return;
-			await store.append({
-				threadId,
-				expectedIndex: entry.index,
-				entries: [entry]
-			});
-		}).catch((error) => {
-			journalError ??= error;
-			failRunOnJournalError(error);
-		}).finally(() => {
-			journalPending--;
-		});
-	};
-	/**
-	* Every journal write ISSUED SO FAR, including the stragglers appended after
-	* the run settled. Re-reads the chain tail until it stops moving, so a write
-	* queued while an earlier one was in flight is covered too. Never rejects: a
-	* failed write already settled the run with `cause: 'journal'`.
-	*/
-	const drainJournal = async () => {
-		if (store === void 0) return;
-		let tail = journalChain;
-		for (;;) {
-			await tail;
-			if (journalPending === 0 && journalChain === tail) return;
-			tail = journalChain;
-		}
-	};
-	/** The barrier: settle the pending chain, then surface any failure. */
-	const awaitJournal = async () => {
-		if (store === void 0) return;
-		while (journalPending > 0) await journalChain;
-		if (journalError !== void 0) throw journalError;
-	};
-	const failRunOnJournalError = (error) => {
-		if (settled) return;
-		settle({
-			status: "error",
-			cause: "journal",
-			error,
-			snapshot: actor.getSnapshot()
-		});
-	};
-	let resumedLogLength = 0;
-	let logExecutionId;
-	const verificationEnabled = options.verification !== false;
-	let lastRootSnapshot;
-	let logMachine = machine;
-	let loggingEnabled = true;
-	const appendLogEntry = (event, snapshot) => {
-		if (!loggingEnabled) return;
-		const entry = createReplayEntry(logMachine, logEntries, event, {
-			machineVersion,
-			verification: verificationEnabled,
-			...verificationEnabled && snapshot !== void 0 ? { snapshot } : {}
-		});
-		logEntries.push(entry);
-		journalEntry(entry);
-		options.onEvent?.(entry);
-		return entry;
-	};
-	const usageEntrySnapshot = () => {
-		const current = lastRootSnapshot;
-		if (current && (current.status !== "active" || !declaresUsageTransition(current))) return current;
-	};
-	const recordUsage = (usage, source = {}) => {
-		const event = {
-			type: require_setup_agent.AGENT_USAGE_EVENT_TYPE,
-			...source,
-			usage
-		};
-		const journal = { event };
-		pendingUsageJournal = journal;
-		try {
-			deliverUsageEvent(event, () => actorHolder.actorRef, (dropped) => {
-				if (!cycleGate.isResolved()) return false;
-				onTrace({
-					type: "usage.dropped",
-					event: dropped,
-					reason: "settled"
-				});
-				return true;
-			});
-		} finally {
-			pendingUsageJournal = void 0;
-		}
-		if (journal.entry === void 0) appendLogEntry(event, usageEntrySnapshot());
-	};
-	let pendingUsageJournal;
-	const runUsage = () => ({
-		...getUsageFromEvents(logEntries.slice(resumedLogLength)),
-		modelCalls: modelCallCount
-	});
-	const warnNonSerializableContext = (snapshot) => {
-		if (warnedNonSerializable || process.env.NODE_ENV === "production") return;
-		let offending = [];
-		try {
-			offending = require_decision.findNonSerializableContextPaths(snapshot.context);
-		} catch {
-			return;
-		}
-		if (offending.length === 0) return;
-		warnedNonSerializable = true;
-		console.warn(`runAgent: context holds value(s) that will not survive snapshot persist/resume (JSON round-trip): ${offending.join(", ")}. Persist only JSON-serializable context, or convert these before the run settles.`);
-	};
-	const provided = machine.provide({ actors: options.actors });
-	logMachine = provided;
-	const effectiveSources = provided.sources.actors;
-	const executors = {
-		...require_decision.getRegisteredAgentExecutionOptions(machine).models?.[require_decision.DEFAULT_AGENT_EXECUTORS]?.(),
-		...options.executors
-	};
-	assertBindable(provided, effectiveSources, executors);
-	const actorHolder = { actorRef: void 0 };
-	const runCtx = {
-		generateText: executors.generateText,
-		streamText: executors.streamText,
-		decide: executors.decide,
-		emitTrace: onTrace,
-		consumeModelCall,
-		recordUsage,
-		actorHolder,
-		awaitJournal,
-		runId,
-		schemas: require_decision.getRegisteredAgentExecutionOptions(machine).schemas
-	};
-	let userInputIsPlaceholder = false;
-	const wrappedSources = {};
-	for (const [key, logic] of Object.entries(effectiveSources)) {
-		if (key === "agent.userInput") {
-			if (options.userInput) {
-				const userInput = options.userInput;
-				wrappedSources[key] = (0, xstate.createAsyncLogic)({ run: async ({ input }) => await userInput(input) });
-			} else if (require_decision.isUnboundPlaceholder(logic)) {
-				userInputIsPlaceholder = true;
-				wrappedSources[key] = (0, xstate.createAsyncLogic)({ run: () => new Promise(() => {}) });
-			}
-			continue;
-		}
-		if (require_decision.isDecisionLogic(logic)) {
-			wrappedSources[key] = bindDecisionLogic(logic, runCtx);
-			continue;
-		}
-		if (require_decision.isTextLogic(logic)) {
-			if (!require_decision.executorBoundLogics.has(logic)) wrappedSources[key] = bindTextLogic(logic, runCtx);
-			continue;
-		}
-		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 isIdle = require_decision.getMachineIdlePredicate(machine) ?? isAgentIdle;
-	const isIntentionalIdle = (snapshot) => isIdle(snapshot) || collectPendingUserInputs(snapshot).length > 0;
-	const resumeEvents = options.events;
-	let effectiveSnapshot = options.snapshot;
-	/** Deferred until after the illegal-resume check, so a rejected resume emits no entries. */
-	let seedInitEntry;
-	const restoredPersistedSnapshot = () => {
-		try {
-			const restored = logMachine.restoreSnapshot(options.snapshot);
-			return logMachine.getPersistedSnapshot(restored);
-		} catch {
-			return;
-		}
-	};
-	/**
-	* Appends the log's reserved first entry, trying each candidate `init` in
-	* turn and, for each, an unverified entry if the hash cannot be computed.
-	* A machine or snapshot that defeats every attempt leaves the run WITHOUT a
-	* log rather than failing it: `runAgent` predates the log, and an exotic
-	* machine that cannot be folded must still run.
-	*/
-	const appendInitEntry = (candidates, metadata) => {
-		for (const init of candidates) for (const verification of verificationEnabled ? [true, false] : [false]) try {
-			const entry = initEntry(logMachine, init, {
-				machineVersion,
-				verification,
-				metadata
-			});
-			logEntries.push(entry);
-			journalEntry(entry);
-			options.onEvent?.(entry);
-			return;
-		} catch {}
-		loggingEnabled = false;
-	};
-	/** Init forms for a snapshot resume, most faithful first. */
-	const snapshotInitCandidates = () => {
-		const restored = restoredPersistedSnapshot();
-		return [...restored !== void 0 ? [{ snapshot: restored }] : [], { snapshot: options.snapshot }];
-	};
-	if (resumeEvents !== void 0 && resumeEvents.length > 0) {
-		validateReplayEntries(resumeEvents);
-		const tail = resumeEvents[resumeEvents.length - 1];
-		const inheritedExecutionId = getLogExecutionId(resumeEvents);
-		if (resumeEvents[0].machineId !== machineId) throw new AgentMachineVersionMismatchError(tail.id, tail.index, {
-			machineId,
-			machineVersion
-		}, {
-			machineId: resumeEvents[0].machineId,
-			machineVersion: tail.machineVersion
-		});
-		if (tail.machineVersion === machineVersion) {
-			logEntries.push(...resumeEvents);
-			resumedLogLength = logEntries.length;
-			logExecutionId = inheritedExecutionId;
-			const cachedMeta = readAgentMeta(options.snapshot);
-			const tailStateHash = tail.verification?.stateHash;
-			if (!(options.snapshot !== void 0 && inheritedExecutionId !== void 0 && cachedMeta?.logId === inheritedExecutionId && cachedMeta.logIndex === resumeEvents.length && tailStateHash !== void 0 && hashResumeSnapshot(options.snapshot) === tailStateHash)) {
-				const cachedIndex = cachedMeta?.logIndex;
-				if (options.snapshot !== void 0 && typeof cachedIndex === "number" && cachedIndex >= 1 && cachedIndex <= resumeEvents.length && resumeEvents[cachedIndex - 1].verification?.stateHash !== void 0) {
-					const expected = getSnapshotStateHash(replay(logMachine, resumeEvents.slice(0, cachedIndex), {
-						machineVersion,
-						verify: false
-					}).persistedSnapshot);
-					const actual = hashResumeSnapshot(options.snapshot);
-					if (expected !== actual) throw new AgentSnapshotDivergedError(expected, actual, cachedIndex);
-				}
-				effectiveSnapshot = replay(logMachine, resumeEvents, {
-					machineVersion,
-					verify: true
-				}).persistedSnapshot;
-			}
-		} else {
-			if (options.snapshot === void 0) throw new AgentMachineVersionMismatchError(tail.id, tail.index, {
-				machineId,
-				machineVersion
-			}, {
-				machineId: tail.machineId,
-				machineVersion: tail.machineVersion
-			});
-			const bridgeMeta = readAgentMeta(options.snapshot);
-			if (inheritedExecutionId === void 0 || bridgeMeta?.logId !== inheritedExecutionId) throw new AgentMachineVersionMismatchError(tail.id, tail.index, {
-				machineId,
-				machineVersion
-			}, {
-				machineId: tail.machineId,
-				machineVersion: tail.machineVersion
-			});
-			const bridgeTailHash = tail.verification?.stateHash;
-			const bridgeSnapshotHash = hashResumeSnapshot(options.snapshot);
-			if (bridgeMeta.logIndex !== resumeEvents.length) throw new AgentSnapshotDivergedError(bridgeTailHash ?? "(unrecorded)", bridgeSnapshotHash, resumeEvents.length);
-			if (bridgeTailHash !== void 0 && bridgeSnapshotHash !== bridgeTailHash) throw new AgentSnapshotDivergedError(bridgeTailHash, bridgeSnapshotHash, resumeEvents.length);
-			logExecutionId = inheritedExecutionId;
-			const migratedFrom = {
-				machineVersion: tail.machineVersion,
-				logIndex: resumeEvents.length
-			};
-			seedInitEntry = () => appendInitEntry(snapshotInitCandidates(), {
-				...logExecutionId !== void 0 ? { executionId: logExecutionId } : {},
-				migratedFrom
-			});
-		}
-	} else if (options.snapshot !== void 0) {
-		logExecutionId = crypto.randomUUID();
-		seedInitEntry = () => appendInitEntry(snapshotInitCandidates(), { executionId: logExecutionId });
-	} else {
-		logExecutionId = crypto.randomUUID();
-		seedInitEntry = () => appendInitEntry([resolvedInput !== void 0 ? { input: resolvedInput } : {}], { executionId: logExecutionId });
-	}
-	const resumedHistory = [...logEntries];
-	const siteCallCounts = /* @__PURE__ */ new Map();
-	const mintedCallKeys = /* @__PURE__ */ new WeakMap();
-	runCtx.callKey = (siteId, self) => {
-		if (logExecutionId === void 0) return;
-		const memoized = self === void 0 ? void 0 : mintedCallKeys.get(self);
-		if (memoized !== void 0) return memoized;
-		const startedHere = siteCallCounts.get(siteId) ?? 0;
-		siteCallCounts.set(siteId, startedHere + 1);
-		const key = `${logExecutionId}:${siteId}#${agentCallOccurrence(resumedHistory, siteId) + startedHere}`;
-		if (self !== void 0) mintedCallKeys.set(self, key);
-		return key;
-	};
-	const resumeEventToSend = options.event;
-	let ignoredEvent;
-	seedInitEntry?.();
-	let settled = false;
-	let journalAtSettle;
-	cycleGate.isResolved = () => settled;
-	let lastResult;
-	const waiters = [];
-	let idleTimer;
-	let actor;
-	let actorStarted = false;
-	let deliveringResumeEvent = resumeEventToSend !== void 0;
-	const settle = (outcome) => {
-		if (settled) return;
-		settled = true;
-		let persistedSnapshot;
-		let persistenceError;
-		if (actorStarted && outcome.status !== "done") try {
-			persistedSnapshot = actor.getPersistedSnapshot();
-		} catch (error) {
-			persistenceError = error;
-		}
-		const logIndexAtSettle = logEntries.length;
-		journalAtSettle = journalChain;
-		const persist = () => {
-			if (persistenceError !== void 0) throw persistenceError;
-			persistedSnapshot ??= actor.getPersistedSnapshot();
-			persistedSnapshot.agentMeta = {
-				machineId,
-				version: machineVersion,
-				...logExecutionId !== void 0 ? { logId: logExecutionId } : {},
-				logIndex: logIndexAtSettle
-			};
-			return persistedSnapshot;
-		};
-		const result = {
-			...outcome,
-			events: [...logEntries],
-			persist,
-			drain: drainJournal,
-			usage: runUsage(),
-			...ignoredEvent !== void 0 ? { ignored: ignoredEvent } : {}
-		};
-		if (idleTimer !== void 0) clearTimeout(idleTimer);
-		onTrace({
-			type: "run.end",
-			...outcome
-		});
-		if (options.signal) options.signal.removeEventListener("abort", onAbort);
-		actor.stop();
-		lastResult = result;
-		for (const resolve of waiters.splice(0)) resolve(result);
-	};
-	const onAbort = () => {
-		settle({
-			status: "error",
-			cause: "aborted",
-			error: options.signal?.reason ?? /* @__PURE__ */ new Error("Aborted"),
-			snapshot: actor.getSnapshot()
-		});
-	};
-	const settleIdle = (current) => {
-		warnNonSerializableContext(current);
-		const pendingUserInputs = userInputIsPlaceholder ? collectPendingUserInputs(current) : [];
-		settle({
-			status: "idle",
-			snapshot: current,
-			...pendingUserInputs.length > 0 ? { pendingUserInputs } : {}
-		});
-	};
-	const runErrorCause = (error) => budgetExceeded ? "max-model-calls" : wrapsDecisionExhausted(error) ? "decision-exhausted" : "machine";
-	const scheduleIdleCheck = () => {
-		if (idleTimer !== void 0) clearTimeout(idleTimer);
-		idleTimer = setTimeout(() => {
-			idleTimer = void 0;
-			if (settled) return;
-			const current = actor.getSnapshot();
-			if (isIntentionalIdle(current) && isIdleSnapshot(current, { ignoreUserInputChildren: userInputIsPlaceholder })) settleIdle(current);
-		}, 0);
-	};
-	actor = (0, xstate.createActor)(boundMachine, {
-		input: resolvedInput,
-		snapshot: effectiveSnapshot,
-		inspect: (event) => {
-			if (typeof options.inspect === "function") options.inspect(event);
-			else options.inspect?.next?.(event);
-			if (event.type !== "@xstate.transition" || event.actorRef !== actor.ref) return;
-			if (settled) return;
-			const snapshot = event.snapshot;
-			lastRootSnapshot = snapshot;
-			if (resumeEventToSend !== void 0 && event.event === resumeEventToSend && event.microsteps.length === 0 && event.actions.length === 0 && event.sent.length === 0) ignoredEvent = resumeEventToSend;
-			if (pendingUsageJournal !== void 0 && event.event === pendingUsageJournal.event) pendingUsageJournal.entry = appendLogEntry(event.event, snapshot);
-			else if (event.event.type !== "@xstate.init" && (event.sourceRef !== event.actorRef || event.event.type === "xstate.timer")) appendLogEntry(event.event, snapshot);
-			onTrace({
-				type: "machine.transition",
-				snapshot,
-				event: event.event
-			});
-			if (snapshot.status === "done") {
-				settle({
-					status: "done",
-					output: snapshot.output,
-					snapshot
-				});
-				return;
-			}
-			if (snapshot.status === "error") {
-				settle({
-					status: "error",
-					cause: runErrorCause(snapshot.error),
-					error: snapshot.error,
-					snapshot
-				});
-				return;
-			}
-			if (snapshot.status === "stopped") {
-				settle({
-					status: "error",
-					cause: "stopped",
-					error: /* @__PURE__ */ new Error("Actor stopped externally."),
-					snapshot
-				});
-				return;
-			}
-			if (!deliveringResumeEvent && isIntentionalIdle(snapshot) && isIdleSnapshot(snapshot, { ignoreUserInputChildren: userInputIsPlaceholder })) {
-				queueMicrotask(() => {
-					if (settled) return;
-					const current = actor.getSnapshot();
-					if (isIntentionalIdle(current) && isIdleSnapshot(current, { ignoreUserInputChildren: userInputIsPlaceholder })) settleIdle(current);
-					else scheduleIdleCheck();
-				});
-				return;
-			}
-			scheduleIdleCheck();
-		}
-	});
-	actorHolder.actorRef = actor;
-	actor.subscribe({ error: () => {} });
-	actor.on("*", (event) => {
-		onTrace({
-			type: "emit",
-			event
-		});
-	});
-	for (const [type, handler] of Object.entries(options.on ?? {})) if (typeof handler === "function") actor.on(type, handler);
-	const sessionApi = { settled: async () => {
-		const result = settled && lastResult !== void 0 ? lastResult : await new Promise((resolve) => {
-			waiters.push(resolve);
-		});
-		await journalAtSettle;
-		return result;
-	} };
-	if (options.signal) {
-		if (options.signal.aborted) {
-			settle({
-				status: "error",
-				cause: "aborted",
-				error: options.signal.reason ?? /* @__PURE__ */ new Error("Aborted"),
-				snapshot: actor.getSnapshot()
-			});
-			return sessionApi;
-		}
-		options.signal.addEventListener("abort", onAbort);
-	}
-	onTrace({
-		type: "run.start",
-		...resolvedInput !== void 0 ? { input: resolvedInput } : {},
-		...effectiveSnapshot !== void 0 ? { snapshot: effectiveSnapshot } : {},
-		...resumeEventToSend !== void 0 ? { event: resumeEventToSend } : {}
-	});
-	actorStarted = true;
-	actor.start();
-	if (!settled) {
-		const startedSnapshot = actor.getSnapshot();
-		lastRootSnapshot ??= startedSnapshot;
-		if (startedSnapshot.status === "done") settle({
-			status: "done",
-			output: startedSnapshot.output,
-			snapshot: startedSnapshot
-		});
-		else if (startedSnapshot.status === "error") settle({
-			status: "error",
-			cause: runErrorCause(startedSnapshot.error),
-			error: startedSnapshot.error,
-			snapshot: startedSnapshot
-		});
-		else if (startedSnapshot.status === "stopped") settle({
-			status: "error",
-			cause: "stopped",
-			error: /* @__PURE__ */ new Error("Actor stopped externally."),
-			snapshot: startedSnapshot
-		});
-	}
-	if (resumeEventToSend && !settled) {
-		deliveringResumeEvent = false;
-		actor.send(resumeEventToSend);
-	}
-	return sessionApi;
-}
-/**
-* Wraps a `(snapshot, actorRef) => void` handler into a function usable as
-* {@link RunAgentOptions.inspect}: it filters the raw inspection stream to
-* `@xstate.transition` events and hands the handler the typed
-* {@link AnyMachineSnapshot} and the {@link InspectedActorRef} that
-* transitioned. Attribute a child actor via `actorRef.id`/`actorRef.src`. Saves
-* the manual `event.type === '@xstate.transition'` filtering and the snapshot/
-* actorRef casts.
-*/
-function inspectTransitions(handler) {
-	return (inspectionEvent) => {
-		if (inspectionEvent.type !== "@xstate.transition") return;
-		handler(inspectionEvent.snapshot, inspectionEvent.actorRef);
-	};
-}
-/**
-* An xstate `inspect` handler that emits `machine.transition` trace events onto
-* `onTrace`, sharing the SAME versioned envelope and per-root-actor `seq`
-* registry as {@link provideExecutors}' `onTrace`. Pair the two on one actor to
-* get a single ordered trace stream (request + transition events) for the
-* uncontrolled path:
-*
-* ```ts
-* const bound = provideExecutors(machine, executors, { onTrace });
-* const actor = createActor(bound, { inspect: traceTransitions(onTrace) });
-* ```
-*
-* Only ROOT-actor transitions are traced (matching `runAgent`'s
-* `machine.transition`); child-actor transitions are ignored. Attribute the
-* event via its envelope `runId`.
-*
-* By design this path has NO `run.start`/`run.end` events: `createActor` has no
-* run boundary the way `runAgent` does, so the stream starts at the actor's
-* first transition. It also does NOT emit `emit` trace events: in this xstate
-* build emitted events are delivered through `actor.on(...)`, not the inspection
-* protocol, so they are not observable from an `inspect` handler — subscribe
-* with `actor.on('*', ...)` if you need them.
-*/
-function traceTransitions(onTrace) {
-	return (inspectionEvent) => {
-		if (inspectionEvent.type !== "@xstate.transition") return;
-		const actorRef = inspectionEvent.actorRef;
-		if (actorRef?._parent) return;
-		onTrace(stampRootTrace(actorRef, {
-			type: "machine.transition",
-			snapshot: inspectionEvent.snapshot,
-			event: inspectionEvent.event
-		}));
-	};
-}
-function isIdleSnapshot(snapshot, { ignoreUserInputChildren }) {
-	if (snapshot.status !== "active") return false;
-	if (Object.values(snapshot.children ?? {}).some((child) => {
-		const ref = child;
-		if (ignoreUserInputChildren && ref?.src === "agent.userInput") return false;
-		const childSnapshot = ref?.getSnapshot?.();
-		if (childSnapshot?.status !== "active") return false;
-		if ((0, xstate.isMachineSnapshot)(childSnapshot)) return !isIdleSnapshot(childSnapshot, { ignoreUserInputChildren });
-		return true;
-	})) return false;
-	return !(0, xstate.getNextTransitions)(snapshot).some((transitionDef) => transitionDef.eventType === "" || transitionDef.eventType.startsWith("xstate.after"));
-}
-/**
-* Default machine-owned idle signal used by {@link runAgent}: an active
-* snapshot that accepts an external event anywhere in its active hierarchy,
-* or declares interaction metadata on an active state.
-*
-* Compose this in `setupAgent({ isIdle })` when the application has additional
-* wait states: `isIdle: (snapshot) => isAgentIdle(snapshot) || snapshot.hasTag('waiting')`.
-* Pending work and active invoked children are checked separately by the
-* runner, so this function only answers whether the state is an intentional
-* external wait.
-*/
-function isAgentIdle(snapshot) {
-	if (snapshot.status !== "active") return false;
-	return snapshot.nodes.some((node) => {
-		const meta = node.meta;
-		return typeof meta === "object" && meta !== null && "interaction" in meta;
-	}) || require_decision.getAcceptedEvents(snapshot).length > 0;
-}
-function collectPendingUserInputs(snapshot) {
-	const pending = [];
-	for (const [id, child] of Object.entries(snapshot.children ?? {})) {
-		const ref = child;
-		if (ref?.src !== "agent.userInput") continue;
-		const childSnapshot = ref.getSnapshot?.();
-		if (childSnapshot?.status !== "active") continue;
-		pending.push({
-			id,
-			input: childSnapshot.input
-		});
-	}
-	return pending;
-}
-//#endregion
-//#region src/agent-run.ts
-/**
-* Wraps {@link runAgent} in a canonical run-stream handle: the run's trace
-* events as a pull-based {@link AgentRun.events} async iterator, alongside the
-* unchanged {@link AgentRun.result} promise.
-*
-* Semantics:
-*
-* 1. **Starts immediately.** The underlying `runAgent` is invoked on this call,
-*    not on the first `events` iteration — work is already in flight when
-*    `createAgentRun` returns.
-* 2. **Buffer, don't stall.** Events are queued in an unbounded in-memory
-*    buffer as the run emits them; a slow or absent consumer never applies
-*    backpressure to the run. Once `run.end` is delivered, the iterator
-*    completes.
-* 3. **Composes `onTrace`.** If `options.onTrace` is passed, it still fires for
-*    every event — the wrapper adds queue delivery, it does not replace the
-*    caller's sink.
-* 4. **`result` mirrors `runAgent`.** Same resolution and rejection behavior
-*    (see {@link AgentRun.result}). A no-op rejection handler is attached
-*    internally so a caller who reads only `events` never trips an unhandled
-*    rejection on a bind-time throw; the returned promise still rejects for a
-*    caller who awaits it.
-* 5. **Resume is identical.** Options pass straight through, so starting from a
-*    persisted `snapshot` (+ resume `event`) streams that run's events from its
-*    own `run.start`, exactly as `runAgent` would run it.
-* 6. **Early termination does not cancel the run.** Breaking out of a
-*    `for await` (or calling `events.return()`) stops delivery, but the run
-*    keeps going and `result` still settles. Cancelling the run itself is
-*    future work — pass `options.signal` to abort it.
-* 7. **`events` is single-consumer.** See {@link AgentRun.events}.
-*/
-function createAgentRun(machine, options) {
-	const buffer = [];
-	const resolvers = [];
-	let closed = false;
-	let stopped = false;
-	const push = (event) => {
-		if (closed || stopped) return;
-		const resolve = resolvers.shift();
-		if (resolve) resolve({
-			value: event,
-			done: false
-		});
-		else buffer.push(event);
-	};
-	const drain = () => {
-		while (resolvers.length > 0) resolvers.shift()({
-			value: void 0,
-			done: true
-		});
-	};
-	const close = () => {
-		if (closed) return;
-		closed = true;
-		drain();
-	};
-	const userOnTrace = options.onTrace;
-	const result = runAgent(machine, {
-		...options,
-		onTrace: (event) => {
-			push(event);
-			userOnTrace?.(event);
-			if (event.type === "run.end") close();
-		}
-	});
-	result.then(close, close);
-	return {
-		events: {
-			next() {
-				if (buffer.length > 0) return Promise.resolve({
-					value: buffer.shift(),
-					done: false
-				});
-				if (closed || stopped) return Promise.resolve({
-					value: void 0,
-					done: true
-				});
-				return new Promise((resolve) => {
-					resolvers.push(resolve);
-				});
-			},
-			return() {
-				stopped = true;
-				buffer.length = 0;
-				drain();
-				return Promise.resolve({
-					value: void 0,
-					done: true
-				});
-			},
-			[Symbol.asyncIterator]() {
-				return this;
-			}
-		},
-		result
-	};
-}
-function requestIdentity(request) {
-	const candidate = request;
-	const id = candidate.id ?? candidate.name ?? "agent.request";
-	return {
-		name: candidate.kind === "text" ? candidate.input?.name ?? id : candidate.name ?? id,
-		id
-	};
-}
-/**
-* Streams one {@link runAgent} call as agent-level events. The machine remains
-* the single artifact; this function only projects its requests, chunks,
-* transitions, emitted events, and terminal result into an async iterable.
-*/
-async function* runAgentStream(machine, options) {
-	const run = createAgentRun(machine, options);
-	for await (const event of run.events) switch (event.type) {
-		case "request.start":
-			yield {
-				kind: "request",
-				phase: "start",
-				...requestIdentity(event.request),
-				request: event.request
-			};
-			break;
-		case "request.end":
-			yield {
-				kind: "request",
-				phase: "end",
-				...requestIdentity(event.request),
-				request: event.request,
-				output: event.output,
-				raw: event.raw
-			};
-			break;
-		case "request.error":
-			yield {
-				kind: "request",
-				phase: "error",
-				...requestIdentity(event.request),
-				request: event.request,
-				error: event.error
-			};
-			break;
-		case "stream.chunk":
-			yield {
-				kind: "chunk",
-				...requestIdentity(event.request),
-				delta: event.chunk
-			};
-			break;
-		case "machine.transition":
-			yield {
-				kind: "transition",
-				value: event.snapshot.value,
-				event: event.event
-			};
-			break;
-		case "emit":
-			yield {
-				kind: "emit",
-				event: event.event
-			};
-			break;
-	}
-	const result = await run.result;
-	if (result.status === "done") yield {
-		kind: "done",
-		result
-	};
-	else if (result.status === "idle") yield {
-		kind: "idle",
-		result
-	};
-	else yield {
-		kind: "error",
-		result
-	};
-}
-//#endregion
-//#region src/run-loop.ts
-function addUsage(total, next) {
-	const merged = { ...total };
-	for (const [key, value] of Object.entries(next)) if (typeof value === "number") merged[key] = (merged[key] ?? 0) + value;
-	return merged;
-}
-/** Drives one machine artifact across as many idle/resume turns as the host
-* supplies. XState snapshots remain the continuation; this helper owns no
-* persistence, retry, tool-loop, or storage policy. */
-async function runAgentLoop(machine, options) {
-	const { onIdle, persist, maxTurns = 100, events: initialEvents, ...runOptions } = options;
-	if (!Number.isInteger(maxTurns) || maxTurns < 0) throw new Error("runAgentLoop: maxTurns must be a non-negative integer.");
-	let usage = { modelCalls: 0 };
-	let snapshot;
-	let event;
-	const stored = options.store !== void 0;
-	let events = initialEvents;
-	for (let turn = 0;; turn++) {
-		const result = await runAgent(machine, {
-			...runOptions,
-			...events ? { events } : {},
-			...snapshot ? {
-				snapshot,
-				event
-			} : {}
-		});
-		events = stored ? void 0 : result.events;
-		usage = addUsage(usage, result.usage);
-		const cumulative = {
-			...result,
-			usage
-		};
-		if (result.status !== "idle" || !onIdle || turn >= maxTurns) return cumulative;
-		snapshot = result.persist();
-		await persist?.(snapshot, result);
-		event = await onIdle(result) ?? void 0;
-		if (!event) return cumulative;
-	}
-}
-//#endregion
-//#region src/provide-executors.ts
-/**
-* Binds a machine's agent actor sources to a set of host `executors` in one
-* call, returning a `machine.provide(...)`-ed copy ready for a plain
-* `createActor(...)` — the uncontrolled-mode counterpart to {@link runAgent}.
-* No run loop, no idle settling: the returned machine drives itself, so
-*
-* ```ts
-* const actor = createActor(provideExecutors(machine, { generateText, decide }), { input });
-* actor.start();
-* ```
-*
-* behaves like a normal XState actor whose agent invokes now reach real models.
-*
-* Binding pass over `machine.sources.actors` (after merging
-* `options.actors`):
-* - `mode: 'generate'` text source → `executors.generateText`
-* - `mode: 'stream'` text source → `executors.streamText`
-* - decision / `agent.decide` source → `executors.decide` (snapshot-driven
-*   candidate events, guard `canTake`, and auto-delivery of the chosen event,
-*   mirroring `runAgent` but without its model-call counting)
-*
-* Pass `options.onTrace` to observe request-level trace events (identical in
-* shape to `runAgent`'s); pair it with {@link traceTransitions} on the actor's
-* `inspect` to also capture `machine.transition` events in the same stream.
-*
-* A source that already carries its own executor (`.withExecutor(...)`) is left
-* as-is. `agent.userInput` is left UNBOUND — an uncontrolled host handles idle
-* itself, so supply a handler via `options.actors` if the machine uses it.
-* Non-agent actors are untouched.
-*
-* Throws at bind time if a source needs an executor kind that `executors` does
-* not provide.
-*
-* 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 = {
-		onChunk: options.onChunk,
-		onTrace: options.onTrace
-	};
-	const withActors = (target, actors) => target.provide({ actors });
-	const provided = options.actors ? withActors(machine, options.actors) : machine;
-	const effectiveSources = provided.sources.actors;
-	const wrappedSources = {};
-	const invokedSrcs = getConfiguredInvokeSrcs(provided);
-	for (const [key, logic] of Object.entries(effectiveSources)) {
-		if (key === "agent.userInput") continue;
-		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;
-		}
-		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);
-			continue;
-		}
-		wrappedSources[key] = binding.bind();
-	}
-	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];
-}
-function buildStateIndex(rootConfig) {
-	const index = /* @__PURE__ */ new Map();
-	const walk = (states, parentPath) => {
-		for (const [name, config] of Object.entries(states ?? {})) {
-			const path = parentPath ? `${parentPath}.${name}` : name;
-			const hasChildren = !!config.states && Object.keys(config.states).length > 0;
-			index.set(path, {
-				path,
-				config,
-				parentPath,
-				isFinal: config.type === "final",
-				isParallel: config.type === "parallel",
-				isCompound: hasChildren && config.type !== "parallel",
-				invokes: normalizeInvokes(config.invoke)
-			});
-			if (hasChildren) walk(config.states, path);
-		}
-	};
-	walk(rootConfig.states, "");
-	return index;
-}
-function ancestorChain(node, index) {
-	const chain = [];
-	let parent = node.parentPath;
-	while (parent) {
-		const parentNode = index.get(parent);
-		if (!parentNode) break;
-		chain.push(parentNode);
-		parent = parentNode.parentPath;
-	}
-	return chain;
-}
-function hasNonEmptyOn(config) {
-	return !!config.on && Object.keys(config.on).length > 0;
-}
-function isDecisionInvoke(src, actors) {
-	if (typeof src === "string") return src === DECIDE_SRC || require_decision.isDecisionLogic(actors[src]);
-	return require_decision.isDecisionLogic(src);
-}
-function isAgentLogicNeedingBinding(src) {
-	return (require_decision.isTextLogic(src) || require_decision.isDecisionLogic(src)) && !require_decision.executorBoundLogics.has(src);
-}
-function checkDecideWithoutEvents(ctx) {
-	const out = [];
-	for (const node of ctx.index.values()) for (const invoke of node.invokes) {
-		if (!isDecisionInvoke(invoke.src, ctx.actors)) continue;
-		const selfHandles = hasNonEmptyOn(node.config);
-		const ancestorHandles = ancestorChain(node, ctx.index).some((ancestor) => hasNonEmptyOn(ancestor.config));
-		const invokeObserves = invoke.onDone !== void 0;
-		if (selfHandles || ancestorHandles || invokeObserves) continue;
-		const srcName = typeof invoke.src === "string" ? invoke.src : "(inline logic)";
-		out.push({
-			code: "decide-without-events",
-			severity: "error",
-			path: node.path,
-			message: `State '${node.path}' invokes decision source '${srcName}', but neither it nor any ancestor handles any event (no 'on:'), so the decision's chosen event can never be delivered. Add an 'on:' handler for the candidate events.`
-		});
-	}
-	return out;
-}
-function checkDirectObjectSrc(ctx) {
-	const out = [];
-	for (const node of ctx.index.values()) for (const invoke of node.invokes) {
-		const src = invoke.src;
-		if (typeof src === "string" || !src || typeof src !== "object") continue;
-		if (!isAgentLogicNeedingBinding(src)) continue;
-		out.push({
-			code: "direct-object-src",
-			severity: "warning",
-			path: node.path,
-			message: `State '${node.path}' invokes a direct-object agent logic. Direct-object invoke srcs cannot be rebound by runAgent, so they inherit no host executors — call '.withExecutor(...)' on the logic, or register it as a string-keyed actor source (machine.provide({ actors: { name: logic } })) and invoke it by name.`
-		});
-	}
-	return out;
-}
-function handlesActorError(config) {
-	if (config["onError"] !== void 0) return true;
-	return Object.keys(config.on ?? {}).some((type) => type === "*" || type.startsWith("xstate.error"));
-}
-function checkInvokeWithoutOnError(ctx) {
-	const out = [];
-	for (const node of ctx.index.values()) for (const invoke of node.invokes) {
-		if (invoke.onError !== void 0 || handlesActorError(node.config)) continue;
-		if (handlesActorError(ctx.config) || ancestorChain(node, ctx.index).some((ancestor) => handlesActorError(ancestor.config))) continue;
-		const srcName = typeof invoke.src === "string" ? invoke.src : "(inline logic)";
-		out.push({
-			code: "invoke-without-on-error",
-			severity: "warning",
-			path: node.path,
-			message: `State '${node.path}' invokes '${srcName}' with no 'onError' transition, and no ancestor handles an actor error. A rejected request or actor puts the machine in an error state with no modeled recovery. Add 'onError' (a 'failed' final state, or a bounded retry).`
-		});
-	}
-	return out;
-}
-function checkUnhandledAgentMessages(ctx) {
-	const handlesMessages = (config) => config.on?.["agent.messages"] !== void 0 || config.on?.["*"] !== void 0;
-	if (handlesMessages(ctx.config) || [...ctx.index.values()].some((node) => handlesMessages(node.config))) return [];
-	let contextJsonSchema;
-	try {
-		contextJsonSchema = require_decision.getJsonSchemaSync(ctx.schemas?.context);
-	} catch {}
-	if (!contextJsonSchema?.properties?.messages) return [];
-	return [...ctx.index.values()].some((node) => node.invokes.some((invoke) => {
-		if (typeof invoke.src !== "string") return false;
-		return invoke.src === "agent.generateText" || invoke.src === "agent.streamText" || require_decision.isTextLogic(ctx.actors[invoke.src]);
-	})) ? [{
-		code: "unhandled-agent-messages",
-		severity: "warning",
-		path: "(root)",
-		message: `Text requests may return framework messages, but the machine does not handle '${require_decision.AGENT_MESSAGES_EVENT_TYPE}'. Add on: { '${require_decision.AGENT_MESSAGES_EVENT_TYPE}': appendMessages() } when transcript retention is intended, or disable this warning when messages are intentionally ignored.`
-	}] : [];
-}
-const LINT_CHECKS = [
-	checkDecideWithoutEvents,
-	checkDirectObjectSrc,
-	checkInvokeWithoutOnError,
-	checkUnhandledAgentMessages
-];
-/**
-* Runs static structural checks over a built agent machine and returns the
-* findings ({@link AgentLintDiagnostic}[], empty when clean). Works for
-* TS-authored (`setupAgent(...).createMachine(...)`) and
-* `setupAgent.fromConfig(...)`-compiled machines alike, reading `machine.config`
-* plus the schemas/actor sources the library already retains per machine.
-*
-* No model calls, no API keys — a coding agent that emits an agent machine can
-* call this to catch agent-specific mistakes such as undeliverable decisions,
-* un-rebindable request sources, and an unhandled transcript event. General
-* state-machine lint belongs to XState tooling.
-*
-* 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 ?? {};
-	const index = buildStateIndex(config);
-	const registered = require_decision.getRegisteredAgentExecutionOptions(machine);
-	const ctx = {
-		config,
-		index,
-		schemas: registered.schemas,
-		actors: registered.actors ?? machine.sources?.actors ?? {}
-	};
-	const disabled = new Set(options.disable ?? []);
-	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 `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.
-*/
-var AgentLintError = class extends require_decision.AgentError {
-	diagnostics;
-	constructor(machineId, diagnostics) {
-		const lines = diagnostics.map((d) => `  ${d.severity === "error" ? "error" : "warn "}  ${d.code}  ${d.path}\n         ${d.message}`);
-		super("lint-failed", `Agent machine '${machineId}' failed lint (${diagnostics.length} finding(s)):\n${lines.join("\n")}`);
-		this.name = "AgentLintError";
-		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 metadata of getPendingInvokes(step.snapshot)) if (typeof metadata.src === "string") out.push({
-		id: metadata.id,
-		src: metadata.src
-	});
-	return out;
-}
-function takeFromQueue(channel, src) {
-	const queue = channel?.[src];
-	if (queue && queue.length > 0) return {
-		found: true,
-		value: queue.shift()
-	};
-	return { found: false };
-}
-/**
-* Deterministically plays a machine through, resolving each request from a
-* {@link SimulationScript} instead of a model — no API keys, no model calls.
-* Runs on the pure step path ({@link initialAgentStep} etc.), so it exercises
-* 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.
-*
-* @example
-* ```ts
-* const { status, snapshot } = simulateAgent(machine, {
-*   input: { topic: 'state machines' },
-*   script: {
-*     decisions: { 'agent.decide': [{ type: 'ESCALATE' }] },
-*     events: [{ type: 'APPROVE' }], // crosses the human gate
-*   },
-* });
-* ```
-*/
-async function simulateAgent(machine, options) {
-	const maxSteps = options.maxSteps ?? 100;
-	const script = {
-		text: mapValues(options.script.text ?? {}, (arr) => [...arr]),
-		decisions: mapValues(options.script.decisions ?? {}, (arr) => [...arr]),
-		invokes: mapValues(options.script.invokes ?? {}, (arr) => [...arr]),
-		errors: mapValues(options.script.errors ?? {}, (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 = [{ state: step.snapshot.value }];
-	for (let i = 0; i < maxSteps; i++) {
-		if (step.done) return {
-			status: "done",
-			snapshot: step.snapshot,
-			trail
-		};
-		const request = step.requests[0];
-		if (request) {
-			if (request.kind === "decision") {
-				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;
-				const errorSrc = queueKey(script.errors, src, request.id);
-				const failure = takeFromQueue(script.errors, errorSrc);
-				if (failure.found) {
-					step = rejectScriptedRequest(machine, step, request.id, failure.value, {
-						kind: "decision",
-						src: errorSrc,
-						trail
-					});
-					continue;
-				}
-				step = await applyScriptedDecision(machine, step, request, decisionSrc, invokeMeta?.logic, script, trail);
-				continue;
-			}
-			const failure = takeFromQueue(script.errors, request.src);
-			if (failure.found) {
-				step = rejectScriptedRequest(machine, step, request, failure.value, {
-					kind: "text",
-					src: request.src,
-					trail
-				});
-				continue;
-			}
-			const taken = takeFromQueue(script.text, request.src);
-			if (!taken.found) throw scriptDryError("text", request.src, request.id);
-			step = resolveAgentStep(machine, step, request, taken.value);
-			trail.push({
-				state: step.snapshot.value,
-				resolvedRequest: {
-					kind: "text",
-					src: request.src,
-					id: request.id,
-					outcome: "output"
-				}
-			});
-			continue;
-		}
-		const [invoke] = pendingInvokes(step);
-		if (invoke) {
-			const failure = takeFromQueue(script.errors, invoke.src);
-			if (failure.found) {
-				step = rejectScriptedRequest(machine, step, invoke.id, failure.value, {
-					kind: "userInput",
-					src: invoke.src,
-					trail
-				});
-				continue;
-			}
-			const taken = takeFromQueue(script.invokes, invoke.src);
-			if (!taken.found) throw scriptDryError("userInput", invoke.src, invoke.id);
-			step = resolveAgentStep(machine, step, invoke.id, taken.value);
-			trail.push({
-				state: step.snapshot.value,
-				resolvedRequest: {
-					kind: "userInput",
-					src: invoke.src,
-					id: invoke.id,
-					outcome: "output"
-				}
-			});
-			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,
-			trail
-		};
-	}
-	return {
-		status: "exhausted",
-		snapshot: step.snapshot,
-		trail
-	};
-}
-function queueKey(channel, src, id) {
-	return channel && !(src in channel) && id in channel ? id : src;
-}
-function rejectScriptedRequest(machine, step, request, error, entry) {
-	const id = typeof request === "string" ? request : request.id;
-	const next = rejectAgentStep(machine, step, request, error);
-	if (next.snapshot.status === "error") throw unhandledScriptedError(error, entry.kind, entry.src, id);
-	entry.trail.push({
-		state: next.snapshot.value,
-		resolvedRequest: {
-			kind: entry.kind,
-			src: entry.src,
-			id,
-			outcome: "error",
-			error
-		}
-	});
-	return next;
-}
-function unhandledScriptedError(error, kind, src, id) {
-	if (error instanceof Error) return error;
-	return new Error(`simulateAgent: the scripted error for the ${kind} request '${src}' (id '${id}') reached no onError transition, so the machine errored. Add an onError to that invoke, or drop the errors['${src}'] entry.`, { cause: error });
-}
-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 = (require_decision.isDecisionLogic(invokeLogic) ? invokeLogic : resolveRegisteredDecisionLogic(machine, decisionSrc))?.maxRetries;
-	let chosen;
-	try {
-		chosen = await require_decision.resolveDecision(request, { decide }, {
-			maxRetries,
-			canTake: (event) => step.snapshot.can(event)
-		});
-	} catch (error) {
-		if (!(error instanceof require_decision.AgentDecisionExhaustedError)) throw error;
-		const next = rejectAgentStep(machine, step, 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 metadata of getPendingInvokes(step.snapshot)) {
-		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 = require_decision.getRegisteredAgentExecutionOptions(machine).actors?.[src] ?? machine.sources?.actors?.[src];
-	return require_decision.isDecisionLogic(candidate) ? candidate : void 0;
-}
-function mapValues(obj, fn) {
-	return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, fn(value)]));
-}
-function scriptDryError(kind, src, id, request) {
-	const events = request?.kind === "decision" ? ` Candidate events: ${request.events.map((e) => e.type).join(", ") || "(none)"}.` : "";
-	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;
-function invokeFork(id, src, outputs) {
-	return src in outputs ? {
-		id,
-		src,
-		hasOutput: true,
-		output: outputs[src]
-	} : {
-		id,
-		src,
-		hasOutput: false
-	};
-}
-async function explore(machine, options, stopWhen) {
-	const maxDepth = options.maxDepth ?? 8;
-	const maxPaths = options.maxPaths ?? 200;
-	const textScript = options.text ?? {};
-	const invokeOutputs = { ...options.invokes ?? {} };
-	if ("userInput" in options) invokeOutputs[USER_INPUT_SRC] = options.userInput;
-	const errorScript = options.errors ?? {};
-	const reachedStates = /* @__PURE__ */ new Set();
-	const reachedValues = [];
-	const terminals = [];
-	const unexplored = [];
-	let prunedByGuard = 0;
-	let pathsExplored = 0;
-	let hitPathCap = false;
-	let witness;
-	const recordState = (snapshot) => {
-		const key = JSON.stringify(snapshot.value);
-		if (!reachedStates.has(key)) {
-			reachedStates.add(key);
-			reachedValues.push(snapshot.value);
-		}
-	};
-	const initial = initialAgentStep(machine, options.input);
-	recordState(initial.snapshot);
-	if (stopWhen?.(initial.snapshot)) witness = [];
-	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") {
-				if (request.src in errorScript) return {
-					step: current,
-					fork: invokeFork(request.id, request.src, textScript)
-				};
-				if (!(request.src in textScript)) return {
-					step: current,
-					blockedSrc: request.src
-				};
-				current = resolveAgentStep(machine, current, request, textScript[request.src]);
-				recordState(current.snapshot);
-				continue;
-			}
-			if (request && request.kind === "decision") {
-				const src = findInvokeMetadata(current, request.id)?.src;
-				const errorSrc = src !== void 0 && src in errorScript ? src : request.id in errorScript ? request.id : void 0;
-				return errorSrc !== void 0 ? {
-					step: current,
-					fork: {
-						id: request.id,
-						src: errorSrc,
-						hasOutput: false,
-						isDecision: true
-					}
-				} : { step: current };
-			}
-			const [invoke] = pendingInvokes(current);
-			if (invoke) {
-				if (invoke.src in errorScript) return {
-					step: current,
-					fork: invokeFork(invoke.id, invoke.src, invokeOutputs)
-				};
-				if (!(invoke.src in invokeOutputs)) return {
-					step: current,
-					blockedSrc: invoke.src
-				};
-				current = resolveAgentStep(machine, current, invoke.id, invokeOutputs[invoke.src]);
-				recordState(current.snapshot);
-				continue;
-			}
-			return { step: current };
-		}
-		return { step: current };
-	};
-	const visit = async (step, path, startDepth) => {
-		let depth = startDepth;
-		if (witness !== void 0) return;
-		if (pathsExplored >= maxPaths) {
-			hitPathCap = true;
-			return;
-		}
-		const { step: settled, blockedSrc, hit, fork } = advance(step);
-		if (hit) {
-			witness = path;
-			return;
-		}
-		if (fork) {
-			if (depth >= maxDepth) {
-				pathsExplored++;
-				terminals.push({
-					status: "max-depth",
-					path,
-					state: settled.snapshot.value
-				});
-				unexplored.push(`max-depth: stopped at path [${path.map((e) => e.type).join(", ")}]`);
-				return;
-			}
-			const failed = rejectAgentStep(machine, settled, fork.id, errorScript[fork.src]);
-			recordState(failed.snapshot);
-			await visit(failed, [...path, { type: `xstate.error.actor.${fork.id}` }], depth + 1);
-			if (!fork.isDecision) {
-				if (fork.hasOutput) {
-					const resolved = resolveAgentStep(machine, settled, fork.id, fork.output);
-					recordState(resolved.snapshot);
-					await visit(resolved, path, depth + 1);
-				}
-				return;
-			}
-			depth += 1;
-			if (witness !== void 0) return;
-		}
-		if (blockedSrc) {
-			pathsExplored++;
-			terminals.push({
-				status: "needs-output",
-				path,
-				state: settled.snapshot.value,
-				missingSrc: blockedSrc
-			});
-			unexplored.push(`needs-output: no canned output for src '${blockedSrc}' at path [${path.map((e) => e.type).join(", ")}]`);
-			return;
-		}
-		if (settled.done) {
-			pathsExplored++;
-			terminals.push({
-				status: "done",
-				path,
-				state: settled.snapshot.value
-			});
-			return;
-		}
-		if (settled.snapshot.status === "error") {
-			pathsExplored++;
-			terminals.push({
-				status: "error",
-				path,
-				state: settled.snapshot.value,
-				error: settled.snapshot.error
-			});
-			return;
-		}
-		const request = settled.requests[0];
-		const branchEvents = request?.kind === "decision" ? request.events.map((descriptor) => ({ type: descriptor.type })) : require_decision.getAcceptedEvents(settled.snapshot).map((descriptor) => ({ type: descriptor.type }));
-		if (branchEvents.length === 0) {
-			pathsExplored++;
-			terminals.push({
-				status: "idle",
-				path,
-				state: settled.snapshot.value
-			});
-			return;
-		}
-		if (depth >= maxDepth) {
-			pathsExplored++;
-			terminals.push({
-				status: "max-depth",
-				path,
-				state: settled.snapshot.value
-			});
-			unexplored.push(`max-depth: stopped at path [${path.map((e) => e.type).join(", ")}]`);
-			return;
-		}
-		for (const event of branchEvents) {
-			if (witness !== void 0 || pathsExplored >= maxPaths) {
-				if (pathsExplored >= maxPaths) hitPathCap = true;
-				return;
-			}
-			if (!settled.snapshot.can(event)) {
-				prunedByGuard++;
-				continue;
-			}
-			const next = transitionAgentStep(machine, settled, event);
-			recordState(next.snapshot);
-			await visit(next, [...path, event], depth + 1);
-		}
-	};
-	if (witness === void 0) await visit(initial, [], 0);
-	return {
-		report: {
-			reachedStates: reachedValues,
-			terminals,
-			prunedByGuard,
-			unexplored,
-			pathsExplored,
-			hitPathCap
-		},
-		witness
-	};
-}
-/**
-* Enumerates a machine's decision and external-event branches to a bounded
-* 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 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. A src in
-* `errors` forks an extra branch where that invoke is rejected, so states
-* behind an `onError` are explored too.
-*
-* Combinatorics are bounded by `maxDepth` (default 8) and `maxPaths` (default
-* 200, reported via `hitPathCap`).
-*
-* @example
-* ```ts
-* const report = await explorePaths(refundMachine, { input: { request: 'x', amount: 5000 } });
-* // report.terminals → both 'refunded' and 'denied'; report.prunedByGuard → 1
-* ```
-*/
-async function explorePaths(machine, options = {}) {
-	return (await explore(machine, options)).report;
-}
-/** Thrown when a string reachability target is not a state in the machine. */
-var AgentUnknownStateError = class extends require_decision.AgentError {
-	target;
-	constructor(machineId, target) {
-		super("unknown-state", `canReach: machine '${machineId}' has no state matching '${target}'.`);
-		this.name = "AgentUnknownStateError";
-		this.target = target;
-	}
-};
-function resolveStateTarget(machine, target) {
-	const stack = [machine.root];
-	while (stack.length > 0) {
-		const node = stack.pop();
-		if (node.id === target.replace(/^#/, "") || node.path.join(".") === target) return node.id;
-		stack.push(...Object.values(node.states));
-	}
-	throw new AgentUnknownStateError(machine.id, target);
-}
-/**
-* 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 }`.
-*
-* @example
-* ```ts
-* 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, target, options = {}) {
-	const resolvedTarget = typeof target === "string" ? resolveStateTarget(machine, target) : void 0;
-	const { witness } = await explore(machine, options, typeof target === "function" ? target : (snapshot) => snapshot.nodes.some((node) => node.id === resolvedTarget));
-	return witness !== void 0 ? {
-		reachable: true,
-		witness,
-		...resolvedTarget ? { target: resolvedTarget } : {}
-	} : {
-		reachable: false,
-		...resolvedTarget ? { target: resolvedTarget } : {}
-	};
-}
-//#endregion
-//#region src/trajectory.ts
-/**
-* Classifies one item. Event-shaped things (log entries, events) become events;
-* everything else is a state value. A snapshot is unwrapped to its `value`.
-* @internal
-*/
-function normalize(item) {
-	if (require_decision.isRecord(item)) {
-		const nested = item["event"];
-		if (require_decision.isRecord(nested) && typeof nested["type"] === "string") return {
-			kind: "event",
-			event: nested
-		};
-		if (typeof item["type"] === "string") return {
-			kind: "event",
-			event: item
-		};
-		if ("value" in item) return {
-			kind: "state",
-			value: item["value"]
-		};
-	}
-	return {
-		kind: "state",
-		value: item
-	};
-}
-/** Every leaf of a state value as a dot path (`{ review: 'editing' }` → `review.editing`). @internal */
-function statePaths(value) {
-	if (typeof value === "string") return [value];
-	if (!require_decision.isRecord(value)) return [];
-	return Object.entries(value).flatMap(([key, child]) => statePaths(child).map((path) => `${key}.${path}`));
-}
-/**
-* A string expectation matches a state value when it names one of its leaves or
-* an ancestor of one, so `'review'` matches `{ review: 'editing' }`. @internal
-*/
-function stateMatchesPath(path, value) {
-	return statePaths(value).some((leaf) => leaf === path || leaf.startsWith(`${path}.`));
-}
-function deepEqual(a, b) {
-	if (Object.is(a, b)) return true;
-	if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, index) => deepEqual(item, b[index]));
-	if (!require_decision.isRecord(a) || !require_decision.isRecord(b)) return false;
-	const keys = Object.keys(a);
-	return keys.length === Object.keys(b).length && keys.every((key) => deepEqual(a[key], b[key]));
-}
-/**
-* Normalizes ONE expected item into a predicate over actual items, so the
-* expectation is classified once instead of once per candidate:
-*
-* - A string expectation matches an event's `type`, or a state value it names.
-* - An event expectation matches an event with the same `type` whose other
-*   declared keys deep-equal, so payload details are opt-in.
-* - A state-value expectation matches structurally.
-* @internal
-*/
-function matcherFor(expected) {
-	if (typeof expected === "string") return (actual) => {
-		const actualItem = normalize(actual);
-		return actualItem.kind === "event" ? actualItem.event.type === expected : stateMatchesPath(expected, actualItem.value);
-	};
-	const expectedItem = normalize(expected);
-	switch (expectedItem.kind) {
-		case "event": return (actual) => {
-			const actualItem = normalize(actual);
-			return actualItem.kind === "event" && Object.keys(expectedItem.event).every((key) => deepEqual(expectedItem.event[key], actualItem.event[key]));
-		};
-		case "state": return (actual) => {
-			const actualItem = normalize(actual);
-			return actualItem.kind === "state" && deepEqual(expectedItem.value, actualItem.value);
-		};
-	}
-}
-/**
-* Matches a run's trajectory against an expected one.
-*
-* Both trajectories may be state values or events collected from
-* `onTransition`;
-* items are compared by shape, so `['prompting', 'drafting']` scores a state
-* path and `['PROMPT_SUBMITTED', 'SEND']` scores an event log with the same
-* call.
-*
-* Semantics are an ordered subsequence: every expected item must appear in
-* `actual`, in order, with gaps allowed. Pass `{ exact: true }` to require
-* equality instead.
-*
-* @example Trajectory assertions in a test
-* ```ts
-* const statePath: unknown[] = [];
-* const result = await runAgent(machine, {
-*   input,
-*   executors,
-*   onTransition: (snapshot) => statePath.push(snapshot.value),
-* });
-*
-* const path = matchesTrajectory(statePath, ['prompting', 'drafting', 'sent']);
-* expect(path.matched, JSON.stringify(path.firstMiss)).toBe(true);
-* expect(matchesTrajectory(events, ['PROMPT_SUBMITTED', 'SEND']).matched).toBe(true);
-* ```
-*
-* @example Partial credit in an eval scorer
-* ```ts
-* const match = matchesTrajectory(output.statePath, expected.statePath);
-* return { name: 'state_path', score: match.score, metadata: { ...match.firstMiss } };
-* ```
-*/
-function matchesTrajectory(actual, expected, options = {}) {
-	const expectedCount = expected.length;
-	if (expectedCount === 0) throw new require_decision.AgentError("empty-trajectory", "matchesTrajectory: expected trajectory must contain at least one item.");
-	const exact = options.exact === true;
-	let cursor = 0;
-	let matchedCount = 0;
-	let firstMiss;
-	for (let index = 0; index < expectedCount; index++) {
-		const want = expected[index];
-		const matches = matcherFor(want);
-		const searchedFrom = exact ? index : cursor;
-		let found = -1;
-		for (let at = searchedFrom; at < actual.length; at++) {
-			if (matches(actual[at])) {
-				found = at;
-				break;
-			}
-			if (exact) break;
-		}
-		if (found === -1) {
-			firstMiss = {
-				index,
-				expected: want,
-				searchedFrom
-			};
-			break;
-		}
-		matchedCount++;
-		cursor = found + 1;
-	}
-	const matched = !firstMiss && (!exact || actual.length === expectedCount);
-	const denominator = exact ? Math.max(expectedCount, actual.length) : expectedCount;
-	return {
-		matched,
-		matchedCount,
-		expectedCount,
-		score: matched ? 1 : denominator === 0 ? 1 : matchedCount / denominator,
-		...firstMiss ? { firstMiss } : {}
-	};
-}
-//#endregion
-//#region src/scripted-executors.ts
-/**
-* Scripted executors — a deterministic stand-in for a model host.
-*
-* `createScriptedExecutors` builds a full `{ generateText, streamText, decide }`
-* set (plus a `userInput` handler) that plays back canned answers keyed by
-* request name, so `runAgent` (or `provideExecutors`, or a bare
-* `TextLogic.execute`) runs with no API key and no network.
-*
-* One rule: entries for a name are consumed in order, and the last entry
-* repeats forever.
-*
-* @module
-*/
-function toQueues(value) {
-	return new Map(Object.entries(value ?? {}).map(([name, entries]) => [name, {
-		entries: Array.isArray(entries) ? [...entries] : [entries],
-		index: 0
-	}]));
-}
-/**
-* Takes the next entry for `name`, holding on the last entry once the list is
-* spent. `undefined` means the script has no route for this name at all.
-* @internal
-*/
-function takeEntry(queues, name) {
-	const queue = queues.get(name) ?? queues.get("*");
-	if (!queue || queue.entries.length === 0) return;
-	const entry = queue.entries[Math.min(queue.index, queue.entries.length - 1)];
-	queue.index++;
-	return entry;
-}
-/** @internal */
-function noAnswer(name, queues) {
-	const known = [...queues.keys()].join(", ") || "(none)";
-	return /* @__PURE__ */ new Error(`No scripted answer for request '${name}'. Known: ${known}`);
-}
-/** The only own keys an executor-result envelope carries. @internal */
-const TEXT_ENVELOPE_KEYS = new Set([
-	"output",
-	"usage",
-	"raw"
-]);
-/**
-* True when a scripted entry is the executor envelope rather than the output
-* value: it owns an `output` key and owns NOTHING outside the envelope's own
-* vocabulary. Bare `'output' in value` would swallow an output object's
-* siblings (`{ output: 'draft', confidence: 0.9 }` would lose `confidence`)
-* and would also match an inherited `output`. @internal
-*/
-function isTextEnvelope(value) {
-	return Object.hasOwn(value, "output") && Object.keys(value).every((key) => TEXT_ENVELOPE_KEYS.has(key));
-}
-/**
-* Resolves ONE scripted text entry to an executor result: a function entry is
-* called with the request, and the value is taken as the raw envelope only when
-* it is one (see {@link isTextEnvelope}). Shared with `runSeam`, whose routed
-* queues follow the same entry conventions. @internal
-*/
-async function resolveScriptedTextEntry(entry, request, info) {
-	const value = typeof entry === "function" ? await entry(request, info) : entry;
-	return require_decision.isRecord(value) && isTextEnvelope(value) ? value : { output: value };
-}
-/**
-* Names a pending text request in an error message. Shared with `runSeam`.
-* @internal
-*/
-function describeText(request) {
-	return request.name ? `'${request.name}' (model '${request.model}')` : `(model '${request.model}')`;
-}
-/**
-* Stream semantics with no model: the whole text lands as one chunk. Shared
-* with `runSeam`, whose scripted answers stream the same way. @internal
-*/
-function emitScriptedChunk(result, info) {
-	const output = require_decision.isRecord(result) ? result["output"] : void 0;
-	if (typeof output === "string") info?.onChunk?.(output);
-}
-/**
-* Executors that replay a script instead of calling a model. Every slot is
-* provided, so any machine binds.
-*
-* Answers are keyed by the request's resolved name — its authored `name`, else
-* the invoke `id` — and `"*"` serves anything unmatched.
-* Entries for a name are consumed in order and the last one repeats forever, so
-* a looping machine needs no extra option. A request the script has no route
-* for throws an ordinary `Error` from inside the executor, which reaches the
-* machine as an actor error.
-*
-* Queues are copied on creation, so the caller's arrays are never mutated and
-* each call builds a fresh, independent playthrough. Entries may be plain
-* values or functions of the request.
-*
-* @example
-* ```ts
-* const result = await runAgent(moderationMachine, {
-*   input: { comment: 'honestly this update is terrible', trust: 20 },
-*   executors: createScriptedExecutors({
-*     decisions: { moderate: [{ type: 'FLAG', reason: 'Borderline tone.' }] },
-*   }),
-* });
-* ```
-*
-* @example Dynamic entries
-* ```ts
-* createScriptedExecutors({
-*   text: { draft: (request) => `Draft about ${request.prompt}` },
-*   decisions: { route: (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 = toQueues(script.decisions);
-	const text = toQueues(script.text);
-	const userInput = [...script.userInput ?? []];
-	let userInputIndex = 0;
-	const calls = [];
-	const withDefaultUsage = (result) => result.usage || !script.usage ? result : {
-		...result,
-		usage: script.usage
-	};
-	const nextText = async (kind, request, info) => {
-		const name = request.name ?? "*";
-		calls.push({
-			kind,
-			name,
-			input: request.input,
-			request
-		});
-		const entry = takeEntry(text, name);
-		if (entry === void 0) throw noAnswer(name, text);
-		return withDefaultUsage(await resolveScriptedTextEntry(entry, request, info));
-	};
-	return {
-		calls,
-		userInput: async (input) => {
-			calls.push({
-				kind: "userInput",
-				name: "agent.userInput",
-				input,
-				request: input
-			});
-			if (userInput.length === 0) throw new Error("No scripted answer for request 'agent.userInput'. Add an entry to the script's `userInput` array.");
-			const entry = userInput[Math.min(userInputIndex++, userInput.length - 1)];
-			return typeof entry === "function" ? await entry(input) : entry;
-		},
-		generateText: (request, info) => nextText("generateText", request, info),
-		streamText: async (request, info) => {
-			const name = request.name ?? "*";
-			const streamEntry = script.stream?.[name] ?? script.stream?.["*"];
-			if (streamEntry !== void 0) {
-				calls.push({
-					kind: "streamText",
-					name,
-					input: request.input,
-					request
-				});
-				const resolved = typeof streamEntry === "function" ? await streamEntry(request, info) : streamEntry;
-				const chunks = typeof resolved === "string" ? [resolved] : [...resolved];
-				for (const chunk of chunks) info?.onChunk?.(chunk);
-				return withDefaultUsage({ output: chunks.join("") });
-			}
-			const result = await nextText("streamText", request, info);
-			emitScriptedChunk(result, info);
-			return result;
-		},
-		decide: async (request) => {
-			const name = request.name ?? request.id;
-			calls.push({
-				kind: "decide",
-				name,
-				input: request.input,
-				request
-			});
-			const entry = takeEntry(decisions, name);
-			if (entry === void 0) throw noAnswer(name, decisions);
-			const value = typeof entry === "function" ? await entry(request) : entry;
-			return withDefaultUsage(require_decision.isRecord(value) && typeof value["type"] !== "string" && "event" in value ? value : { event: value });
-		}
-	};
-}
-//#endregion
-//#region src/seam.ts
-/**
-* The seam's own answer, for scoring. Our `{ output }` envelope is read
-* directly; a raw AI SDK `generateText` result contributes its `text`. A raw
-* STREAM result is left alone — the machine consumes that stream, and reading
-* it here would steal the chunks — so `seamOutput` is `undefined` for a
-* streaming candidate that returns one. Score its trajectory instead.
-* @internal
-*/
-async function seamOutputOf(result, request) {
-	if (!require_decision.isRecord(result)) return;
-	if ("output" in result) return await result["output"];
-	if ("textStream" in result) return;
-	return await require_decision.normalizeGeneratorResult(result, `seam '${request.name ?? request.model}'`, { request });
-}
-/**
-* Runs a machine end to end with one model call under test, and slices the run
-* at that call.
-*
-* The `before`/`after` slices are the point: `after.statePath` is the branch
-* the seam chose and `after.events` is the same question against the durable
-* log, both ready for `matchesTrajectory`. The state slice splits where the
-* state path stood when the seam answered; the event slice splits at the
-* seam's own effect completion (the first `xstate.done.*`/`xstate.error.*`
-* entry appended after the call was made).
-*
-* @example No API key: the seam is scripted too, so the whole thing runs offline.
-* ```ts
-* const run = await runSeam(emailDrafter, {
-*   scripts: { promptEvaluator: [vague, complete], emailDrafter: [draft] },
-*   seam: { request: 'evaluatePrompt' },
-*   respond: ({ state }) => (state === 'prompting' ? { type: 'PROMPT_SUBMITTED', prompt } : null),
-* });
-*
-* matchesTrajectory(run.after.statePath, ['needsMoreInfo', 'drafting']);
-* ```
-*
-* @example A candidate prompt at the seam, scored against the same rows.
-* ```ts
-* const { generateText } = createAiSdkExecutors({ models });
-* const run = await runSeam(emailDrafter, { ...row, candidate: generateText });
-* ```
-*/
-async function runSeam(machine, options) {
-	const { seam, candidate } = options;
-	const queues = new Map(Object.entries(options.scripts ?? {}).map(([key, answers]) => [key, [...answers]]));
-	const statePath = [];
-	let calls = 0;
-	let seamMatches = 0;
-	let seamOutput;
-	let seamUsage;
-	const callLog = [];
-	let seamReached = false;
-	let callsBeforeSeam = -1;
-	let seamStateAt = 0;
-	let seamEventAt = 0;
-	let liveEvents = 0;
-	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. 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(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_decision.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 = 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;
-			callsBeforeSeam = callIndex;
-			seamStateAt = statePath.length;
-			seamEventAt = liveEvents;
-			const result = await candidate(request, info);
-			seamOutput = await seamOutputOf(result, request);
-			seamUsage = require_decision.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 = {
-		...options.executors,
-		generateText: route,
-		streamText: async (request, info) => {
-			const result = await route(request, info);
-			emitScriptedChunk(result, info);
-			return result;
-		}
-	};
-	let snapshot;
-	let event;
-	const events = [];
-	let result;
-	const maxTurns = options.maxTurns ?? 12;
-	for (let turn = 0; turn <= maxTurns; turn++) {
-		result = await runAgent(machine, {
-			...snapshot ? { snapshot } : { input: options.input },
-			...event ? { event } : {},
-			...options.actors ? { actors: options.actors } : {},
-			executors,
-			onTransition: (next, causedBy) => {
-				if (turn > 0 && causedBy.type === "@xstate.init") return;
-				events.push(causedBy);
-				liveEvents = events.length;
-				statePath.push(next.value);
-			}
-		});
-		if (result.status !== "idle" || turn === maxTurns) break;
-		const next = options.respond?.({
-			snapshot: result.snapshot,
-			state: result.snapshot.value,
-			meta: require_decision.getStateMeta(result.snapshot),
-			turn,
-			result
-		});
-		if (!next) break;
-		event = next;
-		snapshot = result.persist();
-	}
-	let splitAt = events.length;
-	if (seamReached) {
-		splitAt = seamEventAt;
-		for (let index = seamEventAt; index < events.length; index++) {
-			const type = events[index].type;
-			if (type.startsWith("xstate.done") || type.startsWith("xstate.error")) {
-				splitAt = index;
-				break;
-			}
-		}
-	}
-	const splitStateAt = seamReached ? seamStateAt : statePath.length;
-	return {
-		result,
-		seamOutput,
-		...seamUsage !== void 0 ? { seamUsage } : {},
-		callsBeforeSeam,
-		calls: callLog,
-		before: {
-			statePath: statePath.slice(0, splitStateAt),
-			events: events.slice(0, splitAt)
-		},
-		after: {
-			statePath: statePath.slice(splitStateAt),
-			events: events.slice(splitAt)
-		}
-	};
+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
-exports.AGENT_EVENT_SCHEMA_VERSION = AGENT_EVENT_SCHEMA_VERSION;
-exports.AGENT_INIT_EVENT_TYPE = AGENT_INIT_EVENT_TYPE;
-exports.AGENT_MESSAGES_EVENT_TYPE = require_decision.AGENT_MESSAGES_EVENT_TYPE;
-exports.AGENT_TRACE_SCHEMA_VERSION = AGENT_TRACE_SCHEMA_VERSION;
-exports.AGENT_USAGE_EVENT_TYPE = require_setup_agent.AGENT_USAGE_EVENT_TYPE;
+exports.AGENT_TRACE_SCHEMA_VERSION = require_run_agent.AGENT_TRACE_SCHEMA_VERSION;
+exports.AGENT_USAGE_EVENT_TYPE = require_usage.AGENT_USAGE_EVENT_TYPE;
 exports.AgentDecisionExhaustedError = require_decision.AgentDecisionExhaustedError;
-exports.AgentError = require_decision.AgentError;
-exports.AgentEventLogConflictError = AgentEventLogConflictError;
-exports.AgentEventLogError = AgentEventLogError;
+exports.AgentError = require_text_logic.AgentError;
+exports.AgentEventLogConflictError = require_event_log_store.AgentEventLogConflictError;
 exports.AgentInvalidEventPayloadError = require_decision.AgentInvalidEventPayloadError;
-exports.AgentLintError = AgentLintError;
-exports.AgentMachineVersionMismatchError = AgentMachineVersionMismatchError;
-exports.AgentMaxModelCallsExceededError = AgentMaxModelCallsExceededError;
-exports.AgentReplayDivergenceError = AgentReplayDivergenceError;
-exports.AgentSnapshotDivergedError = AgentSnapshotDivergedError;
-exports.AgentTruncatedError = require_decision.AgentTruncatedError;
-exports.AgentUnknownStateError = AgentUnknownStateError;
-exports.NonSerializableAgentEventError = NonSerializableAgentEventError;
-exports.agentCallOccurrence = agentCallOccurrence;
-exports.appendMessages = require_decision.appendMessages;
-exports.assertAgentLogEntry = assertAgentLogEntry;
-exports.assertAgentMachine = assertAgentMachine;
-exports.assertEventLogStoreConformance = assertEventLogStoreConformance;
-exports.assertJsonSerializable = assertJsonSerializable;
-exports.assistantMessage = require_decision.assistantMessage;
-exports.bindRequestExecutor = require_decision.bindRequestExecutor;
-exports.buildEnvelopeSchema = require_decision.buildEnvelopeSchema;
-exports.canReach = canReach;
+exports.AgentMachineVersionMismatchError = require_event_log_store.AgentMachineVersionMismatchError;
+exports.AgentMaxModelCallsExceededError = require_run_agent.AgentMaxModelCallsExceededError;
+exports.AgentSnapshotDivergedError = require_run_agent.AgentSnapshotDivergedError;
+exports.AgentTruncatedError = require_text_logic.AgentTruncatedError;
+exports.assistantMessage = require_text_logic.assistantMessage;
+exports.bindRequestExecutor = require_text_logic.bindRequestExecutor;
 exports.createAgentSchemas = require_setup_agent.createAgentSchemas;
 exports.createDecisionLogic = require_decision.createDecisionLogic;
 exports.createDecisionRequest = require_decision.createDecisionRequest;
-exports.createInMemoryEventLogStore = createInMemoryEventLogStore;
-exports.createReplayEntry = createReplayEntry;
-exports.createScriptedExecutors = createScriptedExecutors;
-exports.createTextLogic = require_decision.createTextLogic;
+exports.createTextLogic = require_text_logic.createTextLogic;
 exports.eventFromInteraction = eventFromInteraction;
-exports.executeAgentRequest = executeAgentRequest;
-exports.explorePaths = explorePaths;
-exports.forkEventLog = forkEventLog;
+exports.executeAgentRequest = require_run_agent.executeAgentRequest;
 exports.getAcceptedEvents = require_decision.getAcceptedEvents;
-exports.getAgentOutputMode = require_decision.getAgentOutputMode;
+exports.getAgentOutputMode = require_text_logic.getAgentOutputMode;
 exports.getAgentSchemas = require_setup_agent.getAgentSchemas;
-exports.getCallFinishReason = require_decision.getCallFinishReason;
-exports.getCallUsage = require_decision.getCallUsage;
+exports.getCallFinishReason = require_text_logic.getCallFinishReason;
+exports.getCallUsage = require_text_logic.getCallUsage;
 exports.getInteraction = getInteraction;
-exports.getJsonSchema = require_decision.getJsonSchema;
-exports.getJsonSchemaSync = require_decision.getJsonSchemaSync;
-exports.getLogExecutionId = getLogExecutionId;
-exports.getMachineStructuralHash = require_decision.getMachineStructuralHash;
-exports.getMessageText = require_decision.getMessageText;
-exports.getSnapshotStateHash = getSnapshotStateHash;
-exports.getStateMeta = require_decision.getStateMeta;
-exports.getStatePath = require_decision.getStatePath;
-exports.getUsageFromEvents = getUsageFromEvents;
-exports.initEntry = initEntry;
-exports.inspectTransitions = inspectTransitions;
+exports.getJsonSchema = require_text_logic.getJsonSchema;
+exports.getJsonSchemaSync = require_text_logic.getJsonSchemaSync;
+exports.getMachineStructuralHash = require_text_logic.getMachineStructuralHash;
+exports.getMessageText = require_text_logic.getMessageText;
+exports.getStateMeta = require_text_logic.getStateMeta;
+exports.getStatePath = require_text_logic.getStatePath;
+exports.initialAgentStep = require_run_agent.initialAgentStep;
+exports.inspectTransitions = require_run_agent.inspectTransitions;
 exports.interactionMetaSchema = interactionMetaSchema;
-exports.isAgentIdle = isAgentIdle;
-exports.isAgentMessages = require_decision.isAgentMessages;
-exports.isStandardSchema = require_decision.isStandardSchema;
-exports.lintAgentMachine = lintAgentMachine;
-exports.matchesTrajectory = matchesTrajectory;
-exports.messagesSchema = require_decision.messagesSchema;
+exports.isAgentIdle = require_run_agent.isAgentIdle;
+exports.isAgentMessages = isAgentMessages;
+exports.isStandardSchema = require_text_logic.isStandardSchema;
+exports.messagesSchema = messagesSchema;
 exports.parseAgentEvent = require_decision.parseAgentEvent;
-exports.parseModelRef = require_decision.parseModelRef;
-exports.parseOutput = require_decision.parseOutput;
-exports.parseStructuredEnvelope = require_decision.parseStructuredEnvelope;
+exports.parseOutput = require_text_logic.parseOutput;
+exports.parseProviderOutput = require_text_logic.parseProviderOutput;
 exports.provideExecutors = provideExecutors;
-exports.rebindActorSession = rebindActorSession;
+exports.providerOutputSchema = require_text_logic.providerOutputSchema;
+exports.rejectAgentStep = require_run_agent.rejectAgentStep;
 exports.renderDecisionAttempts = require_decision.renderDecisionAttempts;
-exports.replay = replay;
+exports.resolveAgentStep = require_run_agent.resolveAgentStep;
 exports.resolveDecision = require_decision.resolveDecision;
-exports.runAgent = runAgent;
-exports.runAgentLoop = runAgentLoop;
+exports.runAgent = require_run_agent.runAgent;
 exports.runAgentStream = runAgentStream;
-exports.runSeam = runSeam;
-exports.serializeTraceEvent = serializeTraceEvent;
+exports.serializeTraceEvent = require_run_agent.serializeTraceEvent;
 Object.defineProperty(exports, "setupAgent", {
 	enumerable: true,
 	get: function() {
 		return require_setup_agent.setupAgent;
 	}
 });
-exports.simulateAgent = simulateAgent;
-exports.systemMessage = require_decision.systemMessage;
-exports.toolMessage = require_decision.toolMessage;
-exports.traceTransitions = traceTransitions;
-exports.userMessage = require_decision.userMessage;
-exports.validateReplayEntries = validateReplayEntries;
+exports.systemMessage = require_text_logic.systemMessage;
+exports.toolMessage = require_text_logic.toolMessage;
+exports.traceTransitions = require_run_agent.traceTransitions;
+exports.transitionAgentStep = require_run_agent.transitionAgentStep;
+exports.userMessage = require_text_logic.userMessage;