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

package/dist/testing.mjs

@@ -1,6 +1,251 @@
-import { H as AgentError, P as getStateMeta, S as getRegisteredAgentExecutionOptions, d as getCallUsage, f as isTextLogic, p as normalizeGeneratorResult, y as executorBoundLogics } from "./text-logic-Bl_ZRxDi.mjs";
-import { a as isDecisionLogic, d as isRecord, l as getAcceptedEvents, s as resolveDecision, t as AgentDecisionExhaustedError } from "./decision-DzSv1NpD.mjs";
-import { _ as rejectAgentStep, d as runAgent, g as initialAgentStep, h as getPendingInvokes, v as resolveAgentStep, y as transitionAgentStep } from "./run-agent-DvDQd4If.mjs";
+import { b as getRegisteredAgentExecutionOptions, d as isTextLogic, f as normalizeGeneratorResult, j as getStateMeta, u as getCallUsage, v as executorBoundLogics, z as AgentError } from "./text-logic-CIqHAmBi.mjs";
+import { a as isDecisionLogic, d as isRecord, l as getAcceptedEvents, s as resolveDecision, t as AgentDecisionExhaustedError } from "./decision-RQ0iv0oZ.mjs";
+import { f as runToQuiescence, s as createAgentRuntime } from "./run-agent-xNTxpt82.mjs";
+import { initialTransition, transition } from "xstate";
+//#region src/steps.ts
+/**
+* Internal: the pure `(state, event) => (nextState, requests)` view of an
+* agent machine, used by model-free simulation (`simulateAgent`) and tests.
+* An {@link AgentStep} is a snapshot plus the model requests the machine is
+* now waiting on; nothing here executes anything. Hosts use
+* `createAgentRuntime`.
+* @module
+*/
+/** @internal Normalizes current and legacy XState invoke effect shapes. */
+function getInvokeEffectMetadata(action) {
+	if (action.type === "@xstate.spawn") return action;
+	if (action.type === "xstate.spawnChild") {
+		const params = action.params;
+		return params ? {
+			...params,
+			logic: action.logic
+		} : void 0;
+	}
+	if (action.type === "@xstate.start" && typeof action.src === "string") return action;
+}
+/**
+* The invokes a snapshot is still waiting on, lowered to the same spawn-effect
+* shape {@link getAgentRequests} reads. Derived from the snapshot's live
+* children rather than the last transition's actions, so a state that invokes
+* several actors at once (an `invoke: [...]` array, or parallel regions each
+* invoking) keeps reporting the siblings after the first one settles —
+* including when the settled invoke's `onDone` is targetless and starts
+* nothing new.
+*
+* Entries are ordered by invoke id, so a walker that resolves one invoke per
+* step is deterministic.
+*
+* @internal
+*/
+function getPendingInvokes(snapshot) {
+	const children = snapshot.children ?? {};
+	return Object.keys(children).sort().flatMap((id) => {
+		const child = children[id];
+		const childSnapshot = child?.getSnapshot?.();
+		if (!child || childSnapshot?.status !== "active") return [];
+		return [{
+			type: "@xstate.spawn",
+			id,
+			src: child.src,
+			input: childSnapshot.input,
+			logic: child.logic
+		}];
+	});
+}
+/**
+* Scans a set of executable actions (as returned by xstate's `transition`/
+* `initialTransition`) for spawned `TextLogic`/`DecisionLogic` invokes and
+* lowers each into an {@link AgentStepRequest}. Pass `options.machine` to
+* pre-fill `schemas`/`actors` from the machine's registered `setupAgent`
+* options instead of passing them by hand.
+* `options.snapshot` is required to resolve a decision's candidate events
+* (intersecting declared `allowedEvents` with what's currently legal) — omit
+* it and decision requests report an empty `events` list.
+*
+* @internal
+*/
+function getAgentRequests(actions, { machine, ...options } = {}) {
+	if (machine) options = {
+		...getRegisteredAgentExecutionOptions(machine),
+		...options
+	};
+	return actions.flatMap((action) => {
+		const params = getInvokeEffectMetadata(action);
+		if (!params || typeof params.src !== "string") return [];
+		if (typeof params.id !== "string" || params.id.length === 0) throw new Error(`Agent invoke '${params.src}' must define a durable string id.`);
+		const registeredLogic = isTextLogic(params.logic) || isDecisionLogic(params.logic) ? params.logic : options.actors?.[params.src];
+		if (isDecisionLogic(registeredLogic)) {
+			const decisionRequest = registeredLogic.request(params.input);
+			const allowedEventTypes = registeredLogic.allowedEventTypes?.(params.input);
+			const events = options.snapshot ? getAcceptedEvents(options.snapshot, {
+				events: options.events,
+				schemas: options.schemas,
+				eventTypes: allowedEventTypes
+			}) : [];
+			return [{
+				...decisionRequest,
+				id: params.id,
+				events
+			}];
+		}
+		const textLogic = isTextLogic(registeredLogic) ? registeredLogic : void 0;
+		const input = textLogic ? textLogic.request(params.input) : void 0;
+		if (!input) return [];
+		return [{
+			kind: "text",
+			id: params.id,
+			src: params.src,
+			...textLogic ? { mode: textLogic.mode } : {},
+			input,
+			tools: input.tools ?? {},
+			events: []
+		}];
+	});
+}
+/**
+* Builds the canonical `xstate.done.actor` event xstate's `transition()`
+* expects to resolve a spawned invoke — including the child session identity
+* that rejects a stale completion from an earlier incarnation.
+*
+* @internal
+*/
+function doneEvent(snapshot, request, output) {
+	const id = typeof request === "string" ? request : request.id;
+	const child = snapshot.children[id];
+	return {
+		type: "xstate.done.actor",
+		actorId: id,
+		...typeof child?.sessionId === "string" ? { sessionId: child.sessionId } : {},
+		output
+	};
+}
+/**
+* The `xstate.error.actor` counterpart of {@link doneEvent} — the event a
+* failed invoke delivers, which `onError` transitions observe. Carries the
+* same child session identity, so xstate does not discard it as stale.
+*
+* @internal
+*/
+function errorEvent(snapshot, request, error) {
+	const id = typeof request === "string" ? request : request.id;
+	const child = snapshot.children[id];
+	return {
+		type: "xstate.error.actor",
+		actorId: id,
+		...typeof child?.sessionId === "string" ? { sessionId: child.sessionId } : {},
+		error
+	};
+}
+/**
+* Applies a request's `output` as a done event (or, with `outcome: 'error'`,
+* its `output` as the invoke's error) via `transition(...)`, returning the raw
+* `[snapshot, actions]` tuple. Lower-level than {@link resolveAgentStep} /
+* {@link rejectAgentStep} — those helpers wrap this and also run
+* {@link getAgentRequests} to produce the next {@link AgentStep}.
+*
+* @internal
+*/
+function transitionResult(logic, snapshot, request, output, outcome = "output") {
+	const event = outcome === "error" ? errorEvent(snapshot, request, output) : doneEvent(snapshot, request, output);
+	const result = transition(logic, snapshot, event);
+	applyFinalStateOutput(logic, result[0], event);
+	return result;
+}
+/**
+* Starts a machine and returns its first {@link AgentStep} — the step-path
+* equivalent of `initialTransition` plus request discovery. Begins the
+* durable/per-model-call-checkpoint loop: resolve each `step.requests` entry
+* (via {@link executeAgentRequest} for `kind: 'text'`, or
+* {@link resolveDecision} for `kind: 'decision'`), then advance with
+* {@link resolveAgentStep} or {@link transitionAgentStep}.
+*/
+function initialAgentStep(machine, input, options) {
+	const [snapshot, actions] = initialTransition(machine, input);
+	return createAgentStep(machine, snapshot, actions, getRegisteredAgentExecutionOptions(machine, options));
+}
+/**
+* Applies an externally-sent event (e.g. a decision's chosen event, or a
+* human's reply) and returns the next {@link AgentStep}. Accepts **either**
+* a raw snapshot **or** a prior `AgentStep` as the second argument —
+* `.snapshot` is unwrapped automatically, so callers can thread the whole
+* step object through without manually plucking the snapshot out.
+*/
+function transitionAgentStep(machine, snapshotOrStep, event, options) {
+	const [nextSnapshot, actions] = transition(machine, isAgentStep(snapshotOrStep) ? snapshotOrStep.snapshot : snapshotOrStep, event);
+	return createAgentStep(machine, nextSnapshot, actions, getRegisteredAgentExecutionOptions(machine, options));
+}
+/**
+* Applies a resolved text request's output (a `kind: 'text'`
+* {@link AgentRequest} — not a decision) as a done event and returns the
+* next {@link AgentStep}. For decisions, resolve with `resolveDecision`
+* (which returns a {@link ChosenEvent}) and apply it with
+* {@link transitionAgentStep} instead — a decision has no output value of
+* its own to feed here.
+*/
+function resolveAgentStep(machine, step, request, output, options) {
+	const [snapshot, actions] = transitionResult(machine, step.snapshot, request, output);
+	return createAgentStep(machine, snapshot, actions, getRegisteredAgentExecutionOptions(machine, options));
+}
+/**
+* Rejects a pending invoke — the failure counterpart of
+* {@link resolveAgentStep}. Delivers `error` as the invoke's
+* `xstate.error.actor` event, so the machine takes that invoke's `onError`
+* transition and returns the next {@link AgentStep}. With no `onError` in
+* scope the returned step's snapshot has `status: 'error'`, exactly as a live
+* run's failed invoke does.
+*
+* A durable host replays a failed call with this: the log says the call
+* failed, so the replay rejects the invoke instead of resolving it. Scripted
+* playthroughs use it too — see `simulateAgent`'s `script.errors`.
+*
+* `error` can be any value. An `Error` instance is the usual one, but a plain
+* object (`{ code: 'truncated' }`) reaches the `onError` transition as
+* `event.error` untouched, so a machine that branches on a failure code is
+* testable without constructing a provider's error class.
+*/
+function rejectAgentStep(machine, step, request, error, options) {
+	const [snapshot, actions] = transitionResult(machine, step.snapshot, request, error, "error");
+	return createAgentStep(machine, snapshot, actions, getRegisteredAgentExecutionOptions(machine, options));
+}
+function createAgentStep(machine, snapshot, actions, options) {
+	applyFinalStateOutput(machine, snapshot);
+	return {
+		snapshot,
+		actions,
+		requests: getAgentRequests(getPendingInvokes(snapshot), {
+			...options,
+			snapshot
+		}),
+		done: snapshot.status === "done"
+	};
+}
+function resolveStateValueConfig(config, value) {
+	if (typeof value === "string") return config.states?.[value];
+	if (!value || typeof value !== "object") return;
+	for (const [key, childValue] of Object.entries(value)) {
+		const childConfig = config.states?.[key];
+		if (!childConfig) continue;
+		if (childConfig.type === "final") return childConfig;
+		const nested = resolveStateValueConfig(childConfig, childValue);
+		if (nested) return nested;
+	}
+}
+function applyFinalStateOutput(logic, snapshot, event) {
+	const machineSnapshot = snapshot;
+	if (machineSnapshot.status !== "done" || machineSnapshot.output !== void 0 || !("config" in logic)) return;
+	const config = logic.config;
+	if (!config) return;
+	const output = resolveStateValueConfig(config, machineSnapshot.value)?.output;
+	if (output === void 0) return;
+	machineSnapshot.output = typeof output === "function" ? output({
+		context: machineSnapshot.context,
+		event
+	}) : output;
+}
+function isAgentStep(value) {
+	return !!value && typeof value === "object" && "snapshot" in value && "actions" in value && "requests" in value;
+}
+//#endregion
 //#region src/verify.ts
 const DECIDE_SRC = "agent.decide";
 function normalizeInvokes(invoke) {
@@ -77,7 +322,7 @@ function checkDirectObjectSrc(ctx) {
 			code: "direct-object-src",
 			severity: "warning",
 			path: node.path,
-			message: `State '${node.path}' invokes a direct-object agent logic. Direct-object invoke srcs cannot be rebound by runAgent, so they inherit no host executors — call '.withExecutor(...)' on the logic, or register it as a string-keyed actor source (machine.provide({ actors: { name: logic } })) and invoke it by name.`
+			message: `State '${node.path}' invokes a direct-object agent logic. Direct-object invoke srcs cannot be rebound by the agent runtime, so they inherit no host executors — call '.withExecutor(...)' on the logic, or register it as a string-keyed actor source (machine.provide({ actors: { name: logic } })) and invoke it by name.`
 		});
 	}
 	return out;
@@ -811,11 +1056,13 @@ function matcherFor(expected) {
 * @example Trajectory assertions in a test
 * ```ts
 * const statePath: unknown[] = [];
-* const result = await runAgent(machine, {
-*   input,
-*   executors,
-*   onTransition: (snapshot) => statePath.push(snapshot.value),
-* });
+* const result = await runToQuiescence(
+*   createAgentRuntime(machine, {
+*     executors,
+*     onTransition: (snapshot) => statePath.push(snapshot.value),
+*   }),
+*   { input },
+* );
 *
 * const path = matchesTrajectory(statePath, ['prompting', 'drafting', 'sent']);
 * expect(path.matched, JSON.stringify(path.firstMiss)).toBe(true);
@@ -869,43 +1116,7 @@ function matchesTrajectory(actual, expected, options = {}) {
 	};
 }
 //#endregion
-//#region src/scripted-executors.ts
-/**
-* Scripted executors — a deterministic stand-in for a model host.
-*
-* `createScriptedExecutors` builds a full `{ generateText, streamText, decide }`
-* set that plays back canned answers keyed by
-* request name, so `runAgent` (or `provideExecutors`, or a bare
-* `TextLogic.execute`) runs with no API key and no network.
-*
-* One rule: entries for a name are consumed in order, and the last entry
-* repeats forever.
-*
-* @module
-*/
-function toQueues(value) {
-	return new Map(Object.entries(value ?? {}).map(([name, entries]) => [name, {
-		entries: Array.isArray(entries) ? [...entries] : [entries],
-		index: 0
-	}]));
-}
-/**
-* Takes the next entry for `name`, holding on the last entry once the list is
-* spent. `undefined` means the script has no route for this name at all.
-* @internal
-*/
-function takeEntry(queues, name) {
-	const queue = queues.get(name) ?? queues.get("*");
-	if (!queue || queue.entries.length === 0) return;
-	const entry = queue.entries[Math.min(queue.index, queue.entries.length - 1)];
-	queue.index++;
-	return entry;
-}
-/** @internal */
-function noAnswer(name, queues) {
-	const known = [...queues.keys()].join(", ") || "(none)";
-	return /* @__PURE__ */ new Error(`No scripted answer for request '${name}'. Known: ${known}`);
-}
+//#region src/seam.ts
 /** The only own keys an executor result carries. @internal */
 const TEXT_RESULT_KEYS = new Set([
 	"result",
@@ -924,123 +1135,26 @@ function isTextResult(value) {
 	return Object.hasOwn(value, "result") && Object.keys(value).every((key) => TEXT_RESULT_KEYS.has(key));
 }
 /**
-* Resolves ONE scripted text entry to an executor result: a function entry is
+* Resolves ONE scripted entry to an executor result: a function entry is
 * called with the request, and the value is taken as the executor result only
-* when it is one (see {@link isTextResult}). Shared with `runSeam`, whose routed
-* queues follow the same entry conventions. @internal
+* when it is one (see {@link isTextResult}). @internal
 */
-async function resolveScriptedTextEntry(entry, request, info) {
+async function resolveSeamScriptEntry(entry, request, info) {
 	const value = typeof entry === "function" ? await entry(request, info) : entry;
 	return isRecord(value) && isTextResult(value) ? value : { result: value };
 }
-/**
-* Names a pending text request in an error message. Shared with `runSeam`.
-* @internal
-*/
+/** Names a pending text request in an error message. @internal */
 function describeText(request) {
 	return request.name ? `'${request.name}' (model '${request.model}')` : `(model '${request.model}')`;
 }
 /**
-* Stream semantics with no model: the whole text lands as one chunk. Shared
-* with `runSeam`, whose scripted answers stream the same way. @internal
+* Stream semantics with no model: the whole text lands as one chunk. @internal
 */
 function emitScriptedChunk(result, info) {
 	const text = isRecord(result) ? result["result"] : void 0;
 	if (typeof text === "string") info?.onChunk?.(text);
 }
 /**
-* Executors that replay a script instead of calling a model. Every slot is
-* provided, so any machine binds.
-*
-* Answers are keyed by the request's resolved name — its authored `name`, else
-* the invoke `id` — and `"*"` serves anything unmatched.
-* Entries for a name are consumed in order and the last one repeats forever, so
-* a looping machine needs no extra option. A request the script has no route
-* for throws an ordinary `Error` from inside the executor, which reaches the
-* machine as an actor error.
-*
-* Queues are copied on creation, so the caller's arrays are never mutated and
-* each call builds a fresh, independent playthrough. Entries may be plain
-* values or functions of the request.
-*
-* @example
-* ```ts
-* const result = await runAgent(moderationMachine, {
-*   input: { comment: 'honestly this update is terrible', trust: 20 },
-*   executors: createScriptedExecutors({
-*     decisions: { moderate: [{ type: 'FLAG', reason: 'Borderline tone.' }] },
-*   }),
-* });
-* ```
-*
-* @example Dynamic entries
-* ```ts
-* createScriptedExecutors({
-*   text: { draft: (request) => `Draft about ${request.prompt}` },
-*   decisions: { route: (request) => ({ type: request.events[0]!.type }) },
-* });
-* ```
-*/
-function createScriptedExecutors(script = {}) {
-	const decisions = toQueues(script.decisions);
-	const text = toQueues(script.text);
-	const calls = [];
-	const withDefaultUsage = (result) => result.usage || !script.usage ? result : {
-		...result,
-		usage: script.usage
-	};
-	const nextText = async (kind, request, info) => {
-		const name = request.name ?? "*";
-		calls.push({
-			kind,
-			name,
-			input: request.input,
-			request
-		});
-		const entry = takeEntry(text, name);
-		if (entry === void 0) throw noAnswer(name, text);
-		return withDefaultUsage(await resolveScriptedTextEntry(entry, request, info));
-	};
-	return {
-		calls,
-		generateText: (request, info) => nextText("generateText", request, info),
-		streamText: async (request, info) => {
-			const name = request.name ?? "*";
-			const streamEntry = script.stream?.[name] ?? script.stream?.["*"];
-			if (streamEntry !== void 0) {
-				calls.push({
-					kind: "streamText",
-					name,
-					input: request.input,
-					request
-				});
-				const resolved = typeof streamEntry === "function" ? await streamEntry(request, info) : streamEntry;
-				const chunks = typeof resolved === "string" ? [resolved] : [...resolved];
-				for (const chunk of chunks) info?.onChunk?.(chunk);
-				return withDefaultUsage({ result: chunks.join("") });
-			}
-			const result = await nextText("streamText", request, info);
-			emitScriptedChunk(result, info);
-			return result;
-		},
-		decide: async (request) => {
-			const name = request.name ?? request.id;
-			calls.push({
-				kind: "decide",
-				name,
-				input: request.input,
-				request
-			});
-			const entry = takeEntry(decisions, name);
-			if (entry === void 0) throw noAnswer(name, decisions);
-			const value = typeof entry === "function" ? await entry(request) : entry;
-			return withDefaultUsage(isRecord(value) && typeof value["type"] !== "string" && "event" in value ? value : { event: value });
-		}
-	};
-}
-//#endregion
-//#region src/seam.ts
-/**
 * The seam's own answer, for scoring: the executor result's `result`.
 * @internal
 */
@@ -1062,8 +1176,8 @@ async function seamOutputOf(result, request) {
 * @example No API key: the seam is scripted too, so the whole thing runs offline.
 * ```ts
 * const run = await runSeam(emailDrafter, {
-*   scripts: { promptEvaluator: [vague, complete], emailDrafter: [draft] },
-*   seam: { request: 'evaluatePrompt' },
+*   scripts: { writeFollowUps: [followUps], emailDrafter: [draft] },
+*   seam: { request: 'writeFollowUps' },
 *   respond: ({ state }) => (state === 'prompting' ? { type: 'PROMPT_SUBMITTED', prompt } : null),
 * });
 *
@@ -1099,7 +1213,7 @@ async function runSeam(machine, options) {
 	const takeScriptedSlot = async (request, info) => {
 		const queue = queues.get(queueKeyOf(request));
 		if (!queue?.length) return;
-		return resolveScriptedTextEntry(options.repeatLast && queue.length === 1 ? queue[0] : queue.shift(), request, info);
+		return resolveSeamScriptEntry(options.repeatLast && queue.length === 1 ? queue[0] : queue.shift(), request, info);
 	};
 	const scriptedAnswer = async (request, info) => {
 		const scripted = await takeScriptedSlot(request, info);
@@ -1156,9 +1270,7 @@ async function runSeam(machine, options) {
 	let result;
 	const maxTurns = options.maxTurns ?? 12;
 	for (let turn = 0; turn <= maxTurns; turn++) {
-		result = await runAgent(machine, {
-			...snapshot ? { snapshot } : { input: options.input },
-			...event ? { event } : {},
+		result = await runToQuiescence(createAgentRuntime(machine, {
 			...options.actors ? { actors: options.actors } : {},
 			executors,
 			onTransition: (next, causedBy) => {
@@ -1167,6 +1279,9 @@ async function runSeam(machine, options) {
 				liveEvents = events.length;
 				statePath.push(next.value);
 			}
+		}), {
+			...snapshot ? { snapshot } : { input: options.input },
+			...event ? { event } : {}
 		});
 		if (result.status !== "idle" || turn === maxTurns) break;
 		const next = options.respond?.({
@@ -1209,4 +1324,4 @@ async function runSeam(machine, options) {
 	};
 }
 //#endregion
-export { AgentLintError, AgentUnknownStateError, assertAgentMachine, canReach, createScriptedExecutors, explorePaths, lintAgentMachine, matchesTrajectory, runSeam, simulateAgent };
+export { AgentLintError, AgentUnknownStateError, assertAgentMachine, canReach, explorePaths, lintAgentMachine, matchesTrajectory, runSeam, simulateAgent };

package/dist/{text-logic-Bl_ZRxDi.mjs → text-logic-CIqHAmBi.mjs}

@@ -125,7 +125,7 @@ function findNonSerializableContextPaths(context, limit = 5) {
 * 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
+* Used by {@link createAgentRuntime} 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.
@@ -136,7 +136,7 @@ function getMachineStructuralHash(machine) {
 /**
 * 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`,
+* {@link getMachineStructuralHash}. Single source of truth so `createAgentRuntime`,
 * `provideExecutors`/`traceTransitions` trace envelopes agree.
 * @internal
 */
@@ -327,7 +327,7 @@ function validateSchemaSync(schema, value) {
 * 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
+* rebound by `createAgentRuntime` — or by any host `.provide(...)` — still resolve the
 * schemas/actors `setupAgent` registered. Always write through
 * {@link setAgentExecutionOptions} and read through
 * {@link getAgentExecutionOptions}.
@@ -347,7 +347,7 @@ function setAgentExecutionOptions(machine, 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`
+* key so a `.provide(...)`-rebound machine (e.g. the one behind a `runToQuiescence`
 * result snapshot) resolves the same pack.
 */
 function getAgentExecutionOptions(machine) {
@@ -357,24 +357,9 @@ function getAgentExecutionOptions(machine) {
 	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
+* factory's second arg) — these are runnable as-is, so the runtime's bind check
 * must not reject them as direct-object invoke srcs. */
 const executorBoundLogics = /* @__PURE__ */ new WeakSet();
 function missingActor(src) {
@@ -408,7 +393,7 @@ const AGENT_FINISH_REASONS = new Set([
 /**
 * 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.
+* applied by the runtime 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`.
@@ -430,7 +415,7 @@ const AGENT_USAGE_TOKEN_FIELDS = [
 /**
 * 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`
+* the runtime applies before it delivers `'@agent.usage'`. Returns `undefined`
 * when the result reports no usage at all. Works for our `{ result, usage }`
 * shape, for a raw Vercel AI SDK result (its `LanguageModelUsage` carries
 * the same flat field names), and for any custom executor that follows the
@@ -585,8 +570,7 @@ function resolveTextLogicValue(value, args) {
 * 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.
+* adapter's `machine.provide(...)`, or `createAgentRuntime`'s `executors`.
 *
 * @example
 * ```ts
@@ -639,7 +623,7 @@ function createTextLogic(config, execute) {
 	};
 	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.");
+		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 createAgentRuntime/provideExecutors, or execute the XState effect in your host.");
 		const result = await execute({
 			input,
 			request: resolvedRequest,
@@ -830,4 +814,4 @@ function invalidGeneratorResult(id) {
 	return /* @__PURE__ */ new Error(`Executor for '${id}' returned an invalid result: executors must return { result } (the text string or structured object as \`result\`, plus optional \`messages\`, \`usage\` and other passthrough fields). Wrap a raw SDK result with an adapter such as createAiSdkExecutors.`);
 }
 //#endregion
-export { getJsonSchema as A, userMessage as B, isUnboundPlaceholder as C, assistantMessage as D, setAgentExecutionOptions as E, getStatePath as F, AgentError as H, isStandardSchema as I, resolveMachineVersion as L, getMachineStructuralHash as M, getMessageText as N, djb2Hex as O, getStateMeta as P, systemMessage as R, getRegisteredAgentExecutionOptions as S, missingActor as T, AgentTruncatedError as U, validateSchemaSync as V, resolveTextLogicValue as _, bindRequestExecutor as a, getAgentExecutionOptions as b, executeAgentTextRequest as c, getCallUsage as d, isTextLogic as f, providerOutputSchema as g, parseProviderOutput as h, STREAM_TEXT_ACTOR as i, getJsonSchemaSync as j, findNonSerializableContextPaths as k, getAgentOutputMode as l, parseOutput as m, DECIDE_ACTOR as n, builtinTextActors as o, normalizeGeneratorResult as p, GENERATE_TEXT_ACTOR as r, createTextLogic as s, AGENT_USAGE_TOKEN_FIELDS as t, getCallFinishReason as u, responseMessagesOf as v, machineIdlePredicates as w, getMachineIdlePredicate as x, executorBoundLogics as y, toolMessage as z };
+export { getMessageText as A, AgentTruncatedError as B, setAgentExecutionOptions as C, getJsonSchema as D, findNonSerializableContextPaths as E, systemMessage as F, toolMessage as I, userMessage as L, getStatePath as M, isStandardSchema as N, getJsonSchemaSync as O, resolveMachineVersion as P, validateSchemaSync as R, missingActor as S, djb2Hex as T, responseMessagesOf as _, bindRequestExecutor as a, getRegisteredAgentExecutionOptions as b, getAgentOutputMode as c, isTextLogic as d, normalizeGeneratorResult as f, resolveTextLogicValue as g, providerOutputSchema as h, STREAM_TEXT_ACTOR as i, getStateMeta as j, getMachineStructuralHash as k, getCallFinishReason as l, parseProviderOutput as m, DECIDE_ACTOR as n, builtinTextActors as o, parseOutput as p, GENERATE_TEXT_ACTOR as r, createTextLogic as s, AGENT_USAGE_TOKEN_FIELDS as t, getCallUsage as u, executorBoundLogics as v, assistantMessage as w, isUnboundPlaceholder as x, getAgentExecutionOptions as y, AgentError as z };