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

package/dist/decision-Cv6SfNWl.cjs

@@ -1,1856 +0,0 @@
-require("./validate.cjs");
-let xstate = require("xstate");
-//#region src/errors.ts
-/**
-* Base class for every error this package throws. Carries a stable, kebab-case
-* `code` so hosts can branch on the failure without `instanceof` (useful across
-* bundle/realm boundaries and after serialization).
-*
-* @example
-* ```ts
-* catch (error) {
-*   if (error instanceof AgentError && error.code === 'agent-idle') { ... }
-* }
-* ```
-*/
-var AgentError = class extends Error {
-	code;
-	constructor(code, message, options) {
-		super(message, options);
-		this.name = "AgentError";
-		this.code = code;
-	}
-};
-/**
-* A model call ran out of output tokens before it produced anything usable.
-* Core never throws this: it is the adapter's signal that a `'length'` finish
-* reason left nothing to return — a structured request whose envelope never
-* closed, say. A text request that WAS cut off still returns its text, with
-* `finishReason: 'length'`.
-*
-* The code is `'truncated'`, so an invoke's `onError` can branch on it without
-* `instanceof`:
-*
-* @example
-* ```ts
-* onError: [
-*   { guard: ({ event }) => event.error.code === 'truncated', target: 'retryShorter' },
-*   { target: 'failed' },
-* ]
-* ```
-*/
-var AgentTruncatedError = class extends AgentError {
-	/** The request that was cut off — `AgentTextRequest.name`. */
-	requestName;
-	/** The durable invoke id of the request, when the host knows it. */
-	requestId;
-	/** Whatever the model did produce before it hit the limit, if anything. */
-	partialOutput;
-	constructor(message, options) {
-		super("truncated", message, { cause: options.cause });
-		this.name = "AgentTruncatedError";
-		this.requestName = options.requestName;
-		if (options.requestId !== void 0) this.requestId = options.requestId;
-		if (options.partialOutput !== void 0) this.partialOutput = options.partialOutput;
-	}
-};
-//#endregion
-//#region src/messages.ts
-/** Ordinary machine event emitted after a request returns framework-native messages. */
-const AGENT_MESSAGES_EVENT_TYPE = "agent.messages";
-/** Runtime schema for the framework-neutral `agent.messages` envelope. */
-const agentMessagesEventSchema = { "~standard": {
-	version: 1,
-	vendor: "statelyai-agent",
-	validate(value) {
-		if (!value || typeof value !== "object") return { issues: [{ message: "Expected an 'agent.messages' payload object" }] };
-		const event = value;
-		const issues = [];
-		if (typeof event.request !== "string") issues.push({
-			message: "Expected a string",
-			path: ["request"]
-		});
-		if (typeof event.actorId !== "string") issues.push({
-			message: "Expected a string",
-			path: ["actorId"]
-		});
-		if (!Array.isArray(event.messages)) issues.push({
-			message: "Expected an array",
-			path: ["messages"]
-		});
-		return issues.length > 0 ? { issues } : { value: event };
-	}
-} };
-function appendMessages(options) {
-	const key = options?.key ?? "messages";
-	return (({ context, event }) => {
-		const current = context[key];
-		const messages = event.messages;
-		return { context: { [key]: [...Array.isArray(current) ? current : [], ...messages ?? []] } };
-	});
-}
-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/utils.ts
-/** Returns the human-readable text carried by a message, ignoring non-text parts. */
-function getMessageText(message) {
-	if (typeof message.content === "string") return message.content;
-	const text = [];
-	for (const part of message.content) {
-		if (part.type === "text") {
-			text.push(part.text);
-			continue;
-		}
-		if (part.type !== "tool-result") continue;
-		if (part.output.type === "text" || part.output.type === "error-text") text.push(part.output.value);
-		else if (part.output.type === "content") text.push(...part.output.value.flatMap((item) => item.type === "text" ? [item.text] : []));
-	}
-	return text.join("\n");
-}
-/**
-* Walks a context value and returns the dot-paths of the first few values that
-* would NOT survive a JSON persist/resume round-trip (persist with XState's
-* `actor.getPersistedSnapshot()`, resume with `createActor(machine, { snapshot })`):
-* `Date`, `Map`, `Set`, `RegExp`, functions, `undefined`, `bigint`, class
-* instances (non-plain objects), and circular references. Plain objects,
-* arrays, and JSON primitives are walked/allowed. Returns `[]` for a
-* fully-JSON-safe value. Cheap and bounded (stops after `limit` findings) —
-* intended for a dev-only warning at the moment persistence matters.
-*/
-function findNonSerializableContextPaths(context, limit = 5) {
-	const paths = [];
-	const seen = /* @__PURE__ */ new WeakSet();
-	const walk = (value, path) => {
-		if (paths.length >= limit) return;
-		if (value === null) return;
-		const type = typeof value;
-		if (type === "string" || type === "number" || type === "boolean") return;
-		if (type === "undefined" || type === "bigint" || type === "function" || type === "symbol") {
-			paths.push(`${path} (${type})`);
-			return;
-		}
-		const obj = value;
-		if (seen.has(obj)) {
-			paths.push(`${path} (circular)`);
-			return;
-		}
-		if (Array.isArray(value)) {
-			seen.add(obj);
-			value.forEach((item, index) => walk(item, `${path}[${index}]`));
-			seen.delete(obj);
-			return;
-		}
-		const proto = Object.getPrototypeOf(value);
-		if (proto === Object.prototype || proto === null) {
-			seen.add(obj);
-			for (const [key, item] of Object.entries(value)) walk(item, `${path}.${key}`);
-			seen.delete(obj);
-			return;
-		}
-		const ctorName = value.constructor?.name ?? "object";
-		paths.push(`${path} (${ctorName})`);
-	};
-	walk(context, "context");
-	return paths;
-}
-/**
-* A stable, dependency-free structural fingerprint of a machine — a short hex
-* `djb2` hash over its **structural** config only: state ids/nesting, transition
-* event types and targets, invoke `src`s, `initial`, and any other serializable
-* config fields. Function values (context/output builders, prompts, inline
-* guards/actions) are excluded entirely, so two machines that differ only in
-* their prompts or executors hash identically; adding/removing/retargeting a
-* state or transition changes the hash.
-*
-* Used by {@link runAgent} to stamp settled snapshots with a `version` and to
-* detect a structurally-edited machine on resume. It is a change detector, not
-* a cryptographic digest — collisions are possible but unlikely for real
-* configs. Declare `createMachine({ version })` to pin an explicit version instead.
-*/
-function getMachineStructuralHash(machine) {
-	return djb2Hex(stableStructuralString(machine.config));
-}
-/**
-* The version a machine is stamped with everywhere: an explicitly declared
-* `createMachine({ version })` when present, else its
-* {@link getMachineStructuralHash}. Single source of truth so `runAgent`,
-* `provideExecutors`/`traceTransitions` trace envelopes agree.
-* @internal
-*/
-function resolveMachineVersion(machine) {
-	return machine.version ?? getMachineStructuralHash(machine);
-}
-function stableStructuralString(value, seen = /* @__PURE__ */ new WeakSet()) {
-	if (value === null) return "null";
-	const type = typeof value;
-	if (type === "function" || type === "undefined" || type === "symbol") return "";
-	if (type === "string") return JSON.stringify(value);
-	if (type === "number" || type === "boolean") return String(value);
-	if (type === "bigint") return `${value}n`;
-	const obj = value;
-	if (seen.has(obj)) return "\"[circular]\"";
-	seen.add(obj);
-	let out;
-	if (Array.isArray(value)) out = `[${value.map((item) => stableStructuralString(item, seen)).join(",")}]`;
-	else {
-		const parts = [];
-		for (const key of Object.keys(obj).sort()) {
-			const child = obj[key];
-			const childType = typeof child;
-			if (childType === "function" || childType === "undefined" || childType === "symbol") continue;
-			parts.push(`${JSON.stringify(key)}:${stableStructuralString(child, seen)}`);
-		}
-		out = `{${parts.join(",")}}`;
-	}
-	seen.delete(obj);
-	return out;
-}
-/**
-* djb2 → unsigned 32-bit → 8-char hex. No dependencies. A change detector, not
-* a cryptographic digest.
-*
-* @internal
-*/
-function djb2Hex(input) {
-	let hash = 5381;
-	for (let i = 0; i < input.length; i++) hash = (hash << 5) + hash + input.charCodeAt(i) | 0;
-	return (hash >>> 0).toString(16).padStart(8, "0");
-}
-/** Builds a {@link UserMessage} from a string or multimodal content parts. */
-function userMessage(content) {
-	return {
-		role: "user",
-		content
-	};
-}
-/** Builds an {@link AssistantMessage} from a string or content parts (text, files, tool calls/results). */
-function assistantMessage(content) {
-	return {
-		role: "assistant",
-		content
-	};
-}
-/** Builds a {@link SystemMessage}. */
-function systemMessage(content) {
-	return {
-		role: "system",
-		content
-	};
-}
-/** Builds a {@link ToolMessage} from one or more tool-result parts. */
-function toolMessage(content) {
-	return {
-		role: "tool",
-		content
-	};
-}
-/**
-* Returns the merged `meta` of a snapshot's active state(s) — the typed
-* replacement for the `Object.values(snapshot.getMeta())[0]` dance.
-*
-* `snapshot.getMeta()` is keyed by state id; a leaf machine has one active
-* state, but parallel/nested machines can have several. This shallow-merges
-* every active state's meta into one object and returns `{}` when no active
-* state declares meta.
-*
-* Merge order is fixed and does not depend on XState's internal node order:
-* entries are sorted by structural depth (the state node's distance from the
-* root, regardless of custom `id` strings), then by state id lexicographically,
-* and merged in that order. So a deeper state's key wins over an ancestor's,
-* and between equal-depth parallel siblings the later state id alphabetically
-* wins.
-*
-* The return type is recovered from the snapshot's own `getMeta()` type, so a
-* schema-typed machine (`setupAgent({ meta })`) yields the meta schema's
-* output type. Pass an explicit `TMeta` to override when the snapshot is
-* untyped (e.g. `AnyMachineSnapshot`).
-*
-* @example HITL: read the current state's interaction protocol off an idle
-* snapshot to render for a human.
-* ```ts
-* const { interaction } = getStateMeta(result.snapshot);
-* ```
-*/
-function getStateMeta(snapshot) {
-	const nodes = snapshot.nodes;
-	const depthById = new Map(nodes?.map((node) => [node.id, node.path.length]));
-	const depth = (id) => depthById.get(id) ?? id.split(".").length;
-	const entries = Object.entries(snapshot.getMeta()).filter((entry) => entry[1] != null).sort(([a], [b]) => depth(a) - depth(b) || (a < b ? -1 : a > b ? 1 : 0));
-	return Object.assign({}, ...entries.map(([, meta]) => meta));
-}
-/**
-* Renders a snapshot's state value as one deterministic string, so a log line,
-* a progress field, or a test assertion reads the same on every run.
-*
-* - An atomic state is its own name: `'writing'`.
-* - A nested state joins with dots: `{ review: { editing: 'draft' } }` →
-*   `'review.editing.draft'`.
-* - A parallel state brackets its regions, sorted by region name, so key order
-*   never leaks into the string: `{ p: { left: 'x', right: { a: 'b' } } }` →
-*   `'p:{left.x,right.a.b}'`.
-*
-* Prefer this over `String(snapshot.value)`, which renders every non-atomic
-* value as `[object Object]`.
-*
-* @example
-* ```ts
-* onTransition: (snapshot) => console.log(getStatePath(snapshot));
-* ```
-*/
-function getStatePath(snapshot) {
-	return serializeStateValue(typeof snapshot === "object" && snapshot !== null && "value" in snapshot && ("status" in snapshot || typeof snapshot.matches === "function") ? snapshot.value : snapshot);
-}
-function serializeStateValue(value) {
-	if (typeof value === "string") return value;
-	const entries = Object.entries(value).map(([key, child]) => {
-		const rendered = serializeStateValue(child);
-		if (!rendered) return [key, key];
-		return [key, `${key}${rendered.startsWith("{") ? ":" : "."}${rendered}`];
-	}).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
-	if (entries.length === 0) return "";
-	if (entries.length === 1) return entries[0][1];
-	return `{${entries.map(([, rendered]) => rendered).join(",")}}`;
-}
-/**
-* Structural guard for a {@link StandardSchemaV1}: `true` when `value` carries
-* the `~standard` marker. Used to tell an already-schema'd tool `inputSchema`
-* (a Zod/Valibot/… schema) apart from an SDK-specific schema wrapper that core
-* can't read directly — see the `ai-sdk` tool pass-through.
-*/
-function isStandardSchema(value) {
-	return typeof value === "object" && value !== null && "~standard" in value;
-}
-/**
-* Pulls the JSON Schema off a {@link StandardSchemaV1} via its optional
-* `~standard.jsonSchema.input()` extension (implemented by e.g. Zod v4's
-* `z.toJSONSchema`), awaiting it when the producer is async. Returns
-* `undefined` when the schema doesn't expose the extension. Use this to build
-* a provider request's `response_format`/tool `parameters` from a schema.
-*/
-async function getJsonSchema(schema) {
-	const jsonSchemaFn = schema?.["~standard"].jsonSchema?.input;
-	if (!jsonSchemaFn) return;
-	const result = jsonSchemaFn();
-	return result instanceof Promise ? await result : result;
-}
-/**
-* Synchronous variant of {@link getJsonSchema}, for call sites that can't
-* await (building tool/event descriptors inline). An async JSON Schema
-* producer is treated as absent (returns `undefined`) — in practice Zod's
-* `z.toJSONSchema` resolves synchronously.
-*/
-function getJsonSchemaSync(schema) {
-	const jsonSchemaFn = schema?.["~standard"].jsonSchema?.input;
-	if (!jsonSchemaFn) return;
-	const result = jsonSchemaFn();
-	return result instanceof Promise ? void 0 : result;
-}
-/**
-* Validates `value` against a {@link StandardSchemaV1}, synchronously.
-* Throws if the schema's `validate` returns a `Promise` (async validation is
-* not supported anywhere in this library) or if validation reports issues —
-* in which case the thrown `Error.message` joins every issue message with
-* `', '`.
-*/
-function validateSchemaSync(schema, value) {
-	const result = schema["~standard"].validate(value);
-	if (result instanceof Promise) throw new Error("Async schema validation is not supported.");
-	if (result.issues) throw new Error(result.issues.map((issue) => issue.message).join(", "));
-	return result.value;
-}
-//#endregion
-//#region src/internal/registry.ts
-/** Non-enumerable hook an optional adapter can attach to a model registry. */
-const DEFAULT_AGENT_EXECUTORS = Symbol.for("@statelyai/agent.defaultExecutors");
-/**
-* Registered execution options, keyed on BOTH the machine object and its root
-* `config` object. `config` is shared by reference across `machine.provide(...)`
-* (unlike the machine itself), so the `config` key is what lets a machine
-* rebound by `runAgent` — or by any host `.provide(...)` — still resolve the
-* schemas/actors `setupAgent` registered. Always write through
-* {@link setAgentExecutionOptions} and read through
-* {@link getAgentExecutionOptions}.
-*/
-const agentExecutionOptions = /* @__PURE__ */ new WeakMap();
-/** The root `config` object a machine shares with every `.provide(...)` of itself. */
-function machineConfigKey(machine) {
-	const config = machine?.config;
-	return config && typeof config === "object" ? config : void 0;
-}
-/** Registers `options` for `machine` and for every `.provide(...)` of it. */
-function setAgentExecutionOptions(machine, options) {
-	if (!machine || typeof machine !== "object") return;
-	agentExecutionOptions.set(machine, options);
-	const config = machineConfigKey(machine);
-	if (config) agentExecutionOptions.set(config, options);
-}
-/**
-* Reads the options registered for `machine`, falling back to the root `config`
-* key so a `.provide(...)`-rebound machine (e.g. the one behind a `runAgent`
-* result snapshot) resolves the same pack.
-*/
-function getAgentExecutionOptions(machine) {
-	if (!machine || typeof machine !== "object") return void 0;
-	const direct = agentExecutionOptions.get(machine);
-	if (direct) return direct;
-	const config = machineConfigKey(machine);
-	return config ? agentExecutionOptions.get(config) : void 0;
-}
-/**
-* Machine-carried wait-state predicates, keyed on the machine's root `config`
-* object. `config` is shared by reference across `machine.provide(...)` (unlike
-* the machine object itself), so a predicate registered here travels with the
-* machine through `.provide` — which is why it is keyed on `config`, not the
-* machine. Set by `setupAgent({ isIdle })` in `createMachine` and by
-* `setupAgent.fromConfig` (its `isIdle` option or the config's
-* `idleTags`), read by `runAgent` before its structural default.
-*/
-const machineIdlePredicates = /* @__PURE__ */ new WeakMap();
-/** Reads the {@link machineIdlePredicates} predicate carried by `machine` (via its root `config`), if any. */
-function getMachineIdlePredicate(machine) {
-	const config = machine.config;
-	return config ? machineIdlePredicates.get(config) : void 0;
-}
-const unboundPlaceholderLogics = /* @__PURE__ */ new WeakSet();
-/** Text/decision logics created WITH their own executor (withExecutor or the
-* factory's second arg) — these are runnable as-is, so runAgent's bind check
-* must not reject them as direct-object invoke srcs. */
-const executorBoundLogics = /* @__PURE__ */ new WeakSet();
-function missingActor(src) {
-	const logic = (0, xstate.createAsyncLogic)({ run: async () => {
-		throw new Error(`'${src}' has no host execution. Provide an implementation with machine.provide({ actors: { '${src}': ... } }).`);
-	} });
-	unboundPlaceholderLogics.add(logic);
-	return logic;
-}
-function isUnboundPlaceholder(logic) {
-	return !!logic && typeof logic === "object" && unboundPlaceholderLogics.has(logic);
-}
-function getRegisteredAgentExecutionOptions(machine, options) {
-	return {
-		...getAgentExecutionOptions(machine),
-		...options
-	};
-}
-//#endregion
-//#region src/text-logic.ts
-const USER_INPUT_ACTOR = "agent.userInput";
-const GENERATE_TEXT_ACTOR = "agent.generateText";
-const STREAM_TEXT_ACTOR = "agent.streamText";
-const DECIDE_ACTOR = "agent.decide";
-/**
-* Splits a portable `"provider/model-id"` model ref (the convention JSON
-* workflows and registry-less hosts use, e.g. `"openai/gpt-5.4-mini"`) into
-* its parts. A ref with no `/` has no provider — `modelId` is the whole ref.
-* The standard building block for a host's `resolveModel`:
-*
-* @example
-* ```ts
-* const resolveModel = (ref: string) => openai(parseModelRef(ref).modelId);
-* ```
-*/
-function parseModelRef(modelRef) {
-	const slash = modelRef.indexOf("/");
-	return slash === -1 ? {
-		provider: void 0,
-		modelId: modelRef
-	} : {
-		provider: modelRef.slice(0, slash),
-		modelId: modelRef.slice(slash + 1)
-	};
-}
-const AGENT_FINISH_REASONS = new Set([
-	"stop",
-	"length",
-	"tool-calls",
-	"content-filter",
-	"other"
-]);
-/**
-* Reads a settled call's {@link AgentFinishReason} off a RAW executor result's
-* `finishReason` field — the finish-reason sibling of {@link getCallUsage},
-* applied by `runAgent` before it puts the reason on the `request.end` trace.
-* A provider's `'error'` normalizes to `'other'`; anything else the union does
-* not name (an un-normalized provider string, a missing field) returns
-* `undefined`.
-*/
-function getCallFinishReason(raw) {
-	const value = raw?.finishReason;
-	if (typeof value !== "string") return;
-	if (value === "error") return "other";
-	return AGENT_FINISH_REASONS.has(value) ? value : void 0;
-}
-/** The token fields {@link AgentUsage} aggregates. @internal */
-const AGENT_USAGE_TOKEN_FIELDS = [
-	"inputTokens",
-	"outputTokens",
-	"totalTokens",
-	"reasoningTokens",
-	"cachedInputTokens"
-];
-/**
-* Reads a settled call's per-call {@link AgentCallUsage} off a RAW executor
-* result's `usage` field, keeping only finite numbers — the same normalization
-* `runAgent` applies before it delivers `'@agent.usage'`. Returns `undefined`
-* when the result reports no usage at all. Works for our `{ output, usage }`
-* envelope, for a raw Vercel AI SDK result (its `LanguageModelUsage` carries
-* the same flat field names), and for any custom executor that follows the
-* shape.
-*
-* The seam for the step-loop path, where the host holds the raw result itself:
-*
-* ```ts
-* const { output, raw } = await executeAgentRequest(effect, executors);
-* const usage = getCallUsage(raw);
-* if (usage) append({ type: AGENT_USAGE_EVENT_TYPE, usage }); // journal + transition, like any event
-* append(effect.toDoneEvent(output));
-* ```
-*
-* See "Token usage on this path" in docs/steps.md for the full loop.
-*/
-function getCallUsage(raw) {
-	const usage = raw?.usage;
-	if (!usage || typeof usage !== "object") return;
-	let out;
-	for (const field of AGENT_USAGE_TOKEN_FIELDS) {
-		const value = usage[field];
-		if (typeof value === "number" && Number.isFinite(value)) (out ??= {})[field] = value;
-	}
-	return out;
-}
-function textRequestSourceIssue(request) {
-	const hasPrompt = typeof request.prompt === "string" && request.prompt.length > 0;
-	const hasMessages = Array.isArray(request.messages) && request.messages.length > 0;
-	const label = request.name ? ` '${request.name}'` : "";
-	if (hasPrompt && hasMessages) return `Agent text request${label} has both a non-empty \`prompt\` and \`messages\` — provide exactly one so the model has a single input source.`;
-	if (!hasPrompt && !hasMessages) return `Agent text request${label} has neither a non-empty \`prompt\` nor \`messages\` — provide at least one so the model has something to respond to.`;
-}
-const agentTextInputSchema = { "~standard": {
-	version: 1,
-	vendor: "statelyai-agent",
-	validate(value) {
-		if (!value || typeof value !== "object") return { issues: [{ message: "Expected agent text input object" }] };
-		const request = value;
-		if (typeof request.model !== "string") return { issues: [{ message: "Expected agent text input with a string `model`" }] };
-		const issue = textRequestSourceIssue(request);
-		if (issue) return { issues: [{ message: issue }] };
-		return { value: request };
-	}
-} };
-const passthroughSchema = { "~standard": {
-	version: 1,
-	vendor: "statelyai-agent",
-	validate(value) {
-		return { value };
-	}
-} };
-const unknownOutputSchema = passthroughSchema;
-const stringOutputSchema = { "~standard": {
-	version: 1,
-	vendor: "statelyai-agent",
-	validate(value) {
-		return typeof value === "string" ? { value } : { issues: [{ message: "Expected string output" }] };
-	}
-} };
-const noInputSchema = passthroughSchema;
-function createBuiltinTextActor(src, mode, outputSchema) {
-	const logic = (0, xstate.createAsyncLogic)({ run: async () => {
-		throw new Error(`'${src}' has no host execution. Provide an implementation with machine.provide({ actors: { '${src}': ... } }) or execute the returned agent request with executeAgentRequest(...).`);
-	} });
-	return Object.assign(logic, {
-		kind: "statelyai.textLogic",
-		mode,
-		schemas: {
-			input: agentTextInputSchema,
-			output: outputSchema
-		},
-		request(input) {
-			return validateSchemaSync(agentTextInputSchema, input);
-		},
-		async execute(input, executors) {
-			const { output } = await executeAgentTextRequest(mode, src, validateSchemaSync(agentTextInputSchema, input), executors);
-			return validateSchemaSync(outputSchema, output);
-		},
-		withExecutor(execute) {
-			return createTextLogic({
-				mode,
-				schemas: {
-					input: agentTextInputSchema,
-					output: outputSchema
-				},
-				name: ({ input }) => input.name,
-				model: ({ input }) => input.model,
-				system: ({ input }) => input.system,
-				prompt: ({ input }) => input.prompt,
-				messages: ({ input }) => input.messages,
-				tools: ({ input }) => input.tools,
-				toolChoice: ({ input }) => input.toolChoice,
-				includeReasoning: ({ input }) => input.includeReasoning,
-				temperature: ({ input }) => input.temperature,
-				maxOutputTokens: ({ input }) => input.maxOutputTokens,
-				topP: ({ input }) => input.topP,
-				topK: ({ input }) => input.topK,
-				seed: ({ input }) => input.seed,
-				stopSequences: ({ input }) => input.stopSequences,
-				maxSteps: ({ input }) => input.maxSteps,
-				metadata: ({ input }) => input.metadata
-			}, execute);
-		}
-	});
-}
-/** The unbound `agent.generateText`/`agent.streamText` builtins registered by setupAgent. @internal */
-const builtinTextActors = {
-	[GENERATE_TEXT_ACTOR]: createBuiltinTextActor(GENERATE_TEXT_ACTOR, "generate", unknownOutputSchema),
-	[STREAM_TEXT_ACTOR]: createBuiltinTextActor(STREAM_TEXT_ACTOR, "stream", stringOutputSchema)
-};
-/** The unbound `agent.userInput` builtin registered by setupAgent (an unbound-placeholder logic — see internal/registry.ts). Output is `string` — what the human typed. @internal */
-const userInputActor = (0, xstate.createAsyncLogic)({ run: async () => {
-	throw new Error(`'${USER_INPUT_ACTOR}' has no host execution. Provide an implementation with machine.provide({ actors: { '${USER_INPUT_ACTOR}': ... } }).`);
-} });
-unboundPlaceholderLogics.add(userInputActor);
-/**
-* Validates a raw model/executor output against `schema`, returning the
-* parsed value. Thin wrapper over {@link validateSchemaSync} for parsing a
-* text request's structured output outside of `TextLogic.execute`/
-* `executeAgentRequest` (e.g. a custom host loop).
-*/
-function parseOutput(schema, output) {
-	return validateSchemaSync(schema, output);
-}
-/** Resolves a `ResolveTextLogicValue` (calls it if it's a function, else returns it as-is). @internal */
-function resolveTextLogicValue(value, args) {
-	return typeof value === "function" ? value(args) : value;
-}
-/**
-* Creates reusable, standalone {@link TextLogic}: an actor that, when run,
-* resolves typed input to typed output via a model call. Register the
-* result under `actors:` and invoke it by name (equivalent to what
-* `setupAgent({ requests })` builds internally for each request entry). Pass
-* `execute` here, or bind it later with `.withExecutor(...)`, a runtime
-* adapter's `machine.provide(...)`, or `runAgent`'s `generateText`/
-* `streamText` options.
-*
-* @example
-* ```ts
-* export const tellJoke = createTextLogic({
-*   mode: 'stream',
-*   schemas: { input: z.object({ topic: z.string() }), output: z.string() },
-*   model: 'openai/gpt-5.4-mini',
-*   system: 'You tell short, punchy jokes.',
-*   prompt: ({ input }) => `Tell a joke about ${input.topic}.`,
-* });
-* ```
-*/
-function createTextLogic(config, execute) {
-	const schemas = {
-		input: config.schemas?.input ?? noInputSchema,
-		output: config.schemas?.output ?? stringOutputSchema
-	};
-	const request = (input) => {
-		const parsedInput = validateSchemaSync(schemas.input, input);
-		const args = { input: parsedInput };
-		const name = resolveTextLogicValue(config.name, args);
-		const prompt = resolveTextLogicValue(config.prompt, args);
-		const messages = resolveTextLogicValue(config.messages, args);
-		const sourceIssue = textRequestSourceIssue({
-			name,
-			prompt,
-			messages
-		});
-		if (sourceIssue) throw new Error(sourceIssue);
-		return {
-			name,
-			input: parsedInput,
-			model: resolveTextLogicValue(config.model, args),
-			system: resolveTextLogicValue(config.system, args),
-			prompt,
-			messages,
-			tools: resolveTextLogicValue(config.tools, args),
-			toolChoice: resolveTextLogicValue(config.toolChoice, args),
-			outputSchema: schemas.output,
-			includeReasoning: resolveTextLogicValue(config.includeReasoning, args),
-			temperature: resolveTextLogicValue(config.temperature, args),
-			maxOutputTokens: resolveTextLogicValue(config.maxOutputTokens, args),
-			topP: resolveTextLogicValue(config.topP, args),
-			topK: resolveTextLogicValue(config.topK, args),
-			seed: resolveTextLogicValue(config.seed, args),
-			stopSequences: resolveTextLogicValue(config.stopSequences, args),
-			maxSteps: resolveTextLogicValue(config.maxSteps, args),
-			metadata: resolveTextLogicValue(config.metadata, args)
-		};
-	};
-	const logic = (0, xstate.createAsyncLogic)({ run: async ({ input, signal, system, self }, enq) => {
-		const resolvedRequest = request(input);
-		if (!execute) throw new Error("Text logic has no host execution. Pass an executor as the second argument to createTextLogic(...), provide a runtime adapter, or bind it through runAgent/provideExecutors, or execute the XState effect in your host.");
-		const result = await execute({
-			input,
-			request: resolvedRequest,
-			signal,
-			system,
-			self,
-			emit: enq.emit
-		});
-		const selfId = self?.id;
-		const output = await normalizeGeneratorResult(result, typeof selfId === "string" ? selfId : "text logic", { request: resolvedRequest });
-		return validateSchemaSync(schemas.output, output);
-	} });
-	const textLogic = Object.assign(logic, {
-		kind: "statelyai.textLogic",
-		mode: config.mode ?? "generate",
-		schemas,
-		request,
-		async execute(input, executors) {
-			const { output } = await executeAgentTextRequest(config.mode ?? "generate", "textLogic", request(input), executors);
-			return validateSchemaSync(schemas.output, output);
-		},
-		withExecutor(nextExecute) {
-			return createTextLogic(config, nextExecute);
-		}
-	});
-	if (execute) executorBoundLogics.add(textLogic);
-	return textLogic;
-}
-/**
-* Binds a child machine's {@link TextLogic} to a raw
-* {@link AgentRequestExecutor} (the `generateText`/`streamText` shape hosts
-* implement). Encapsulates the `withExecutor` idiom child agents repeat:
-* default the request's `tools` to `{}`, forward the actor `signal`, call the
-* executor, and return its `{ output }` envelope. Use this to share ONE
-* executor across a parent and its nested children.
-*
-* @example
-* ```ts
-* childMachine.provide({
-*   actors: {
-*     researchTopic: bindRequestExecutor(setup.requests.researchTopic, generateText),
-*   },
-* });
-* ```
-*/
-function bindRequestExecutor(logic, executor, info) {
-	return logic.withExecutor(async ({ request, signal }) => {
-		const { output } = await executor({
-			...request,
-			tools: request.tools ?? {}
-		}, {
-			signal,
-			onChunk: info?.onChunk
-		});
-		return { output };
-	});
-}
-/** Type guard: true for any actor logic built by createTextLogic (checks the `kind` marker). @internal */
-function isTextLogic(value) {
-	return !!value && typeof value === "object" && value.kind === "statelyai.textLogic" && typeof value.request === "function";
-}
-/**
-* Classifies a text request's output schema as `'structured'` (its JSON
-* Schema is `type: 'object'`, `type: 'array'`, or a top-level union/
-* composition — `anyOf`/`oneOf`/`allOf`, which a bare `z.union`/
-* `z.discriminatedUnion` emits with no top-level `type`) or `'text'`
-* (anything else, including no schema). Reads the schema's
-* `~standard.jsonSchema.input()` extension — schemas without it are treated
-* as `'text'`.
-*/
-function getAgentOutputMode(schema) {
-	const jsonSchema = getJsonSchemaSync(schema);
-	if (!jsonSchema) return "text";
-	if (jsonSchema.type === "object" || jsonSchema.type === "array") return "structured";
-	if (jsonSchema.type === void 0 && ("anyOf" in jsonSchema || "oneOf" in jsonSchema || "allOf" in jsonSchema)) return "structured";
-	return "text";
-}
-/**
-* Builds the uniform structured-output envelope schema every structured request
-* is sent to the provider as: a root object `{ result: <inner> }`, plus — when
-* `options.reasoning` is `true` — an optional string `reasoning` property listed
-* BEFORE `result` (property order nudges the model to reason first). This is THE
-* wire contract for structured output: a root object is universally accepted as
-* a provider response schema, unlike a bare union/array root that many providers
-* reject.
-*
-* The returned {@link StandardSchemaV1} validates the `{ reasoning?, result }`
-* envelope (unwrapping `result` through the original schema, capturing a string
-* `reasoning` when present) and exposes the enveloped JSON Schema. Adapters read
-* `.result` off the provider output before the machine validates it — so this is
-* transparent: user-facing output types stay the declared (un-enveloped) schema,
-* and `reasoning` is surfaced only on the raw executor result, never in machine
-* context/output.
-*/
-function buildEnvelopeSchema(inner, options = {}) {
-	const includeReasoning = options.reasoning === true;
-	const buildJson = (innerJson) => ({
-		type: "object",
-		properties: {
-			...includeReasoning ? { reasoning: { type: "string" } } : {},
-			result: innerJson ?? {}
-		},
-		required: ["result"],
-		additionalProperties: false
-	});
-	return { "~standard": {
-		version: 1,
-		vendor: "statelyai-agent",
-		validate(value) {
-			if (!value || typeof value !== "object" || !("result" in value)) return { issues: [{ message: "Expected a { result } envelope object" }] };
-			const innerResult = inner["~standard"].validate(value.result);
-			if (innerResult instanceof Promise) throw new Error("Async schema validation is not supported.");
-			if (innerResult.issues) return innerResult;
-			const envelope = { result: innerResult.value };
-			const reasoning = value.reasoning;
-			if (typeof reasoning === "string") envelope.reasoning = reasoning;
-			return { value: envelope };
-		},
-		jsonSchema: { input: () => {
-			const innerJson = inner["~standard"].jsonSchema?.input?.();
-			return innerJson instanceof Promise ? innerJson.then(buildJson) : buildJson(innerJson);
-		} }
-	} };
-}
-/**
-* Validates a raw provider value against the structured-output envelope for
-* `request` and returns the unwrapped `{ result, reasoning? }` — the checked
-* replacement for `raw as StructuredOutputEnvelope` in hand-written hosts.
-* Pair with {@link buildEnvelopeSchema} (which produced the schema the
-* provider was asked to satisfy).
-*/
-function parseStructuredEnvelope(request, value) {
-	if (!request.outputSchema) throw new Error("parseStructuredEnvelope: the request declares no outputSchema.");
-	return validateSchemaSync(buildEnvelopeSchema(request.outputSchema, { reasoning: request.includeReasoning }), value);
-}
-/**
-* Merges request-declared and call-site `tools`, dispatches to the
-* `mode`-appropriate executor (`generateText`/`streamText`), and normalizes
-* the raw result via {@link normalizeGeneratorResult}. Shared by
-* `TextLogic.execute`, `executeAgentRequest`, and the `agent.generateText`/
-* `agent.streamText` builtins. Throws if no executor is registered for
-* `mode`.
-*
-* @internal
-*/
-async function executeAgentTextRequest(mode, id, input, executors, tools = {}, info) {
-	const request = {
-		...input,
-		name: input.name ?? id,
-		tools: {
-			...input.tools,
-			...tools
-		}
-	};
-	const sourceIssue = textRequestSourceIssue(request);
-	if (sourceIssue) throw new Error(sourceIssue);
-	const executor = mode === "stream" ? executors.streamText : executors.generateText;
-	if (!executor) throw new Error(`No executor provided for ${mode === "stream" ? "stream" : "generate"} request '${id}'.`);
-	const raw = await executor(request, info);
-	return {
-		output: await normalizeGeneratorResult(raw, id, {
-			request,
-			onChunk: info?.onChunk
-		}),
-		raw
-	};
-}
-function hasTextStream(value) {
-	return "textStream" in value && typeof value.textStream === "object" && !!value.textStream?.[Symbol.asyncIterator];
-}
-function parseRawAiSdkText(text, request, id) {
-	if (!request?.outputSchema) return text;
-	let parsed = text;
-	try {
-		parsed = JSON.parse(text);
-	} catch {}
-	try {
-		return parseOutput(request.outputSchema, parsed);
-	} catch (error) {
-		throw new Error(`Executor for '${id}' returned a raw AI SDK result whose text could not be parsed against the request's outputSchema. Structured-output requests through raw AI SDK generateText/streamText functions are best-effort — for reliable structured output, use createAiSdkExecutors from '@statelyai/agent/ai-sdk'. Cause: ${error instanceof Error ? error.message : String(error)}`);
-	}
-}
-/**
-* Unwraps an executor result into the request's final output. Accepts three
-* shapes:
-* - `{ output }` (the {@link AgentRequestExecutorResult} envelope) — awaits and
-*   returns `output` (the fast path; unchanged).
-* - a raw AI SDK `streamText` result (`{ textStream }` async iterable) — iterates
-*   `textStream`, forwarding each string chunk to `info.onChunk`, then resolves
-*   the final text from `await result.text` if present else the accumulated chunks.
-* - a raw AI SDK `generateText` result (`{ text }` string or promise) — awaits `text`.
-*
-* For the two raw AI SDK shapes, if `info.request?.outputSchema` is set the final
-* text is parsed through {@link parseOutput} (best-effort); a parse failure throws
-* an error recommending `createAiSdkExecutors` from '@statelyai/agent/ai-sdk'.
-*
-* A value matching none of these is a runtime error naming `id`. This is
-* generator-result unwrapping only — decision results are extracted separately
-* by `resolveDecision`.
-*
-* @internal
-*/
-async function normalizeGeneratorResult(result, id = "text request", info) {
-	const resolved = await result;
-	if (!resolved || typeof resolved !== "object") throw invalidGeneratorResult(id);
-	if ("output" in resolved) return await resolved.output;
-	if (hasTextStream(resolved)) {
-		let accumulated = "";
-		for await (const chunk of resolved.textStream) {
-			accumulated += chunk;
-			info?.onChunk?.(chunk);
-		}
-		const finalText = "text" in resolved && resolved.text !== void 0 ? await resolved.text : accumulated;
-		return parseRawAiSdkText(String(finalText), info?.request, id);
-	}
-	if ("text" in resolved) {
-		const finalText = await resolved.text;
-		return parseRawAiSdkText(String(finalText), info?.request, id);
-	}
-	throw invalidGeneratorResult(id);
-}
-function invalidGeneratorResult(id) {
-	return /* @__PURE__ */ new Error(`Executor for '${id}' returned an invalid result: executors must return { output } (an envelope with the text string or structured object as \`output\`, plus optional passthrough fields). Raw Vercel AI SDK generateText/streamText results ({ text } or { textStream }) are also accepted.`);
-}
-//#endregion
-//#region src/internal/is-record.ts
-/** True for a plain object-like value (arrays excluded). @internal */
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//#endregion
-//#region src/events.ts
-/**
-* Thrown by {@link parseAgentEvent} (and {@link eventFromInteraction}) when a
-* wire payload is not a usable event: it is not an object with a string
-* `type`, it names a reserved `@agent.*` type, or its fields fail the schema
-* the machine registered for that type. A host turns it into a 400.
-*
-* Not handling an event is NOT this error — a state machine ignores events it
-* has no transition for, so an event the current state does not handle parses
-* fine and settles the run with `result.ignored` set.
-*/
-var AgentInvalidEventPayloadError = class extends AgentError {
-	eventType;
-	constructor(eventType, detail) {
-		super("invalid-event-payload", `Invalid event payload for '${eventType}': ${detail}`);
-		this.name = "AgentInvalidEventPayloadError";
-		this.eventType = eventType;
-	}
-};
-/** Default prefix for the synthetic tool name generated per candidate event (e.g. `send_event_ASK`). Override per-request with {@link AgentEventToolNameResolver}. @internal */
-const EVENT_TOOL_PREFIX = "send_event_";
-function hashString(value) {
-	let hash = 5381;
-	for (let i = 0; i < value.length; i++) hash = hash * 33 ^ value.charCodeAt(i);
-	return (hash >>> 0).toString(36);
-}
-function sanitizeEventToolName(eventType) {
-	const base = `${EVENT_TOOL_PREFIX}${eventType.replace(/[^a-zA-Z0-9_-]/g, "_") || "event"}`;
-	if (base.length <= 64) return base;
-	const hash = hashString(eventType);
-	const prefixLength = 64 - hash.length - 1;
-	return `${base.slice(0, prefixLength)}_${hash}`;
-}
-function disambiguateEventToolName(toolName, eventType, usedToolNames) {
-	if (!usedToolNames.has(toolName)) {
-		usedToolNames.add(toolName);
-		return toolName;
-	}
-	const suffix = `_${hashString(eventType)}`;
-	const uniqueToolName = `${toolName.slice(0, 64 - suffix.length)}${suffix}`;
-	usedToolNames.add(uniqueToolName);
-	return uniqueToolName;
-}
-/**
-* True when an event type matches an `allowedEvents` entry: an exact type,
-* `'*'` (every event), or a `'prefix.*'` wildcard matching any deeper
-* segment (`'todo.*'` matches `'todo.add'` and `'todo.list.clear'`, not
-* `'todo'` itself — mirroring xstate's partial wildcard events).
-*/
-function matchesEventPattern(eventType, pattern) {
-	if (pattern === "*") return true;
-	if (pattern.endsWith(".*")) return eventType.startsWith(`${pattern.slice(0, -1)}`);
-	return eventType === pattern;
-}
-/**
-* Event types reserved for delivery by the library (`@agent.*` and
-* `agent.messages`). A machine may declare transitions on them,
-* but they are never model-facing: {@link getAcceptedEvents} drops them before
-* any `allowedEvents` matching, so they cannot be offered as a decision
-* candidate (not even under a `'*'` wildcard) and {@link parseAgentEvent}
-* rejects them — a model or a wire message must not be able to forge one.
-* @internal
-*/
-const RESERVED_AGENT_EVENT_PREFIX = "@agent.";
-function isReservedAgentEvent(eventType) {
-	return eventType.startsWith(RESERVED_AGENT_EVENT_PREFIX) || eventType === "agent.messages";
-}
-/** True when an `allowedEvents` entry is a wildcard pattern rather than a concrete event type. @internal */
-function isEventPattern(entry) {
-	return entry === "*" || entry.endsWith(".*");
-}
-/**
-* Parses a wire payload (a request body, a socket frame) into an
-* event typed as the machine's event union, so it can go straight to
-* `runAgent({ event })` / `actor.send(...)` without a cast. Pass the machine
-* itself, or any snapshot of it.
-*
-* It checks exactly what a schema can check: the payload is an object with a
-* string `type`, that type is not one of the library-reserved `@agent.*` types,
-* and — when the machine registered a schema for it — the fields satisfy that
-* schema (defaults filled, transforms applied). Anything else throws
-* {@link AgentInvalidEventPayloadError}, which a host answers with a 400.
-*
-* It deliberately does NOT check whether the current state handles the event.
-* State machines ignore events they have no transition for; that is normal
-* behavior, not a validation failure. Send the parsed event and read
-* `result.ignored` if the host wants to tell the client nothing happened.
-*
-* @example
-* ```ts
-* const event = parseAgentEvent(machine, await request.json());
-* const result = await runAgent(machine, { store, threadId, event, executors });
-* ```
-*/
-function parseAgentEvent(source, payload, options = {}) {
-	if (!isRecord(payload) || typeof payload.type !== "string") throw new AgentInvalidEventPayloadError("(unknown)", "expected an object with a string `type`.");
-	const event = payload;
-	if (isReservedAgentEvent(event.type)) throw new AgentInvalidEventPayloadError(event.type, "this event type is reserved for the library and cannot be sent from outside.");
-	const registered = getAgentExecutionOptions(typeof source.provide === "function" ? source : source.machine)?.schemas;
-	const inputSchema = (options.events ?? options.schemas?.events ?? registered?.events)?.[event.type];
-	if (!inputSchema) return event;
-	const { type, ...fields } = event;
-	try {
-		return {
-			...validateSchemaSync(inputSchema, fields),
-			type
-		};
-	} catch (error) {
-		throw new AgentInvalidEventPayloadError(event.type, error instanceof Error ? error.message : String(error));
-	}
-}
-/**
-* Lists the events a snapshot can currently accept, as {@link AgentEventDescriptor}s
-* a model can be offered (via `resolveDecision`/an adapter's tool-per-event
-* mapping). **Filters by event TYPE only** — it does not evaluate guards, so
-* a type-legal-but-guard-rejected event can still appear here. Guard
-* legality is checked separately, at decision-resolution time, via
-* `snapshot.can(event)` (the `canTake` option of {@link resolveDecision} /
-* {@link ResolveDecisionOptions}). Pass `eventTypes` to further narrow to a
-* declared `allowedEvents` set — entries may be exact types or wildcard
-* patterns (`'*'`, `'todo.*'`; see {@link matchesEventPattern}).
-*
-* XState-internal (`xstate.*`) and library-reserved
-* ({@link RESERVED_AGENT_EVENT_PREFIX}) event types are always excluded, before
-* any `allowedEvents` matching — a machine that handles `'@agent.usage'` still
-* never offers it to a model.
-*/
-function getAcceptedEvents(snapshot, options = {}) {
-	const eventTypes = options.eventTypes;
-	const seen = /* @__PURE__ */ new Set();
-	const usedToolNames = /* @__PURE__ */ new Set();
-	return (0, xstate.getNextTransitions)(snapshot).flatMap((transitionDefinition) => {
-		const eventType = transitionDefinition.eventType;
-		if (!eventType || eventType === "*" || eventType.startsWith("xstate.") || isReservedAgentEvent(eventType) || eventTypes && !eventTypes.some((pattern) => matchesEventPattern(eventType, pattern)) || seen.has(eventType)) return [];
-		seen.add(eventType);
-		const defaultToolName = sanitizeEventToolName(eventType);
-		const toolName = options.eventToolName ? options.eventToolName({
-			eventType,
-			defaultToolName
-		}) : disambiguateEventToolName(defaultToolName, eventType, usedToolNames);
-		const inputSchema = (options.events ?? options.schemas?.events)?.[eventType];
-		return [{
-			type: eventType,
-			toolName,
-			...inputSchema ? { inputSchema } : {}
-		}];
-	});
-}
-//#endregion
-//#region src/decision.ts
-function decideRequestFromInput(input) {
-	const allowedEventTypes = resolveAllowedEventTypes(input.allowedEvents, input) ?? [];
-	return {
-		kind: "decision",
-		id: "",
-		name: input.name,
-		input,
-		model: input.model,
-		system: input.system,
-		prompt: input.prompt,
-		messages: input.messages,
-		events: allowedEventTypes.filter((type) => !isEventPattern(type)).map((type) => ({
-			type,
-			toolName: sanitizeEventToolName(type)
-		})),
-		attempts: [],
-		temperature: input.temperature,
-		maxOutputTokens: input.maxOutputTokens,
-		topP: input.topP,
-		topK: input.topK,
-		seed: input.seed,
-		stopSequences: input.stopSequences,
-		metadata: input.metadata
-	};
-}
-function decideActorWithExecutor(execute) {
-	const logic = (0, xstate.createAsyncLogic)({ run: async ({ input, signal }) => {
-		if (!execute) throw new Error(`'${DECIDE_ACTOR}' has no host execution. Provide an implementation with machine.provide({ actors: { '${DECIDE_ACTOR}': ... } }) or resolve the returned agent request with resolveDecision(...).`);
-		const resolvedEventTypes = resolveAllowedEventTypes(input.allowedEvents, input);
-		if (resolvedEventTypes === void 0) throw new Error(`'${DECIDE_ACTOR}' input has omitted \`allowedEvents\`, which means "all currently-legal events" — but that requires a snapshot-aware host (runAgent or the step path) to resolve. Under a bare createActor(...), declare \`allowedEvents\` explicitly to use this actor here.`);
-		if (resolvedEventTypes.some(isEventPattern)) throw new Error(`'${DECIDE_ACTOR}' input uses wildcard \`allowedEvents\` patterns, which expand against the live snapshot — that requires a snapshot-aware host (runAgent or the step path). Under a bare createActor(...), list event types explicitly.`);
-		return resolveDecision(decideRequestFromInput(input), { decide: execute }, {
-			maxRetries: input.maxRetries ?? 2,
-			signal
-		});
-	} });
-	return Object.assign(logic, {
-		kind: "statelyai.decisionLogic",
-		maxRetries: 2,
-		request: decideRequestFromInput,
-		allowedEventTypes: (input) => resolveAllowedEventTypes(input.allowedEvents, input),
-		withExecutor: (nextExecute) => decideActorWithExecutor(nextExecute)
-	});
-}
-function createDecideActor() {
-	return decideActorWithExecutor();
-}
-function resolveAllowedEventTypes(allowedEvents, input) {
-	if (allowedEvents === void 0) return;
-	const resolved = typeof allowedEvents === "function" ? allowedEvents({ input }) : allowedEvents;
-	return typeof resolved === "string" ? [resolved] : resolved;
-}
-/**
-* Creates reusable, standalone {@link DecisionLogic}: an actor that, when
-* run, resolves to exactly one currently-legal {@link ChosenEvent} by
-* calling the host `decide` executor (passed here as `execute`, or supplied
-* later via {@link DecisionLogic.withExecutor}, `machine.provide(...)`, or
-* `runAgent`'s `decide` option). Register the result under `actors:` and
-* invoke it by name; for a one-off, state-local decision, prefer the
-* `agent.decide` builtin invoke instead — it needs no separate declaration
-* and types `allowedEvents` against the machine's own event schemas.
-*
-* @example
-* ```ts
-* import { createDecisionLogic } from '@statelyai/agent';
-* import { z } from 'zod';
-*
-* export const chooseMove = createDecisionLogic({
-*   schemas: { input: z.object({ playerHp: z.number(), enemyHp: z.number() }) },
-*   model: 'openai/gpt-5.4-mini',
-*   system: 'You are playing a turn-based game. Choose exactly one legal move.',
-*   prompt: ({ input }) => `Player HP: ${input.playerHp}\nEnemy HP: ${input.enemyHp}`,
-*   allowedEvents: ({ input }) =>
-*     input.playerHp <= 6
-*       ? ['ATTACK', 'DEFEND', 'HEAL', 'FLEE']
-*       : ['ATTACK', 'DEFEND', 'FLEE'],
-* });
-* ```
-*/
-function createDecisionLogic(config, execute) {
-	const maxRetries = config.maxRetries ?? 2;
-	const request = (input) => {
-		const parsedInput = config.schemas ? validateSchemaSync(config.schemas.input, input) : input;
-		const args = { input: parsedInput };
-		const allowedEventTypes = resolveAllowedEventTypes(config.allowedEvents, parsedInput);
-		return {
-			kind: "decision",
-			id: "",
-			name: resolveTextLogicValue(config.name, args),
-			input: parsedInput,
-			model: resolveTextLogicValue(config.model, args),
-			system: resolveTextLogicValue(config.system, args),
-			prompt: resolveTextLogicValue(config.prompt, args),
-			messages: resolveTextLogicValue(config.messages, args),
-			events: (allowedEventTypes ?? []).map((type) => ({
-				type,
-				toolName: sanitizeEventToolName(type)
-			})),
-			attempts: [],
-			temperature: resolveTextLogicValue(config.temperature, args),
-			maxOutputTokens: resolveTextLogicValue(config.maxOutputTokens, args),
-			topP: resolveTextLogicValue(config.topP, args),
-			topK: resolveTextLogicValue(config.topK, args),
-			seed: resolveTextLogicValue(config.seed, args),
-			stopSequences: resolveTextLogicValue(config.stopSequences, args),
-			metadata: resolveTextLogicValue(config.metadata, args)
-		};
-	};
-	const logic = (0, xstate.createAsyncLogic)({ run: async ({ input, signal }) => {
-		if (!execute) throw new Error("Decision logic has no host execution. Pass an executor as the second argument to createDecisionLogic(...), provide a runtime adapter, or bind it through runAgent/provideExecutors, or call resolveDecision from your host.");
-		const allowedEventTypes = resolveAllowedEventTypes(config.allowedEvents, input);
-		if (allowedEventTypes === void 0) throw new Error("Decision logic has omitted `allowedEvents`, which means \"all currently-legal events\" — but that requires a snapshot-aware host (runAgent or the step path) to resolve. Under a bare createActor(...), declare `allowedEvents` explicitly on this logic to use it here.");
-		if (allowedEventTypes.some(isEventPattern)) throw new Error("Decision logic uses wildcard `allowedEvents` patterns, which expand against the live snapshot — that requires a snapshot-aware host (runAgent or the step path). Under a bare createActor(...), list event types explicitly.");
-		return resolveDecision(request(input), { decide: execute }, {
-			maxRetries,
-			signal
-		});
-	} });
-	const decisionLogic = Object.assign(logic, {
-		kind: "statelyai.decisionLogic",
-		maxRetries,
-		request,
-		allowedEventTypes: (input) => resolveAllowedEventTypes(config.allowedEvents, input),
-		withExecutor(nextExecute) {
-			return createDecisionLogic(config, nextExecute);
-		}
-	});
-	if (execute) executorBoundLogics.add(decisionLogic);
-	return decisionLogic;
-}
-/** Type guard: true for any actor logic built by createDecisionLogic/createDecideActor (checks the `kind` marker). @internal */
-function isDecisionLogic(value) {
-	return !!value && typeof value === "object" && value.kind === "statelyai.decisionLogic" && typeof value.request === "function";
-}
-/**
-* Builds an {@link AgentDecisionRequest} for {@link resolveDecision}, filling
-* in the fields a hand-written literal has to restate every time: `kind`, an
-* `id`, an empty `attempts` list, and each candidate event's `toolName`.
-*
-* @example
-* ```ts
-* const chosen = await resolveDecision(
-*   createDecisionRequest({
-*     name: 'judge',
-*     model: 'reviewer',
-*     prompt: `Judge this draft.\n\n${snapshot.context.draft}`,
-*     events: getAcceptedEvents(snapshot),
-*   }),
-*   { decide },
-*   { canTake: (event) => snapshot.can(event) },
-* );
-* ```
-*/
-function createDecisionRequest(options) {
-	const { id, name, events, attempts, ...rest } = options;
-	return {
-		...rest,
-		kind: "decision",
-		id: id ?? name ?? "decision",
-		...name === void 0 ? {} : { name },
-		events: dedupeToolNames(events.map((event) => typeof event === "string" ? {
-			type: event,
-			toolName: sanitizeEventToolName(event)
-		} : event)),
-		attempts: attempts ?? []
-	};
-}
-function dedupeToolNames(candidates) {
-	const taken = /* @__PURE__ */ new Set();
-	return candidates.map((candidate) => {
-		if (candidate.toolName === void 0) return candidate;
-		let toolName = candidate.toolName;
-		for (let n = 2; taken.has(toolName); n++) {
-			const suffix = `_${n}`;
-			toolName = `${candidate.toolName.slice(0, 64 - suffix.length)}${suffix}`;
-		}
-		taken.add(toolName);
-		return toolName === candidate.toolName ? candidate : {
-			...candidate,
-			toolName
-		};
-	});
-}
-/**
-* Thrown by {@link resolveDecision} when every attempt (up to
-* `maxRetries + 1` of them) fails one of the three checks recorded in
-* {@link DecisionAttempt.failure}. Carries the full `attempts` list for
-* diagnostics; a machine typically routes this via the decision invoke's
-* `onError`.
-*/
-var AgentDecisionExhaustedError = class extends AgentError {
-	attempts;
-	constructor(attempts) {
-		super("decision-exhausted", `Decision exhausted after ${attempts.length} attempt${attempts.length === 1 ? "" : "s"}: ` + attempts.map((attempt) => attempt.reason).join("; "));
-		this.name = "AgentDecisionExhaustedError";
-		this.attempts = attempts;
-	}
-};
-/**
-* Renders a decision request's prior failed `attempts` into feedback messages
-* a host appends to the model call so retries converge — the transport-agnostic
-* "your last choice failed because X, choose again from Y" logic every adapter
-* and raw-SDK host repeats. Returns one `user`-role {@link AgentMessage} per
-* attempt (empty when there are none); adapters map each onto their wire
-* message shape (`attempt.content` is always a string). Core never rewrites the
-* request itself — this only turns the recorded attempts into messages.
-*
-* @example
-* ```ts
-* const messages = [...baseMessages, ...renderDecisionAttempts(request)];
-* ```
-*/
-function renderDecisionAttempts(request) {
-	const types = request.events.map((event) => event.type).join(", ") || "(none)";
-	return request.attempts.map((attempt) => userMessage(`Your previous choice failed: ${attempt.reason}. Choose again from: ${types}`));
-}
-/**
-* Validation + retry core for decisions. No provider mechanics — the
-* `executors.decide` is responsible for making the model choose an event; this
-* function only validates the choice and retries on failure, up to
-* `options.maxRetries` (default 2, i.e. up to 3 attempts total).
-*
-* Each attempt is checked in order and can fail one of three ways (recorded
-* as a {@link DecisionAttempt}): `'unknown-event'` (the chosen `type` is not
-* among `request.events`), `'invalid-payload'` (the payload fails that
-* event's schema), or `'rejected-by-guard'` (passes both checks but
-* `options.canTake` returns `false` — a type/payload-legal event the
-* machine's guard rejects right now; omit `canTake` to skip this check).
-* Every prior failed attempt for this call is fed back to the executor on
-* the next attempt via `request.attempts`, so an adapter can render "your
-* last choice failed because X — try again" into the next model call; core
-* never rewrites the request itself. Exhausting all attempts throws
-* {@link AgentDecisionExhaustedError} with the full attempts list.
-*
-* @example
-* ```ts
-* const event = await resolveDecision(request, executors, {
-*   canTake: (e) => snapshot.can(e),
-* });
-* ```
-*/
-async function resolveDecision(request, executors, options = {}) {
-	const executor = executors?.decide;
-	if (typeof executor !== "function") throw new AgentError("missing-decide-executor", "resolveDecision(request, executors, ...) takes the EXECUTOR SET (the same object executeAgentRequest takes), and this one has no 'decide' function. Build one with createAiSdkExecutors({ models }), or pass { decide }.");
-	const maxRetries = options.maxRetries ?? 2;
-	const attempts = [];
-	const eventsByType = new Map(request.events.map((event) => [event.type, event]));
-	for (let attempt = 0; attempt <= maxRetries; attempt++) {
-		options.signal?.throwIfAborted();
-		const result = await executor({
-			...request,
-			name: request.name ?? (request.id || "agent.decide"),
-			attempts: [...attempts]
-		}, {
-			...options.signal !== void 0 ? { signal: options.signal } : {},
-			...request.id ? { requestId: request.id } : {}
-		});
-		if (!result || typeof result !== "object" || typeof result.event !== "object" || result.event === null || typeof result.event.type !== "string") throw new Error(`decide executor must return { event: { type: string, ... } }; got ${JSON.stringify(result)}. Wrap the chosen event: return { event: { type: 'SAFE' } }.`);
-		const { event } = result;
-		const descriptor = eventsByType.get(event.type);
-		if (!descriptor) {
-			attempts.push({
-				event,
-				failure: "unknown-event",
-				reason: `'${event.type}' is not among the currently allowed events: ${request.events.map((candidate) => candidate.type).join(", ") || "(none)"}.`
-			});
-			continue;
-		}
-		let validatedEvent = event;
-		if (descriptor.inputSchema) {
-			const { type, ...payload } = event;
-			try {
-				validatedEvent = {
-					...validateSchemaSync(descriptor.inputSchema, payload),
-					type
-				};
-			} catch (error) {
-				attempts.push({
-					event,
-					failure: "invalid-payload",
-					reason: `'${event.type}' payload failed validation: ${error instanceof Error ? error.message : String(error)}`
-				});
-				continue;
-			}
-		}
-		if (options.canTake?.(validatedEvent) === false) {
-			attempts.push({
-				event: validatedEvent,
-				failure: "rejected-by-guard",
-				reason: `'${validatedEvent.type}' is not currently takeable (guard rejected it).`
-			});
-			continue;
-		}
-		return validatedEvent;
-	}
-	throw new AgentDecisionExhaustedError(attempts);
-}
-//#endregion
-Object.defineProperty(exports, "AGENT_MESSAGES_EVENT_TYPE", {
-	enumerable: true,
-	get: function() {
-		return AGENT_MESSAGES_EVENT_TYPE;
-	}
-});
-Object.defineProperty(exports, "AGENT_USAGE_TOKEN_FIELDS", {
-	enumerable: true,
-	get: function() {
-		return AGENT_USAGE_TOKEN_FIELDS;
-	}
-});
-Object.defineProperty(exports, "AgentDecisionExhaustedError", {
-	enumerable: true,
-	get: function() {
-		return AgentDecisionExhaustedError;
-	}
-});
-Object.defineProperty(exports, "AgentError", {
-	enumerable: true,
-	get: function() {
-		return AgentError;
-	}
-});
-Object.defineProperty(exports, "AgentInvalidEventPayloadError", {
-	enumerable: true,
-	get: function() {
-		return AgentInvalidEventPayloadError;
-	}
-});
-Object.defineProperty(exports, "AgentTruncatedError", {
-	enumerable: true,
-	get: function() {
-		return AgentTruncatedError;
-	}
-});
-Object.defineProperty(exports, "DECIDE_ACTOR", {
-	enumerable: true,
-	get: function() {
-		return DECIDE_ACTOR;
-	}
-});
-Object.defineProperty(exports, "DEFAULT_AGENT_EXECUTORS", {
-	enumerable: true,
-	get: function() {
-		return DEFAULT_AGENT_EXECUTORS;
-	}
-});
-Object.defineProperty(exports, "GENERATE_TEXT_ACTOR", {
-	enumerable: true,
-	get: function() {
-		return GENERATE_TEXT_ACTOR;
-	}
-});
-Object.defineProperty(exports, "STREAM_TEXT_ACTOR", {
-	enumerable: true,
-	get: function() {
-		return STREAM_TEXT_ACTOR;
-	}
-});
-Object.defineProperty(exports, "USER_INPUT_ACTOR", {
-	enumerable: true,
-	get: function() {
-		return USER_INPUT_ACTOR;
-	}
-});
-Object.defineProperty(exports, "agentMessagesEventSchema", {
-	enumerable: true,
-	get: function() {
-		return agentMessagesEventSchema;
-	}
-});
-Object.defineProperty(exports, "appendMessages", {
-	enumerable: true,
-	get: function() {
-		return appendMessages;
-	}
-});
-Object.defineProperty(exports, "assistantMessage", {
-	enumerable: true,
-	get: function() {
-		return assistantMessage;
-	}
-});
-Object.defineProperty(exports, "bindRequestExecutor", {
-	enumerable: true,
-	get: function() {
-		return bindRequestExecutor;
-	}
-});
-Object.defineProperty(exports, "buildEnvelopeSchema", {
-	enumerable: true,
-	get: function() {
-		return buildEnvelopeSchema;
-	}
-});
-Object.defineProperty(exports, "builtinTextActors", {
-	enumerable: true,
-	get: function() {
-		return builtinTextActors;
-	}
-});
-Object.defineProperty(exports, "createDecideActor", {
-	enumerable: true,
-	get: function() {
-		return createDecideActor;
-	}
-});
-Object.defineProperty(exports, "createDecisionLogic", {
-	enumerable: true,
-	get: function() {
-		return createDecisionLogic;
-	}
-});
-Object.defineProperty(exports, "createDecisionRequest", {
-	enumerable: true,
-	get: function() {
-		return createDecisionRequest;
-	}
-});
-Object.defineProperty(exports, "createTextLogic", {
-	enumerable: true,
-	get: function() {
-		return createTextLogic;
-	}
-});
-Object.defineProperty(exports, "djb2Hex", {
-	enumerable: true,
-	get: function() {
-		return djb2Hex;
-	}
-});
-Object.defineProperty(exports, "executeAgentTextRequest", {
-	enumerable: true,
-	get: function() {
-		return executeAgentTextRequest;
-	}
-});
-Object.defineProperty(exports, "executorBoundLogics", {
-	enumerable: true,
-	get: function() {
-		return executorBoundLogics;
-	}
-});
-Object.defineProperty(exports, "findNonSerializableContextPaths", {
-	enumerable: true,
-	get: function() {
-		return findNonSerializableContextPaths;
-	}
-});
-Object.defineProperty(exports, "getAcceptedEvents", {
-	enumerable: true,
-	get: function() {
-		return getAcceptedEvents;
-	}
-});
-Object.defineProperty(exports, "getAgentExecutionOptions", {
-	enumerable: true,
-	get: function() {
-		return getAgentExecutionOptions;
-	}
-});
-Object.defineProperty(exports, "getAgentOutputMode", {
-	enumerable: true,
-	get: function() {
-		return getAgentOutputMode;
-	}
-});
-Object.defineProperty(exports, "getCallFinishReason", {
-	enumerable: true,
-	get: function() {
-		return getCallFinishReason;
-	}
-});
-Object.defineProperty(exports, "getCallUsage", {
-	enumerable: true,
-	get: function() {
-		return getCallUsage;
-	}
-});
-Object.defineProperty(exports, "getJsonSchema", {
-	enumerable: true,
-	get: function() {
-		return getJsonSchema;
-	}
-});
-Object.defineProperty(exports, "getJsonSchemaSync", {
-	enumerable: true,
-	get: function() {
-		return getJsonSchemaSync;
-	}
-});
-Object.defineProperty(exports, "getMachineIdlePredicate", {
-	enumerable: true,
-	get: function() {
-		return getMachineIdlePredicate;
-	}
-});
-Object.defineProperty(exports, "getMachineStructuralHash", {
-	enumerable: true,
-	get: function() {
-		return getMachineStructuralHash;
-	}
-});
-Object.defineProperty(exports, "getMessageText", {
-	enumerable: true,
-	get: function() {
-		return getMessageText;
-	}
-});
-Object.defineProperty(exports, "getRegisteredAgentExecutionOptions", {
-	enumerable: true,
-	get: function() {
-		return getRegisteredAgentExecutionOptions;
-	}
-});
-Object.defineProperty(exports, "getStateMeta", {
-	enumerable: true,
-	get: function() {
-		return getStateMeta;
-	}
-});
-Object.defineProperty(exports, "getStatePath", {
-	enumerable: true,
-	get: function() {
-		return getStatePath;
-	}
-});
-Object.defineProperty(exports, "isAgentMessages", {
-	enumerable: true,
-	get: function() {
-		return isAgentMessages;
-	}
-});
-Object.defineProperty(exports, "isDecisionLogic", {
-	enumerable: true,
-	get: function() {
-		return isDecisionLogic;
-	}
-});
-Object.defineProperty(exports, "isRecord", {
-	enumerable: true,
-	get: function() {
-		return isRecord;
-	}
-});
-Object.defineProperty(exports, "isStandardSchema", {
-	enumerable: true,
-	get: function() {
-		return isStandardSchema;
-	}
-});
-Object.defineProperty(exports, "isTextLogic", {
-	enumerable: true,
-	get: function() {
-		return isTextLogic;
-	}
-});
-Object.defineProperty(exports, "isUnboundPlaceholder", {
-	enumerable: true,
-	get: function() {
-		return isUnboundPlaceholder;
-	}
-});
-Object.defineProperty(exports, "machineIdlePredicates", {
-	enumerable: true,
-	get: function() {
-		return machineIdlePredicates;
-	}
-});
-Object.defineProperty(exports, "messagesSchema", {
-	enumerable: true,
-	get: function() {
-		return messagesSchema;
-	}
-});
-Object.defineProperty(exports, "missingActor", {
-	enumerable: true,
-	get: function() {
-		return missingActor;
-	}
-});
-Object.defineProperty(exports, "normalizeGeneratorResult", {
-	enumerable: true,
-	get: function() {
-		return normalizeGeneratorResult;
-	}
-});
-Object.defineProperty(exports, "parseAgentEvent", {
-	enumerable: true,
-	get: function() {
-		return parseAgentEvent;
-	}
-});
-Object.defineProperty(exports, "parseModelRef", {
-	enumerable: true,
-	get: function() {
-		return parseModelRef;
-	}
-});
-Object.defineProperty(exports, "parseOutput", {
-	enumerable: true,
-	get: function() {
-		return parseOutput;
-	}
-});
-Object.defineProperty(exports, "parseStructuredEnvelope", {
-	enumerable: true,
-	get: function() {
-		return parseStructuredEnvelope;
-	}
-});
-Object.defineProperty(exports, "renderDecisionAttempts", {
-	enumerable: true,
-	get: function() {
-		return renderDecisionAttempts;
-	}
-});
-Object.defineProperty(exports, "resolveDecision", {
-	enumerable: true,
-	get: function() {
-		return resolveDecision;
-	}
-});
-Object.defineProperty(exports, "resolveMachineVersion", {
-	enumerable: true,
-	get: function() {
-		return resolveMachineVersion;
-	}
-});
-Object.defineProperty(exports, "setAgentExecutionOptions", {
-	enumerable: true,
-	get: function() {
-		return setAgentExecutionOptions;
-	}
-});
-Object.defineProperty(exports, "systemMessage", {
-	enumerable: true,
-	get: function() {
-		return systemMessage;
-	}
-});
-Object.defineProperty(exports, "toolMessage", {
-	enumerable: true,
-	get: function() {
-		return toolMessage;
-	}
-});
-Object.defineProperty(exports, "userInputActor", {
-	enumerable: true,
-	get: function() {
-		return userInputActor;
-	}
-});
-Object.defineProperty(exports, "userMessage", {
-	enumerable: true,
-	get: function() {
-		return userMessage;
-	}
-});
-Object.defineProperty(exports, "validateSchemaSync", {
-	enumerable: true,
-	get: function() {
-		return validateSchemaSync;
-	}
-});