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

package/dist/decision-BBZ2jMO1.mjs

@@ -1,1490 +0,0 @@
-import { createAsyncLogic, getNextTransitions } from "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 = 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 = 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 = 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 = 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 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 = 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 = 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
-export { userMessage as $, userInputActor as A, assistantMessage as B, getCallFinishReason as C, parseModelRef as D, normalizeGeneratorResult as E, getRegisteredAgentExecutionOptions as F, getMachineStructuralHash as G, findNonSerializableContextPaths as H, isUnboundPlaceholder as I, getStatePath as J, getMessageText as K, machineIdlePredicates as L, executorBoundLogics as M, getAgentExecutionOptions as N, parseOutput as O, getMachineIdlePredicate as P, toolMessage as Q, missingActor as R, getAgentOutputMode as S, isTextLogic as T, getJsonSchema as U, djb2Hex as V, getJsonSchemaSync as W, resolveMachineVersion as X, isStandardSchema as Y, systemMessage as Z, bindRequestExecutor as _, isDecisionLogic as a, messagesSchema as at, createTextLogic as b, AgentInvalidEventPayloadError as c, isRecord as d, validateSchemaSync as et, AGENT_USAGE_TOKEN_FIELDS as f, USER_INPUT_ACTOR as g, STREAM_TEXT_ACTOR as h, createDecisionRequest as i, isAgentMessages as it, DEFAULT_AGENT_EXECUTORS as j, parseStructuredEnvelope as k, getAcceptedEvents as l, GENERATE_TEXT_ACTOR as m, createDecideActor as n, agentMessagesEventSchema as nt, renderDecisionAttempts as o, AgentError as ot, DECIDE_ACTOR as p, getStateMeta as q, createDecisionLogic as r, appendMessages as rt, resolveDecision as s, AgentTruncatedError as st, AgentDecisionExhaustedError as t, AGENT_MESSAGES_EVENT_TYPE as tt, parseAgentEvent as u, buildEnvelopeSchema as v, getCallUsage as w, executeAgentTextRequest as x, builtinTextActors as y, setAgentExecutionOptions as z };