@statelyai/agent 2.0.0-alpha.22 → 2.0.0-alpha.24

package/dist/setup-agent-DkCTy5Eu.cjs

@@ -1,1707 +0,0 @@
-const require_errors = require("./errors-DUBBzRLP.cjs");
-const require_decision = require("./decision-1o45_ZrS.cjs");
-const require_event_log_store = require("./event-log-store-a_TKy1gk.cjs");
-require("./validate.cjs");
-let xstate = require("xstate");
-//#region src/messages.ts
-function addMessages(resolve) {
-	return (args) => {
-		const resolved = typeof resolve === "function" ? resolve(args) : resolve;
-		return [...args.context.messages, ...Array.isArray(resolved) ? resolved : [resolved]];
-	};
-}
-/**
-* Builds a transition-function result that appends one or more
-* {@link AgentMessage}s to a context's `messages` array. `resolve` is either
-* a message (or array of messages) or a function of `{ context, event }`
-* returning them; the returned function is meant to be used directly as (or
-* composed into) a transition's result, e.g. `on: { USER_REPLIED:
-* agent.appendMessages(({ event }) => userMessage(event.text)) }`. Requires
-* `messages: AgentMessage[]` on context — see {@link messagesSchema} for a
-* ready-made schema for that field.
-*
-* @example
-* ```ts
-* on: {
-*   USER_REPLIED: appendMessages(({ event }) => userMessage(event.text)),
-* }
-* ```
-*/
-function appendMessages(resolve) {
-	return (args) => ({ context: { messages: addMessages(resolve)(args) } });
-}
-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`.
-*/
-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 };
-	}
-} };
-//#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;
-}
-/**
-* 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.
-*
-* @internal
-*/
-function getAgentRequests(actions, { machine, ...options } = {}) {
-	if (machine) options = {
-		...require_decision.getRegisteredAgentExecutionOptions(machine),
-		...options
-	};
-	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 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];
-	return {
-		type: "xstate.done.actor",
-		actorId: id,
-		...typeof child?.sessionId === "string" ? { sessionId: child.sessionId } : {},
-		output
-	};
-}
-/**
-* Applies a request's `output` as a done event via `transition(...)`,
-* returning the raw `[snapshot, actions]` tuple. Lower-level than
-* {@link resolveAgentStep} — that helper wraps this and also runs
-* {@link getAgentRequests} to produce the next {@link AgentStep}.
-*
-* @internal
-*/
-function transitionResult(logic, snapshot, request, output) {
-	const event = 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));
-}
-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
-	};
-}
-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(actions, {
-			...options,
-			snapshot
-		}),
-		done: snapshot.status === "done"
-	};
-}
-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/effects.ts
-/**
-* The effect/replay path: the library's new append-only-log core. Two
-* primitives sit under every host loop:
-*
-* - {@link getAgentEffects} maps a transition's ordered executable actions
-*   (reconciled with the still-owed effects visible only on the snapshot) into
-*   an ordered {@link AgentEffect} list a host starts at the frontier.
-* - {@link replay} folds a journal of EXTERNAL inputs through xstate's pure
-*   `initialTransition`/`transition` WITHOUT executing anything, returning the
-*   final snapshot plus the effects still owed — crash recovery, fork resume,
-*   and time travel in one function.
-*
-* The journal of external inputs (effect completions with outputs inline, user
-* events, timer firings) is the authoritative artifact; raised/internal events
-* are never journaled (replay re-derives them). A reserved first entry
-* {@link initEntry} carries the machine input so a log is self-contained.
-* @module
-*/
-/**
-* The reserved journal event type of the {@link initEntry} first entry: it
-* carries the machine `input` so a log replays with no side-channel. Named in
-* the `agent.*` builtin-actor namespace so it never collides with a machine's
-* own event vocabulary. Consumed by {@link replay}; never fed to `transition`.
-*/
-const AGENT_INIT_EVENT_TYPE = "@agent.init";
-/**
-* The reserved event type `runAgent` delivers to the running machine after
-* every settled model call that reported usage — the one seam that puts a
-* call's tokens in reach of ordinary `context` and guards, so a token budget
-* is a plain machine transition instead of host bookkeeping.
-*
-* Like {@link AGENT_INIT_EVENT_TYPE} it lives in the reserved `@agent.*`
-* namespace: it can never collide with a machine's own vocabulary, and
-* `getAcceptedEvents`/`parseAgentEvent` never offer it — a model can neither
-* be shown it as a decision candidate nor forge one.
-*
-* Delivery is opt-in BY CONSTRUCTION: the event is sent only when the live
-* snapshot can currently take it (i.e. the machine declares an
-* `'@agent.usage'` transition, usually machine-level `on`). A machine without
-* one sees no extra transition, no extra trace event, and no extra log entry.
-* When it IS taken it rides the event log like any other external input, so
-* events-only recovery (`runAgent({ events })`) replays the folded tokens
-* without re-calling a model.
-*/
-const AGENT_USAGE_EVENT_TYPE = "@agent.usage";
-/**
-* Creates a JSON-safe, self-describing entry and records the state/effect
-* hashes produced after replaying it. `entries` must be the complete prefix.
-*/
-function createReplayEntry(machine, entries, event, options = {}) {
-	const index = entries.length;
-	const machineId = machine.config.id ?? machine.id ?? "(machine)";
-	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,
-		machineVersion,
-		event: normalizeEventErrors(event),
-		...options.causationId !== void 0 ? { causationId: options.causationId } : {},
-		...options.correlationId !== void 0 ? { correlationId: options.correlationId } : {},
-		...options.metadata !== void 0 ? { metadata: options.metadata } : {}
-	};
-	require_event_log_store.assertAgentLogEntry(entry);
-	if (options.verification !== false) {
-		const result = replay(machine, [...entries, entry], {
-			machineVersion,
-			verify: false
-		});
-		entry.verification = replayVerification(result.snapshot, result.effects);
-	}
-	return entry;
-}
-/** Reserved first replay entry carrying machine input and verification hashes. */
-function initEntry(machine, input, options = {}) {
-	return createReplayEntry(machine, [], {
-		type: AGENT_INIT_EVENT_TYPE,
-		...input !== void 0 ? { input } : {}
-	}, options);
-}
-/** Normalizes a mixed `EventObject | AgentLogEntry` history into bare events. */
-function toEvents(history) {
-	if (!history) return [];
-	return history.map((entry) => {
-		const candidate = entry;
-		return candidate && typeof candidate === "object" && "event" in candidate && candidate.event ? candidate.event : entry;
-	});
-}
-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
-	};
-}
-const DONE_ACTOR_EVENT_TYPE = "xstate.done.actor";
-const ERROR_ACTOR_EVENT_TYPE = "xstate.error.actor";
-function isInvokeCompletion(event, id) {
-	return (event.type === DONE_ACTOR_EVENT_TYPE || event.type === ERROR_ACTOR_EVENT_TYPE) && event.actorId === id;
-}
-/**
-* 1-based occurrence for an invoke/spawn site: `1 + completions` (done AND
-* error both count — an error is a semantic completion) for `id` in `events`.
-*/
-function invokeOccurrence(events, id) {
-	let count = 0;
-	for (const event of events) if (isInvokeCompletion(event, id)) count++;
-	return count + 1;
-}
-/** The exact canonical done/error events xstate's actor system delivers for an invoke `id`. */
-function invokeEventMinters(id, snapshot) {
-	const child = snapshot.children[id];
-	const identity = {
-		actorId: id,
-		...typeof child?.sessionId === "string" ? { sessionId: child.sessionId } : {}
-	};
-	return {
-		toDoneEvent: (output) => ({
-			type: DONE_ACTOR_EVENT_TYPE,
-			output,
-			...identity
-		}),
-		toErrorEvent: (error) => ({
-			type: ERROR_ACTOR_EVENT_TYPE,
-			error,
-			...identity
-		})
-	};
-}
-/** Splits an `xstate.after.<delayKey>.<statePath>` id into its parts. */
-function parseAfterId(afterId) {
-	if (!afterId.startsWith("xstate.after.")) return;
-	const rest = afterId.slice(13);
-	const dot = rest.indexOf(".");
-	if (dot === -1) return;
-	return {
-		delayKey: rest.slice(0, dot),
-		statePath: rest.slice(dot + 1)
-	};
-}
-function buildInvokeEffect(meta, mapped, events, snapshot, options) {
-	const id = typeof meta.id === "string" ? meta.id : void 0;
-	if (!id) return;
-	const requestId = `${id}#${invokeOccurrence(events, id)}`;
-	if (mapped?.kind === "text") return {
-		kind: "text",
-		requestId,
-		request: mapped.input,
-		mode: mapped.mode,
-		...invokeEventMinters(id, snapshot)
-	};
-	if (mapped?.kind === "decision") return {
-		kind: "decision",
-		requestId,
-		request: mapped
-	};
-	const logic = require_decision.isTextLogic(meta.logic) || require_decision.isDecisionLogic(meta.logic) ? meta.logic : typeof meta.src === "string" ? options.actors?.[meta.src] : void 0;
-	if (require_decision.isTextLogic(logic)) return {
-		kind: "text",
-		requestId,
-		request: logic.request(meta.input),
-		mode: logic.mode,
-		...invokeEventMinters(id, snapshot)
-	};
-	if (require_decision.isDecisionLogic(logic)) {
-		const base = logic.request(meta.input);
-		const eventTypes = logic.allowedEventTypes?.(meta.input);
-		const candidateEvents = require_decision.getAcceptedEvents(snapshot, {
-			events: options.schemas?.events,
-			schemas: options.schemas,
-			eventTypes
-		});
-		return {
-			kind: "decision",
-			requestId,
-			request: {
-				...base,
-				id,
-				events: candidateEvents
-			}
-		};
-	}
-	return {
-		kind: "task",
-		requestId,
-		id,
-		src: typeof meta.src === "string" ? meta.src : id,
-		input: meta.input,
-		...invokeEventMinters(id, snapshot)
-	};
-}
-/**
-* Maps a transition's ORDERED executable actions (plus the still-owed effects
-* visible only on the snapshot) into an ordered {@link AgentEffect} list the
-* host starts at the frontier.
-*
-* Ordering is load-bearing: a single transition's actions are emitted in
-* document order (a custom entry action, a spawn, and a `sendTo` in that order
-* yield `execute`, then `task`/agent effect, then `execute` — never a
-* reordered set). Effects visible only on the snapshot (children spawned by
-* an EARLIER transition that
-* have not completed yet — the fan-out / crash-resume case) are appended after
-* the action-derived effects, deduped by site id.
-*
-* Every `requestId` is `${siteId}#${n}`, `n` the 1-based occurrence derived
-* from `options.history` — so the same log yields identical requestIds on every
-* replay. XState alpha.24 prunes a child when its matching completion is
-* folded; the history check also prevents older/restored snapshots from
-* re-surfacing completed work. A re-entered invoke site instead re-derives
-* from the action list each fresh entry (so `#2`, `#3`, … stay correct).
-*/
-function getAgentEffects(machine, snapshot, actions, options = {}) {
-	const resolved = require_decision.getRegisteredAgentExecutionOptions(machine, options);
-	const events = toEvents(options.history);
-	const rawActions = actions;
-	const requests = getAgentRequests(rawActions, {
-		...resolved,
-		snapshot
-	});
-	const requestById = new Map(requests.map((request) => [request.id, request]));
-	const effects = [];
-	const emitted = /* @__PURE__ */ new Set();
-	for (const rawAction of rawActions) {
-		const meta = getInvokeEffectMetadata(rawAction);
-		if (meta) {
-			const effect = buildInvokeEffect(meta, typeof meta.id === "string" ? requestById.get(meta.id) : void 0, events, snapshot, resolved);
-			if (effect && typeof meta.id === "string") {
-				effects.push(effect);
-				emitted.add(meta.id);
-			}
-			continue;
-		}
-		if (rawAction.type === "@xstate.raise" && typeof rawAction.delay === "number") {
-			const afterId = typeof rawAction.id === "string" ? rawAction.id : "";
-			const parsed = parseAfterId(afterId);
-			const siteId = parsed ? `${parsed.statePath}#${parsed.delayKey}` : afterId;
-			const event = {
-				type: "xstate.timer",
-				id: afterId
-			};
-			const firings = events.filter((candidate) => candidate.type === event.type && candidate.id === afterId).length;
-			effects.push({
-				kind: "delay",
-				requestId: `${siteId}#${firings + 1}`,
-				id: afterId,
-				delayMs: rawAction.delay,
-				event
-			});
-			continue;
-		}
-		if (rawAction.type === "@xstate.start" || rawAction.type === "@xstate.stop" || rawAction.type === "@xstate.terminate" || rawAction.type === "@xstate.raise" || rawAction.type === "registerChild") continue;
-		if (typeof rawAction.exec === "function") {
-			const action = rawAction;
-			effects.push({
-				kind: "execute",
-				action: rawAction,
-				exec: () => {
-					action.exec();
-				}
-			});
-		}
-	}
-	const children = snapshot.children;
-	for (const [id, child] of Object.entries(children ?? {})) {
-		if (emitted.has(id) || invokeOccurrence(events, id) > 1) continue;
-		const ref = child;
-		if (typeof ref?.getSnapshot !== "function") continue;
-		const effect = buildInvokeEffect({
-			id,
-			src: ref.src,
-			input: ref.getSnapshot().input,
-			logic: ref.logic
-		}, requestById.get(id), events, snapshot, resolved);
-		if (effect) {
-			effects.push(effect);
-			emitted.add(id);
-		}
-	}
-	return effects;
-}
-var AgentReplayMachineMismatchError = class extends require_errors.AgentError {
-	constructor(eventId, index, expected, actual) {
-		super("replay-machine-mismatch", `Replay 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 = "AgentReplayMachineMismatchError";
-	}
-};
-var AgentReplayDivergenceError = class extends require_errors.AgentError {
-	constructor(eventId, index, kind, expected, actual) {
-		super("replay-divergence", kind === "missing-verification" ? `Replay entry '${eventId}' at index ${index} has no verification hashes.` : `Replay diverged after '${eventId}' at index ${index} (${kind}): expected '${expected}', got '${actual}'.`);
-		this.eventId = eventId;
-		this.index = index;
-		this.kind = kind;
-		this.expected = expected;
-		this.actual = actual;
-		this.name = "AgentReplayDivergenceError";
-	}
-};
-/**
-* Folds a journal through `initialTransition`/`transition` WITHOUT executing
-* anything, then returns the final snapshot plus the still-owed effects
-* ({@link getAgentEffects} of the final frontier, occurrence counts taken from
-* the whole log). Crash recovery, fork resume, and time travel in one call.
-*
-* `entries` is a versioned {@link AgentLogEntry} array. A reserved
-* {@link initEntry} first envelope carries `{ type: '@agent.init', input }`,
-* so a complete log replays with no side-channel; when absent,
-* `options.input` is used instead.
-* Raised/internal events are never in the journal — replay re-derives them
-* deterministically from the machine's own logic.
-*/
-/**
-* Validates a replay entry sequence: envelope shape, contiguity from index 0,
-* unique event ids, and machine identity.
-*
-* @internal
-*/
-function validateReplayEntries(entries, expected, label) {
-	const eventIds = /* @__PURE__ */ new Set();
-	for (let index = 0; index < entries.length; index++) {
-		const entry = entries[index];
-		require_event_log_store.assertAgentLogEntry(entry);
-		if (entry.index !== index) throw new Error(`${label} must be contiguous from index 0; found entry.index ${entry.index} at position ${index}.`);
-		if (eventIds.has(entry.id)) throw new Error(`${label} contain duplicate event id '${entry.id}'.`);
-		eventIds.add(entry.id);
-		if (entry.machineId !== expected.machineId || entry.machineVersion !== expected.machineVersion) throw new AgentReplayMachineMismatchError(entry.id, entry.index, expected, {
-			machineId: entry.machineId,
-			machineVersion: entry.machineVersion
-		});
-	}
-}
-function replay(machine, entries, options = {}) {
-	validateReplayEntries(entries, {
-		machineId: machine.config.id ?? machine.id ?? "(machine)",
-		machineVersion: options.machineVersion ?? require_decision.resolveMachineVersion(machine)
-	}, "Replay entries");
-	const events = toEvents(entries);
-	const initOffset = events[0]?.type === "@agent.init" ? 1 : 0;
-	const input = initOffset ? events[0].input : options.input;
-	const journal = events.slice(initOffset);
-	const journalEntries = entries.slice(initOffset);
-	let [snapshot, actions] = (0, xstate.initialTransition)(machine, input);
-	let effects = getAgentEffects(machine, snapshot, actions, {
-		...options,
-		history: entries.slice(0, initOffset)
-	});
-	if (initOffset) verifyEntry(entries[0], snapshot, effects, options.verify);
-	const sessions = /* @__PURE__ */ new Map();
-	for (let index = 0; index < journal.length; index++) {
-		const event = journal[index];
-		const reboundEvent = rebindActorSession(event, snapshot, sessions);
-		[snapshot, actions] = (0, xstate.transition)(machine, snapshot, reboundEvent);
-		const consumed = entries.slice(0, initOffset + index + 1);
-		effects = getAgentEffects(machine, snapshot, actions, {
-			...options,
-			history: consumed
-		});
-		verifyEntry(journalEntries[index], snapshot, effects, options.verify);
-	}
-	return {
-		snapshot,
-		effects
-	};
-}
-/** Structural event-tail, logical-state, and owed-effect comparison. */
-function diffEventLogs(machine, parentEntries, forkEntries, options = {}) {
-	let commonLength = 0;
-	while (commonLength < parentEntries.length && commonLength < forkEntries.length && stableJson(parentEntries[commonLength]) === stableJson(forkEntries[commonLength])) commonLength++;
-	const parent = replay(machine, parentEntries, options);
-	const fork = replay(machine, forkEntries, options);
-	const parentState = logicalReplayState(parent.snapshot);
-	const forkState = logicalReplayState(fork.snapshot);
-	return {
-		commonPrefix: {
-			length: commonLength,
-			...commonLength > 0 ? { throughEventId: parentEntries[commonLength - 1].id } : {}
-		},
-		parentOnly: parentEntries.slice(commonLength),
-		forkOnly: forkEntries.slice(commonLength),
-		parent,
-		fork,
-		stateChanges: diffJson(parentState, forkState),
-		effectChanges: diffEffects(parent.effects, fork.effects)
-	};
-}
-function verifyEntry(entry, snapshot, effects, mode) {
-	if (mode === false) return;
-	if (!entry.verification) {
-		if (mode === "strict") throw new AgentReplayDivergenceError(entry.id, entry.index, "missing-verification");
-		return;
-	}
-	const actual = replayVerification(snapshot, effects);
-	if (actual.stateHash !== entry.verification.stateHash) throw new AgentReplayDivergenceError(entry.id, entry.index, "state", entry.verification.stateHash, actual.stateHash);
-	if (actual.effectsHash !== entry.verification.effectsHash) throw new AgentReplayDivergenceError(entry.id, entry.index, "effects", entry.verification.effectsHash, actual.effectsHash);
-}
-function replayVerification(snapshot, effects) {
-	return {
-		stateHash: hashStableJson(logicalReplayState(snapshot)),
-		effectsHash: hashStableJson(serializableEffects(effects))
-	};
-}
-function logicalReplayState(snapshot) {
-	const state = {
-		status: snapshot.status,
-		value: snapshot.value,
-		context: snapshot.context
-	};
-	if (snapshot.output !== void 0) state.output = snapshot.output;
-	if (snapshot.error !== void 0) state.error = snapshot.error;
-	const canonical = canonicalizeForHash(state);
-	require_event_log_store.assertJsonSerializable(canonical, "snapshot");
-	return canonical;
-}
-function serializableEffects(effects) {
-	return effects.map((effect) => canonicalizeEffect(effect));
-}
-function canonicalizeEffect(effect) {
-	if (effect.kind === "execute") return {
-		kind: effect.kind,
-		type: String(effect.action.type)
-	};
-	const value = { ...effect };
-	delete value.toDoneEvent;
-	delete value.toErrorEvent;
-	delete value.exec;
-	delete value.action;
-	return canonicalizeForHash(value);
-}
-function canonicalizeForHash(value, seen = /* @__PURE__ */ new WeakSet()) {
-	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) return {
-		errorName: value.name,
-		message: value.message,
-		...value.cause !== void 0 ? { cause: canonicalizeForHash(value.cause, seen) } : {}
-	};
-	if (value instanceof Set) return [...value].map((item) => canonicalizeForHash(item, seen)).sort((a, b) => stableJson(a).localeCompare(stableJson(b)));
-	if (value instanceof Map) return [...value.entries()].map(([key, item]) => [canonicalizeForHash(key, seen), canonicalizeForHash(item, seen)]).sort(([a], [b]) => stableJson(a).localeCompare(stableJson(b)));
-	if (seen.has(value)) return "[circular]";
-	seen.add(value);
-	if (Array.isArray(value)) {
-		const result = value.map((item) => canonicalizeForHash(item, seen));
-		seen.delete(value);
-		return result;
-	}
-	const standard = value["~standard"];
-	if (standard) {
-		seen.delete(value);
-		return {
-			schemaVendor: standard.vendor,
-			schemaVersion: standard.version
-		};
-	}
-	const result = {};
-	for (const key of Object.keys(value).sort()) result[key] = canonicalizeForHash(value[key], seen);
-	seen.delete(value);
-	return result;
-}
-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;
-}
-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;
-}
-function hashStableJson(value) {
-	return require_decision.djb2Hex(stableJson(value));
-}
-function diffJson(before, after, path = "") {
-	if (stableJson(before) === stableJson(after)) return [];
-	if (before === null || after === null || typeof before !== "object" || typeof after !== "object" || Array.isArray(before) || Array.isArray(after)) return [{
-		op: "replace",
-		path,
-		value: after
-	}];
-	const changes = [];
-	const beforeObject = before;
-	const afterObject = after;
-	const keys = new Set([...Object.keys(beforeObject), ...Object.keys(afterObject)]);
-	for (const key of [...keys].sort()) {
-		const childPath = `${path}/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`;
-		if (!(key in afterObject)) changes.push({
-			op: "remove",
-			path: childPath
-		});
-		else if (!(key in beforeObject)) changes.push({
-			op: "add",
-			path: childPath,
-			value: afterObject[key]
-		});
-		else changes.push(...diffJson(beforeObject[key], afterObject[key], childPath));
-	}
-	return changes;
-}
-function diffEffects(before, after) {
-	const beforeValues = serializableEffects(before);
-	const afterValues = serializableEffects(after);
-	const key = (value, index) => {
-		const record = value;
-		return typeof record.requestId === "string" ? record.requestId : `${String(record.kind ?? "effect")}:${index}`;
-	};
-	const beforeMap = new Map(beforeValues.map((value, index) => [key(value, index), value]));
-	const afterMap = new Map(afterValues.map((value, index) => [key(value, index), value]));
-	const added = [];
-	const removed = [];
-	const changed = [];
-	for (const [id, value] of beforeMap) {
-		const next = afterMap.get(id);
-		if (next === void 0) removed.push(value);
-		else if (stableJson(value) !== stableJson(next)) changed.push({
-			before: value,
-			after: next
-		});
-	}
-	for (const [id, value] of afterMap) if (!beforeMap.has(id)) added.push(value);
-	return {
-		added,
-		removed,
-		changed
-	};
-}
-//#endregion
-//#region src/workflow-config.ts
-/**
-* The machines-as-data lowering: `setupAgent(...).fromConfig(config, options)`.
-*
-* Takes a serializable `AgentWorkflowConfig` (the JSON form of an agent
-* machine — published schema at `schemas/agent-workflow.json`, docs at
-* docs/machines-as-data.md), compiles its embedded JSON Schemas with the
-* host-provided `compileSchema`, resolves named guards/actions/actors from
-* `options`, and lowers the whole thing to an ordinary XState machine plus its
-* schema pack. This is what makes LLM-generated and stored-as-JSON machines
-* first-class: the config validates against the shipped schema before any
-* model call, and the resulting machine lints, simulates, and runs like a
-* hand-authored one.
-*/
-const DECIDE_SRC = "agent.decide";
-const workflowConfigWholeExpressionPattern = /^\{\{\s*([\s\S]*?)\s*\}\}$/;
-const workflowConfigTemplateExpressionPattern = /\{\{\s*([\s\S]*?)\s*\}\}/g;
-const workflowConfigHasTemplatePattern = /\{\{[\s\S]*?\}\}/;
-function toArray(value) {
-	return Array.isArray(value) ? value : [value];
-}
-function evaluateWorkflowConfigPath(expression, scope) {
-	const parts = expression.trim().split(".").filter(Boolean);
-	let current = scope;
-	for (const part of parts) {
-		if (!current || typeof current !== "object") return;
-		current = current[part];
-	}
-	return current;
-}
-function evaluateWorkflowConfigValue(value, scope) {
-	if (typeof value === "string") {
-		const wholeMatch = value.match(workflowConfigWholeExpressionPattern);
-		if (wholeMatch?.[1]) return evaluateWorkflowConfigPath(wholeMatch[1], scope);
-		return value.replace(workflowConfigTemplateExpressionPattern, (_match, expression) => {
-			const resolved = evaluateWorkflowConfigPath(expression, scope);
-			return resolved === void 0 || resolved === null ? "" : String(resolved);
-		});
-	}
-	if (Array.isArray(value)) return value.map((item) => evaluateWorkflowConfigValue(item, scope));
-	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, evaluateWorkflowConfigValue(item, scope)]));
-	return value;
-}
-function createSchemasFromWorkflowConfig(config, compileSchema) {
-	return createAgentSchemas({
-		context: compileSchema(config.schemas?.context ?? { type: "object" }, "context"),
-		events: Object.fromEntries(Object.entries(config.schemas?.events ?? {}).map(([key, schema]) => [key, compileSchema(schema, `event.${key}`)])),
-		emitted: Object.fromEntries(Object.entries(config.schemas?.emitted ?? {}).map(([key, schema]) => [key, compileSchema(schema, `emitted.${key}`)])),
-		input: compileSchema(config.schemas?.input ?? {}, "input"),
-		output: compileSchema(config.schemas?.output ?? {}, "output"),
-		meta: compileSchema(config.schemas?.meta ?? {}, "meta")
-	});
-}
-function createRequestsFromWorkflowConfig(config, compileSchema) {
-	const resolver = (value) => value === void 0 ? void 0 : ({ input }) => evaluateWorkflowConfigValue(value, { input });
-	return Object.fromEntries(Object.entries(config.requests ?? {}).map(([key, request]) => [key, {
-		mode: request.mode,
-		description: request.description,
-		schemas: {
-			input: compileSchema(request.input, `${key}.input`),
-			output: compileSchema(request.output, `${key}.output`)
-		},
-		model: ({ input }) => String(evaluateWorkflowConfigValue(request.model, { input }) ?? ""),
-		system: resolver(request.system),
-		prompt: resolver(request.prompt),
-		messages: resolver(request.messages),
-		tools: request.tools,
-		toolChoice: request.toolChoice,
-		includeReasoning: request.includeReasoning,
-		temperature: resolver(request.temperature),
-		maxOutputTokens: resolver(request.maxOutputTokens),
-		topP: resolver(request.topP),
-		topK: resolver(request.topK),
-		seed: resolver(request.seed),
-		stopSequences: resolver(request.stopSequences),
-		metadata: resolver(request.metadata)
-	}]));
-}
-function createActorPlaceholdersFromWorkflowConfig(config) {
-	return Object.fromEntries(Object.keys(config.actors ?? {}).map((key) => [key, require_decision.missingActor(key)]));
-}
-const AGENT_EXPRESSION_LANG = "agent-template";
-function containsTemplateExpression(value) {
-	if (typeof value === "string") return workflowConfigHasTemplatePattern.test(value);
-	if (Array.isArray(value)) return value.some(containsTemplateExpression);
-	if (value && typeof value === "object") return Object.values(value).some(containsTemplateExpression);
-	return false;
-}
-function toWorkflowExpression(value) {
-	if (!containsTemplateExpression(value)) return value;
-	return { "@expr": JSON.stringify(value) };
-}
-function createWorkflowConfigEvaluator(contextSchema) {
-	const decoded = /* @__PURE__ */ new Map();
-	const decode = (source) => {
-		if (!decoded.has(source)) decoded.set(source, JSON.parse(source));
-		return decoded.get(source);
-	};
-	return ({ source, slot, scope }) => {
-		const value = decode(source);
-		if (slot === "context") return require_decision.validateSchemaSync(contextSchema, evaluateWorkflowConfigValue(value, { input: scope.input }));
-		return evaluateWorkflowConfigValue(value, {
-			context: scope.context,
-			event: scope.event,
-			input: scope.input
-		});
-	};
-}
-function translateWorkflowGuard(guard, translation, location) {
-	if (guard === void 0) return;
-	if (typeof guard === "string") {
-		if (workflowConfigHasTemplatePattern.test(guard)) return { "@expr": JSON.stringify(guard) };
-		if (!(guard in translation.guards)) throw new Error(`setupAgent.fromConfig: ${location} references guard '${guard}', which has no implementation. Provide one via fromConfig options: setupAgent.fromConfig(config, { guards: { '${guard}': ({ context, event }) => ... } }).`);
-		return { type: guard };
-	}
-	if (typeof guard === "function") {
-		const name = `__fromConfigGuard${Object.keys(translation.syntheticGuards).length}`;
-		translation.syntheticGuards[name] = guard;
-		return { type: name };
-	}
-	throw new Error(`setupAgent.fromConfig: ${location} has an unsupported guard value. Use a '{{ ... }}' template string, a named guard reference (string), or a function.`);
-}
-function translateWorkflowAction(action, translation, location) {
-	if (action.assign !== void 0) return {
-		type: "@xstate.assign",
-		context: toWorkflowExpression(action.assign)
-	};
-	if (action.emit !== void 0) return {
-		type: "@xstate.emit",
-		event: toWorkflowExpression(action.emit)
-	};
-	if (action.type) {
-		if (!(action.type in translation.actions)) throw new Error(`setupAgent.fromConfig: ${location} uses named action type '${action.type}', which has no implementation. Provide one via fromConfig options: setupAgent.fromConfig(config, { actions: { '${action.type}': (params) => ... } }).`);
-		return {
-			type: action.type,
-			...action.params !== void 0 ? { params: toWorkflowExpression(action.params) } : {}
-		};
-	}
-	throw new Error(`setupAgent.fromConfig: ${location} action must declare 'assign', 'emit', or 'type'.`);
-}
-function translateWorkflowTransition(transitionConfig, translation, location) {
-	const actionConfigs = transitionConfig.actions ? toArray(transitionConfig.actions) : [];
-	const assignConfigs = [...transitionConfig.assign !== void 0 ? [transitionConfig.assign] : [], ...actionConfigs.filter((action) => action.assign !== void 0).map((action) => action.assign)];
-	const contextPatch = assignConfigs.length ? toWorkflowExpression(Object.assign({}, ...assignConfigs)) : void 0;
-	const actions = actionConfigs.filter((action) => action.assign === void 0).map((action) => translateWorkflowAction(action, translation, location));
-	const guard = translateWorkflowGuard(transitionConfig.guard, translation, location);
-	return {
-		...transitionConfig.target !== void 0 ? { target: transitionConfig.target } : {},
-		...guard ? { guard } : {},
-		...contextPatch !== void 0 ? { context: contextPatch } : {},
-		...actions.length ? { actions } : {},
-		...transitionConfig.description !== void 0 ? { description: transitionConfig.description } : {},
-		...transitionConfig.reenter !== void 0 ? { reenter: transitionConfig.reenter } : {},
-		...transitionConfig.meta !== void 0 ? { meta: transitionConfig.meta } : {}
-	};
-}
-function translateWorkflowTransitions(transitionConfig, translation, location) {
-	if (!transitionConfig) return;
-	return Array.isArray(transitionConfig) ? transitionConfig.map((candidate) => translateWorkflowTransition(candidate, translation, location)) : translateWorkflowTransition(transitionConfig, translation, location);
-}
-function addTransitionMatch(transition, matches) {
-	if (Array.isArray(transition)) return transition.map((candidate) => addTransitionMatch(candidate, matches));
-	return transition ? {
-		...transition,
-		matches: {
-			...transition.matches,
-			...matches
-		}
-	} : void 0;
-}
-function translateWorkflowInvoke(invokeConfig, translation, stateKey) {
-	if (invokeConfig.src === DECIDE_SRC && invokeConfig.onDone !== void 0) throw new Error(`setupAgent.fromConfig: state '${stateKey}' declares an 'onDone' on its 'agent.decide' invoke, which is always a config error. A decision has no output of its own — the chosen event is delivered automatically and handled by the state's 'on' transitions. Remove the 'onDone' (use 'on' for the chosen event; 'onError' still handles retries exhausted).`);
-	const location = `state '${stateKey}'`;
-	return {
-		...invokeConfig.id !== void 0 ? { id: invokeConfig.id } : {},
-		src: invokeConfig.src,
-		...invokeConfig.input !== void 0 ? { input: toWorkflowExpression(invokeConfig.input) } : {},
-		...invokeConfig.onDone !== void 0 ? { onDone: translateWorkflowTransitions(invokeConfig.onDone, translation, location) } : {},
-		...invokeConfig.onError !== void 0 ? { onError: translateWorkflowTransitions(invokeConfig.onError, translation, location) } : {}
-	};
-}
-function assertValidTransitionTargets(stateKey, location, transitionConfig, siblingKeys, declaredTargets) {
-	if (!transitionConfig) return;
-	for (const transition of toArray(transitionConfig)) {
-		const targets = transition.target === void 0 ? [] : toArray(transition.target);
-		for (const target of targets) {
-			if (typeof target !== "string") continue;
-			declaredTargets.push(target);
-			if (target.startsWith("#") || target.startsWith(".")) continue;
-			const head = target.split(".")[0];
-			if (!siblingKeys.has(head)) throw new Error(`setupAgent.fromConfig: state '${stateKey}' has a ${location} transition targeting '${target}', which is not a state at that level. Valid targets: ${[...siblingKeys].join(", ") || "(none)"}.`);
-		}
-	}
-}
-function assertStateTransitionTargets(stateKey, stateConfig, siblingKeys) {
-	const declaredTargets = [];
-	const invokes = stateConfig.invoke ? toArray(stateConfig.invoke) : [];
-	const sources = [
-		...Object.entries(stateConfig.on ?? {}).map(([eventType, transition]) => [`'on.${eventType}'`, transition]),
-		...Object.entries(stateConfig.after ?? {}).map(([delay, transition]) => [`'after.${delay}'`, transition]),
-		["'always'", stateConfig.always],
-		["'onDone'", stateConfig.onDone],
-		["'choice'", stateConfig.choice],
-		...invokes.flatMap((invoke) => [["invoke 'onDone'", invoke.onDone], ["invoke 'onError'", invoke.onError]])
-	];
-	for (const [location, transition] of sources) assertValidTransitionTargets(stateKey, location, transition, siblingKeys, declaredTargets);
-	return declaredTargets;
-}
-function translateWorkflowState(stateKey, stateConfig, siblingKeys, path, translation) {
-	const location = `state '${stateKey}'`;
-	if (stateKey.includes(".")) throw new Error(`setupAgent.fromConfig: state key '${stateKey}' contains a '.', which is reserved as the state-path separator. Rename the state (e.g. '${stateKey.replace(/\./g, "_")}').`);
-	const childKeys = new Set(Object.keys(stateConfig.states ?? {}));
-	const childPath = [...path, stateKey];
-	translation.transitionTargets[childPath.join(".")] = assertStateTransitionTargets(stateKey, stateConfig, siblingKeys);
-	const doneStateId = stateConfig.onDone !== void 0 ? `@state.${childPath.join(".")}` : void 0;
-	const translatedOn = {
-		...Object.fromEntries(Object.entries(stateConfig.on ?? {}).map(([eventType, transitionConfig]) => [eventType, translateWorkflowTransitions(transitionConfig, translation, location)])),
-		...doneStateId ? { "xstate.done.state": addTransitionMatch(translateWorkflowTransitions(stateConfig.onDone, translation, location), { stateId: doneStateId }) } : {}
-	};
-	return {
-		...stateConfig.description !== void 0 ? { description: stateConfig.description } : {},
-		...stateConfig.type !== void 0 ? { type: stateConfig.type } : {},
-		...doneStateId ? { id: doneStateId } : {},
-		...stateConfig.initial !== void 0 ? { initial: stateConfig.initial } : {},
-		...stateConfig.states !== void 0 ? { states: Object.fromEntries(Object.entries(stateConfig.states).map(([key, child]) => [key, translateWorkflowState(key, child, childKeys, childPath, translation)])) } : {},
-		...stateConfig.choice !== void 0 ? { choice: toArray(stateConfig.choice).map((branch) => {
-			if (branch.actions !== void 0) throw new Error(`setupAgent.fromConfig: state '${stateKey}' has a 'choice' branch with 'actions', which is not supported. Use 'assign' on the branch, or move the actions to the target state's 'entry'.`);
-			const when = translateWorkflowGuard(branch.guard, translation, location);
-			return {
-				...when ? { when } : {},
-				target: branch.target,
-				...branch.assign !== void 0 ? { context: toWorkflowExpression(branch.assign) } : {},
-				...branch.description !== void 0 ? { description: branch.description } : {},
-				...branch.reenter !== void 0 ? { reenter: branch.reenter } : {},
-				...branch.meta !== void 0 ? { meta: branch.meta } : {}
-			};
-		}) } : {},
-		...stateConfig.invoke !== void 0 ? { invoke: Array.isArray(stateConfig.invoke) ? stateConfig.invoke.map((invoke) => translateWorkflowInvoke(invoke, translation, stateKey)) : translateWorkflowInvoke(stateConfig.invoke, translation, stateKey) } : {},
-		...Object.keys(translatedOn).length ? { on: translatedOn } : {},
-		...stateConfig.always !== void 0 ? { always: translateWorkflowTransitions(stateConfig.always, translation, location) } : {},
-		...stateConfig.after !== void 0 ? { after: Object.fromEntries(Object.entries(stateConfig.after).map(([delay, transitionConfig]) => [delay, translateWorkflowTransitions(transitionConfig, translation, location)])) } : {},
-		...stateConfig.entry !== void 0 ? { entry: toArray(stateConfig.entry).map((action) => translateWorkflowAction(action, translation, location)) } : {},
-		...stateConfig.exit !== void 0 ? { exit: toArray(stateConfig.exit).map((action) => translateWorkflowAction(action, translation, location)) } : {},
-		...stateConfig.tags !== void 0 ? { tags: stateConfig.tags } : {},
-		...stateConfig.output !== void 0 ? { output: toWorkflowExpression(stateConfig.output) } : {},
-		...stateConfig.meta !== void 0 ? { meta: stateConfig.meta } : {}
-	};
-}
-function collectTranslatedFinalOutputs(states, outputs = []) {
-	for (const state of Object.values(states ?? {})) {
-		if (state?.type === "final" && state.output !== void 0) outputs.push(state.output);
-		collectTranslatedFinalOutputs(state?.states, outputs);
-	}
-	return outputs;
-}
-function translateWorkflowConfig(config, translation) {
-	const rootKeys = new Set(Object.keys(config.states));
-	const states = Object.fromEntries(Object.entries(config.states).map(([key, state]) => [key, translateWorkflowState(key, state, rootKeys, [], translation)]));
-	const json = {
-		"@exprLang": AGENT_EXPRESSION_LANG,
-		...config.id !== void 0 ? { id: config.id } : {},
-		...config.description !== void 0 ? { description: config.description } : {},
-		...config.context !== void 0 ? { context: { "@expr": JSON.stringify(config.context) } } : {},
-		initial: config.initial,
-		states,
-		...config.meta !== void 0 ? { meta: config.meta } : {}
-	};
-	const finalOutputs = collectTranslatedFinalOutputs(states);
-	if (json.output === void 0 && finalOutputs.length === 1) json.output = finalOutputs[0];
-	return json;
-}
-function collectDeclaredStateTags(states, tags = /* @__PURE__ */ new Set()) {
-	for (const state of Object.values(states ?? {})) {
-		for (const tag of state.tags ?? []) tags.add(tag);
-		collectDeclaredStateTags(state.states, tags);
-	}
-	return tags;
-}
-function resolveIdlePredicate(config, options) {
-	if (options.isIdle) return options.isIdle;
-	const idleTags = config.idleTags ?? [];
-	if (!idleTags.length) return;
-	const declaredTags = collectDeclaredStateTags(config.states);
-	const unknown = idleTags.filter((tag) => !declaredTags.has(tag));
-	if (unknown.length) throw new Error(`setupAgent.fromConfig: 'idleTags' lists ${unknown.map((tag) => `'${tag}'`).join(", ")}, which no state declares in its 'tags'. Tag the waiting state(s) — e.g. "tags": ["${unknown[0]}"] — or remove the entry.`);
-	return (snapshot) => idleTags.some((tag) => snapshot.hasTag(tag));
-}
-function setupAgentFromConfig(config, options) {
-	if (!options || typeof options.compileSchema !== "function") throw new Error("setupAgent.fromConfig(...) requires a 'compileSchema' option: { compileSchema: (jsonSchema, name) => StandardSchemaV1 }. Bring your own JSON Schema engine (Ajv, @cfworker/json-schema, a compiled-Zod-from-JSON-Schema pipeline, ...). Core intentionally ships no JSON Schema engine.");
-	const { compileSchema } = options;
-	const schemas = createSchemasFromWorkflowConfig(config, compileSchema);
-	const requestActors = createRequestActors(createRequestsFromWorkflowConfig(config, compileSchema));
-	const actors = createAgentActors(createActorPlaceholdersFromWorkflowConfig(config), requestActors);
-	const translation = {
-		guards: options.guards ?? {},
-		actions: options.actions ?? {},
-		syntheticGuards: {},
-		transitionTargets: {}
-	};
-	const machine = (0, xstate.createMachineFromConfig)(translateWorkflowConfig(config, translation), {
-		guards: Object.fromEntries(Object.entries({
-			...translation.guards,
-			...translation.syntheticGuards
-		}).map(([name, implementation]) => [name, (args) => Boolean(implementation({
-			context: args.context,
-			event: args.event
-		}))])),
-		...options.actions ? { actions: options.actions } : {},
-		actors: Object.fromEntries(Object.keys(actors).map((key) => [key, key])),
-		evaluators: { [AGENT_EXPRESSION_LANG]: createWorkflowConfigEvaluator(schemas.context) }
-	}).provide({ actors });
-	require_decision.agentExecutionOptions.set(machine, {
-		schemas,
-		actors,
-		models: {}
-	});
-	if (machine.config) require_decision.machineStaticTransitionTargets.set(machine.config, translation.transitionTargets);
-	const isIdle = resolveIdlePredicate(config, options);
-	if (isIdle && machine.config) require_decision.machineIdlePredicates.set(machine.config, isIdle);
-	return {
-		machine,
-		schemas
-	};
-}
-//#endregion
-//#region src/setup-agent.ts
-const emptyEventSchema = { "~standard": {
-	version: 1,
-	vendor: "statelyai-agent",
-	validate(value) {
-		return value !== null && typeof value === "object" && Object.keys(value).length === 0 ? { value: {} } : { issues: [{ message: "Expected an empty event payload" }] };
-	}
-} };
-const USAGE_TOKEN_FIELDS = [
-	"inputTokens",
-	"outputTokens",
-	"totalTokens",
-	"reasoningTokens",
-	"cachedInputTokens"
-];
-const USAGE_ATTRIBUTION_FIELDS = [
-	"id",
-	"src",
-	"model",
-	"name"
-];
-const USAGE_KINDS = ["text", "decision"];
-/**
-* Standard Schema for the reserved `'@agent.usage'` payload. Hand-rolled (no
-* validation-library dependency in core) and deliberately permissive about
-* unknown fields, so a newer runtime adding an attribution field cannot fail
-* an older machine's validation.
-*/
-const agentUsageEventSchema = { "~standard": {
-	version: 1,
-	vendor: "statelyai-agent",
-	validate(value) {
-		const issues = [];
-		if (!value || typeof value !== "object") return { issues: [{ message: "Expected an '@agent.usage' payload object" }] };
-		const event = value;
-		const usage = event.usage;
-		if (!usage || typeof usage !== "object") issues.push({
-			message: "Expected 'usage' to be an object",
-			path: ["usage"]
-		});
-		else for (const field of USAGE_TOKEN_FIELDS) {
-			const token = usage[field];
-			if (token !== void 0 && (typeof token !== "number" || !Number.isFinite(token))) issues.push({
-				message: `Expected a finite number`,
-				path: ["usage", field]
-			});
-		}
-		if (event.kind !== void 0 && !USAGE_KINDS.some((kind) => kind === event.kind)) issues.push({
-			message: `Expected one of ${USAGE_KINDS.join(", ")}`,
-			path: ["kind"]
-		});
-		for (const field of USAGE_ATTRIBUTION_FIELDS) if (event[field] !== void 0 && typeof event[field] !== "string") issues.push({
-			message: "Expected a string",
-			path: [field]
-		});
-		return issues.length > 0 ? { issues } : { value: event };
-	}
-} };
-/**
-* Adds the reserved `'@agent.usage'` schema to an authored event map. A
-* user-declared entry under that key is rejected: the `@agent.*` namespace
-* belongs to the library (same rule as the reserved `agent.*` actor keys), and
-* a custom payload schema would silently disagree with what `runAgent`
-* delivers.
-*/
-function withAgentUsageEventSchema(events) {
-	const declared = events?.[AGENT_USAGE_EVENT_TYPE];
-	if (declared !== void 0 && declared !== agentUsageEventSchema) throw new Error(`setupAgent: event type '${AGENT_USAGE_EVENT_TYPE}' is in the reserved '@agent.' namespace and cannot be declared in 'events' — setupAgent registers it for you with the usage payload schema. Remove it from 'events'; to receive it, declare a transition instead: on: { '${AGENT_USAGE_EVENT_TYPE}': … }.`);
-	return {
-		...events,
-		[AGENT_USAGE_EVENT_TYPE]: agentUsageEventSchema
-	};
-}
-function normalizeEventSchemas(events) {
-	return Object.fromEntries(Object.entries(events).map(([type, schema]) => [type, schema && typeof schema === "object" && "~standard" in schema ? schema : emptyEventSchema]));
-}
-/**
-* Builds a machine's {@link AgentSchemaPack} from a partial schema
-* declaration — only `context` is required; `events`/`input`/`output`/`meta`
-* default to empty/unknown schemas when omitted. Pass the result as
-* `setupAgent({ schemas })`'s `schemas` (or spread the individual fields
-* directly into `setupAgent({ context, events, ... })` — both forms are
-* accepted).
-*/
-function createAgentSchemas(schemas) {
-	return {
-		context: schemas.context,
-		events: normalizeEventSchemas(withAgentUsageEventSchema(schemas.events)),
-		input: schemas.input,
-		output: schemas.output,
-		meta: schemas.meta,
-		emitted: schemas.emitted
-	};
-}
-function mergeContextSchema(base, fields) {
-	return { "~standard": {
-		version: 1,
-		vendor: "statelyai-agent",
-		validate(value) {
-			const baseResult = base["~standard"].validate(value);
-			if (baseResult instanceof Promise) throw new Error("setupAgent: async context schemas are not supported.");
-			if (baseResult.issues) return baseResult;
-			const merged = { ...baseResult.value };
-			const issues = [];
-			for (const [key, fieldSchema] of Object.entries(fields)) {
-				const fieldResult = fieldSchema["~standard"].validate(value[key]);
-				if (fieldResult instanceof Promise) throw new Error("setupAgent: async context schemas are not supported.");
-				if (fieldResult.issues) issues.push(...fieldResult.issues.map((issue) => ({
-					...issue,
-					path: [key, ...issue.path ?? []]
-				})));
-				else merged[key] = fieldResult.value;
-			}
-			return issues.length > 0 ? { issues } : { value: merged };
-		}
-	} };
-}
-function resolveAgentStateSchemas(contextSchema, states) {
-	return Object.fromEntries(Object.entries(states).map(([key, state]) => {
-		if (!state || typeof state !== "object") return [key, state];
-		const children = "states" in state && state.states ? resolveAgentStateSchemas(contextSchema, state.states) : void 0;
-		if ("context" in state && state.context) return [key, {
-			schemas: { context: mergeContextSchema(contextSchema, state.context) },
-			...children ? { states: children } : {}
-		}];
-		return [key, children ? {
-			...state,
-			states: children
-		} : state];
-	}));
-}
-/**
-* Schema-first `setup(...)` for agent machines — the standard entry point
-* for authoring a machine (the blueprint) that this library then runs (via
-* {@link runAgent} or the step helpers) against host-supplied model/decision
-* executors. Context, events, machine input, machine output, and
-* state/transition meta are all standard schemas — no `{} as Type` casts —
-* and are retained on `result.schemas` for runtime validation. Also
-* registers the `agent.generateText`/`agent.streamText`/`agent.userInput`/
-* `agent.decide` builtin actors and lowers `requests`/`actors` into the
-* machine's actor sources. The result is the xstate `setup(...)` object with
-* a wrapped `result.createMachine(...)` plus `result.schemas`/`models`/
-* `requests`/`appendMessages` attached. Also has a
-* `setupAgent.fromConfig(...)` namespace member for building a machine from
-* a serializable {@link AgentWorkflowConfig} instead of this TS API.
-*
-* @example
-* ```ts
-* const schemas = createAgentSchemas({
-*   context: z.object({ topic: z.string(), joke: z.string().nullable() }),
-*   input: z.object({ topic: z.string() }),
-*   output: z.object({ joke: z.string() }),
-* });
-*
-* const agent = setupAgent({
-*   schemas,
-*   actors: { tellJoke },
-* });
-*
-* const jokeMachine = agent.createMachine({
-*   context: ({ input }) => ({ topic: input.topic, joke: null }),
-*   initial: 'telling',
-*   states: {
-*     telling: {
-*       invoke: {
-*         id: 'joke',
-*         src: 'tellJoke',
-*         input: ({ context }) => ({ topic: context.topic }),
-*         onDone: ({ output }) => ({ target: 'done', context: { joke: output } }),
-*       },
-*     },
-*     done: { type: 'final', output: ({ context }) => ({ joke: context.joke ?? '' }) },
-*   },
-* });
-* ```
-*/
-function setupAgent(config) {
-	const schemas = normalizeAgentSchemas(config);
-	const requestActors = createRequestActors(config.requests ?? {});
-	const actors = createAgentActors(config.actors, requestActors);
-	const base = (0, xstate.setup)({
-		schemas: {
-			context: schemas.context,
-			events: schemas.events,
-			input: schemas.input,
-			output: schemas.output,
-			meta: schemas.meta,
-			...schemas.emitted && Object.keys(schemas.emitted).length > 0 ? { emitted: schemas.emitted } : {}
-		},
-		...config.states ? { states: resolveAgentStateSchemas(schemas.context, config.states) } : {},
-		actors,
-		actions: config.actions,
-		guards: config.guards,
-		delays: config.delays
-	});
-	const createBaseMachine = base.createMachine.bind(base);
-	const models = config.models ?? {};
-	const machineOptions = {
-		schemas,
-		actors,
-		models
-	};
-	return Object.assign(base, {
-		createMachine(machineConfig) {
-			assertStateSchemaKeysExist(config.states, machineConfig?.states);
-			const machine = createBaseMachine(withRootOutputFromSingleFinal(machineConfig));
-			require_decision.agentExecutionOptions.set(machine, machineOptions);
-			if (config.isIdle) {
-				const rootConfig = machine.config;
-				if (rootConfig) require_decision.machineIdlePredicates.set(rootConfig, config.isIdle);
-			}
-			return machine;
-		},
-		schemas,
-		models,
-		requests: requestActors,
-		appendMessages
-	});
-}
-function collectFinalStateOutputs(states, outputs = []) {
-	for (const state of Object.values(states ?? {})) {
-		if (state?.type === "final" && state.output !== void 0) outputs.push(state.output);
-		collectFinalStateOutputs(state?.states, outputs);
-	}
-	return outputs;
-}
-function withRootOutputFromSingleFinal(config) {
-	if (!config || typeof config !== "object" || "output" in config || !("states" in config)) return config;
-	const outputs = collectFinalStateOutputs(config.states);
-	return outputs.length === 1 ? {
-		...config,
-		output: outputs[0]
-	} : config;
-}
-(function(_setupAgent) {
-	function fromConfig(config, options) {
-		return setupAgentFromConfig(config, options);
-	}
-	_setupAgent.fromConfig = fromConfig;
-})(setupAgent || (setupAgent = {}));
-/**
-* The schema pack a machine was built with — `setupAgent(...).createMachine`
-* and `setupAgent.fromConfig(...)` both register one, so hosts can read a
-* machine's input/event schemas at runtime without knowing how it was
-* authored. Returns `undefined` for machines not built by either (a plain
-* xstate `createMachine`/`setup` machine).
-*
-* Registration is keyed on the machine object, so a machine returned by
-* `machine.provide(...)` carries no pack — read it from the machine the setup
-* returned.
-*/
-function getAgentSchemas(machine) {
-	return require_decision.agentExecutionOptions.get(machine)?.schemas;
-}
-/** Builds one TextLogic actor per `setupAgent({ requests })` entry. @internal */
-function createRequestActors(requests) {
-	return Object.fromEntries(Object.entries(requests).map(([key, request]) => {
-		return [key, require_decision.createTextLogic({
-			...request,
-			name: key,
-			mode: request.mode ?? "generate"
-		})];
-	}));
-}
-function normalizeAgentSchemas(config) {
-	if ("schemas" in config && config.schemas) return {
-		...config.schemas,
-		events: normalizeEventSchemas(withAgentUsageEventSchema(config.schemas.events))
-	};
-	const loose = config;
-	return createAgentSchemas({
-		...loose,
-		context: loose.context
-	});
-}
-/**
-* Runtime guard: every key of the `setupAgent({ states })` narrowing map must
-* name a real state node in the machine config. A typo'd key is otherwise a
-* silent no-op — the narrowing simply never applies — so fail fast at
-* `createMachine` time. Walks nested `states` maps in parallel with the
-* machine config, since narrowing entries nest the same way.
-*/
-function assertStateSchemaKeysExist(stateSchemas, machineStates, path = []) {
-	if (!stateSchemas) return;
-	for (const [key, stateSchema] of Object.entries(stateSchemas)) {
-		const machineState = machineStates?.[key];
-		if (!machineState || typeof machineState !== "object") {
-			const validKeys = Object.keys(machineStates ?? {});
-			const parent = path.length > 0 ? ` of state '${path.join(".")}'` : "";
-			throw new Error(`setupAgent: 'states' key '${[...path, key].join(".")}' does not name a state in the machine config, so its context narrowing would silently never apply. Valid child states${parent}: ${validKeys.join(", ") || "(none)"}. Fix the key to match a state in createMachine({ states }), or remove it from setupAgent({ states }).`);
-		}
-		if (stateSchema && typeof stateSchema === "object" && "states" in stateSchema && stateSchema.states) assertStateSchemaKeysExist(stateSchema.states, machineState.states, [...path, key]);
-	}
-}
-const RESERVED_AGENT_ACTOR_KEYS = [
-	...Object.keys(require_decision.builtinTextActors),
-	require_decision.USER_INPUT_ACTOR,
-	require_decision.DECIDE_ACTOR
-];
-/**
-* The whole `agent.` actor-source namespace is reserved for the library, not
-* just the shipped builtins: a key starting with this prefix is rejected at
-* setup time so a future builtin can never collide with (or be shadowed by) a
-* user source. Name your own sources without it.
-*/
-const RESERVED_AGENT_KEY_PREFIX = "agent.";
-/**
-* Runtime guards over the user-supplied `actors`/`requests` keys, in one walk
-* of both groups:
-*
-* 1. A key in the reserved `agent.` namespace is rejected — every key with
-*    that prefix, not only today's builtins. Without this, the builtins-first
-*    spread in {@link createAgentActors} lets such a key overwrite the builtin
-*    (`agent.decide`, …) silently, and a builtin added later would start
-*    colliding with user code. Deliberate override of a builtin is still
-*    possible after the machine is created, via
-*    `machine.provide({ actors: { 'agent.decide': ... } })`.
-* 2. A key appearing in BOTH groups is almost certainly a mistake (whichever
-*    spread applies last would silently win) — fail fast with a clear message
-*    rather than let one implementation shadow another.
-*/
-function assertActorKeys(actors, requests) {
-	const seenIn = /* @__PURE__ */ new Map();
-	const groups = [["actors", actors], ["requests", requests]];
-	for (const [groupName, group] of groups) for (const key of Object.keys(group ?? {})) {
-		if (RESERVED_AGENT_ACTOR_KEYS.some((reserved) => reserved === key)) throw new Error(`setupAgent: '${groupName}' key '${key}' is a reserved builtin agent actor and cannot be redefined here (it would silently clobber the builtin). Reserved keys: ${RESERVED_AGENT_ACTOR_KEYS.join(", ")}. To deliberately override a builtin, do it on the created machine instead: machine.provide({ actors: { '${key}': ... } }).`);
-		if (key.startsWith(RESERVED_AGENT_KEY_PREFIX)) throw new Error(`setupAgent: '${groupName}' key '${key}' uses the reserved '${RESERVED_AGENT_KEY_PREFIX}' namespace, which belongs to the library (${RESERVED_AGENT_ACTOR_KEYS.join(", ")}, and anything added later). Rename it without the '${RESERVED_AGENT_KEY_PREFIX}' prefix.`);
-		const existingGroup = seenIn.get(key);
-		if (existingGroup) throw new Error(`setupAgent: key '${key}' is defined in both '${existingGroup}' and '${groupName}'. Each actor source key must be unique across 'actors' and 'requests'.`);
-		seenIn.set(key, groupName);
-	}
-}
-function createAgentActors(actors, requestActors) {
-	assertActorKeys(actors, requestActors);
-	return {
-		...require_decision.builtinTextActors,
-		[require_decision.USER_INPUT_ACTOR]: require_decision.userInputActor,
-		[require_decision.DECIDE_ACTOR]: require_decision.createDecideActor(),
-		...actors,
-		...requestActors
-	};
-}
-//#endregion
-Object.defineProperty(exports, "AGENT_INIT_EVENT_TYPE", {
-	enumerable: true,
-	get: function() {
-		return AGENT_INIT_EVENT_TYPE;
-	}
-});
-Object.defineProperty(exports, "AGENT_USAGE_EVENT_TYPE", {
-	enumerable: true,
-	get: function() {
-		return AGENT_USAGE_EVENT_TYPE;
-	}
-});
-Object.defineProperty(exports, "AgentReplayDivergenceError", {
-	enumerable: true,
-	get: function() {
-		return AgentReplayDivergenceError;
-	}
-});
-Object.defineProperty(exports, "AgentReplayMachineMismatchError", {
-	enumerable: true,
-	get: function() {
-		return AgentReplayMachineMismatchError;
-	}
-});
-Object.defineProperty(exports, "appendMessages", {
-	enumerable: true,
-	get: function() {
-		return appendMessages;
-	}
-});
-Object.defineProperty(exports, "createAgentSchemas", {
-	enumerable: true,
-	get: function() {
-		return createAgentSchemas;
-	}
-});
-Object.defineProperty(exports, "createReplayEntry", {
-	enumerable: true,
-	get: function() {
-		return createReplayEntry;
-	}
-});
-Object.defineProperty(exports, "diffEventLogs", {
-	enumerable: true,
-	get: function() {
-		return diffEventLogs;
-	}
-});
-Object.defineProperty(exports, "executeAgentRequest", {
-	enumerable: true,
-	get: function() {
-		return executeAgentRequest;
-	}
-});
-Object.defineProperty(exports, "getAgentEffects", {
-	enumerable: true,
-	get: function() {
-		return getAgentEffects;
-	}
-});
-Object.defineProperty(exports, "getAgentSchemas", {
-	enumerable: true,
-	get: function() {
-		return getAgentSchemas;
-	}
-});
-Object.defineProperty(exports, "getInvokeEffectMetadata", {
-	enumerable: true,
-	get: function() {
-		return getInvokeEffectMetadata;
-	}
-});
-Object.defineProperty(exports, "initEntry", {
-	enumerable: true,
-	get: function() {
-		return initEntry;
-	}
-});
-Object.defineProperty(exports, "initialAgentStep", {
-	enumerable: true,
-	get: function() {
-		return initialAgentStep;
-	}
-});
-Object.defineProperty(exports, "messagesSchema", {
-	enumerable: true,
-	get: function() {
-		return messagesSchema;
-	}
-});
-Object.defineProperty(exports, "replay", {
-	enumerable: true,
-	get: function() {
-		return replay;
-	}
-});
-Object.defineProperty(exports, "resolveAgentStep", {
-	enumerable: true,
-	get: function() {
-		return resolveAgentStep;
-	}
-});
-Object.defineProperty(exports, "setupAgent", {
-	enumerable: true,
-	get: function() {
-		return setupAgent;
-	}
-});
-Object.defineProperty(exports, "transitionAgentStep", {
-	enumerable: true,
-	get: function() {
-		return transitionAgentStep;
-	}
-});
-Object.defineProperty(exports, "validateReplayEntries", {
-	enumerable: true,
-	get: function() {
-		return validateReplayEntries;
-	}
-});