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

package/dist/testing.cjs

@@ -1,7 +1,253 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_text_logic = require("./text-logic-C8xyr6Ag.cjs");
-const require_decision = require("./decision-CM9CYZ6t.cjs");
-const require_run_agent = require("./run-agent-Cb1-LS5P.cjs");
+const require_text_logic = require("./text-logic-f5F5sCdc.cjs");
+const require_decision = require("./decision-CmM8-HHz.cjs");
+const require_run_agent = require("./run-agent-Dmf8GV2d.cjs");
+require("./validate.cjs");
+let xstate = require("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 = {
+		...require_text_logic.getRegisteredAgentExecutionOptions(machine),
+		...options
+	};
+	return actions.flatMap((action) => {
+		const params = getInvokeEffectMetadata(action);
+		if (!params || typeof params.src !== "string") return [];
+		if (typeof params.id !== "string" || params.id.length === 0) throw new Error(`Agent invoke '${params.src}' must define a durable string id.`);
+		const registeredLogic = require_text_logic.isTextLogic(params.logic) || require_decision.isDecisionLogic(params.logic) ? params.logic : options.actors?.[params.src];
+		if (require_decision.isDecisionLogic(registeredLogic)) {
+			const decisionRequest = registeredLogic.request(params.input);
+			const allowedEventTypes = registeredLogic.allowedEventTypes?.(params.input);
+			const events = options.snapshot ? require_decision.getAcceptedEvents(options.snapshot, {
+				events: options.events,
+				schemas: options.schemas,
+				eventTypes: allowedEventTypes
+			}) : [];
+			return [{
+				...decisionRequest,
+				id: params.id,
+				events
+			}];
+		}
+		const textLogic = require_text_logic.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 = (0, xstate.transition)(logic, snapshot, event);
+	applyFinalStateOutput(logic, result[0], event);
+	return result;
+}
+/**
+* Starts a machine and returns its first {@link AgentStep} — the step-path
+* equivalent of `initialTransition` plus request discovery. Begins the
+* durable/per-model-call-checkpoint loop: resolve each `step.requests` entry
+* (via {@link executeAgentRequest} for `kind: 'text'`, or
+* {@link resolveDecision} for `kind: 'decision'`), then advance with
+* {@link resolveAgentStep} or {@link transitionAgentStep}.
+*/
+function initialAgentStep(machine, input, options) {
+	const [snapshot, actions] = (0, xstate.initialTransition)(machine, input);
+	return createAgentStep(machine, snapshot, actions, require_text_logic.getRegisteredAgentExecutionOptions(machine, options));
+}
+/**
+* Applies an externally-sent event (e.g. a decision's chosen event, or a
+* human's reply) and returns the next {@link AgentStep}. Accepts **either**
+* a raw snapshot **or** a prior `AgentStep` as the second argument —
+* `.snapshot` is unwrapped automatically, so callers can thread the whole
+* step object through without manually plucking the snapshot out.
+*/
+function transitionAgentStep(machine, snapshotOrStep, event, options) {
+	const [nextSnapshot, actions] = (0, xstate.transition)(machine, isAgentStep(snapshotOrStep) ? snapshotOrStep.snapshot : snapshotOrStep, event);
+	return createAgentStep(machine, nextSnapshot, actions, require_text_logic.getRegisteredAgentExecutionOptions(machine, options));
+}
+/**
+* Applies a resolved text request's output (a `kind: 'text'`
+* {@link AgentRequest} — not a decision) as a done event and returns the
+* next {@link AgentStep}. For decisions, resolve with `resolveDecision`
+* (which returns a {@link ChosenEvent}) and apply it with
+* {@link transitionAgentStep} instead — a decision has no output value of
+* its own to feed here.
+*/
+function resolveAgentStep(machine, step, request, output, options) {
+	const [snapshot, actions] = transitionResult(machine, step.snapshot, request, output);
+	return createAgentStep(machine, snapshot, actions, require_text_logic.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, require_text_logic.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) {
@@ -78,7 +324,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;
@@ -192,7 +438,7 @@ function assertAgentMachine(machine, options = {}) {
 }
 function pendingInvokes(step) {
 	const out = [];
-	for (const metadata of require_run_agent.getPendingInvokes(step.snapshot)) if (typeof metadata.src === "string") out.push({
+	for (const metadata of getPendingInvokes(step.snapshot)) if (typeof metadata.src === "string") out.push({
 		id: metadata.id,
 		src: metadata.src
 	});
@@ -252,7 +498,7 @@ async function simulateAgent(machine, options) {
 		errors: mapValues(options.script.errors ?? {}, (arr) => [...arr]),
 		events: [...options.script.events ?? []]
 	};
-	let step = require_run_agent.initialAgentStep(machine, options.input);
+	let step = initialAgentStep(machine, options.input);
 	const trail = [{ state: step.snapshot.value }];
 	for (let i = 0; i < maxSteps; i++) {
 		if (step.done) return {
@@ -290,7 +536,7 @@ async function simulateAgent(machine, options) {
 			}
 			const taken = takeFromQueue(script.text, request.src);
 			if (!taken.found) throw scriptDryError("text", request.src, request.id);
-			step = require_run_agent.resolveAgentStep(machine, step, request, asTextResult(taken.value));
+			step = resolveAgentStep(machine, step, request, asTextResult(taken.value));
 			trail.push({
 				state: step.snapshot.value,
 				resolvedRequest: {
@@ -315,7 +561,7 @@ async function simulateAgent(machine, options) {
 			}
 			const taken = takeFromQueue(script.invokes, invoke.src);
 			if (!taken.found) throw scriptDryError("invoke", invoke.src, invoke.id);
-			step = require_run_agent.resolveAgentStep(machine, step, invoke.id, taken.value);
+			step = resolveAgentStep(machine, step, invoke.id, taken.value);
 			trail.push({
 				state: step.snapshot.value,
 				resolvedRequest: {
@@ -331,7 +577,7 @@ async function simulateAgent(machine, options) {
 		if (external.length > 0) {
 			const event = external.shift();
 			if (!step.snapshot.can(event)) throw new Error(`simulateAgent: scripted external event '${event.type}' cannot be taken in state ${JSON.stringify(step.snapshot.value)} (no handler, or its guard rejected it). A live run's send would be silently dropped here; fix the script's \`events\` queue.`);
-			step = require_run_agent.transitionAgentStep(machine, step, event);
+			step = transitionAgentStep(machine, step, event);
 			trail.push({
 				state: step.snapshot.value,
 				appliedEvent: event,
@@ -356,7 +602,7 @@ function queueKey(channel, src, id) {
 }
 function rejectScriptedRequest(machine, step, request, error, entry) {
 	const id = typeof request === "string" ? request : request.id;
-	const next = require_run_agent.rejectAgentStep(machine, step, request, error);
+	const next = rejectAgentStep(machine, step, request, error);
 	if (next.snapshot.status === "error") throw unhandledScriptedError(error, entry.kind, entry.src, id);
 	entry.trail.push({
 		state: next.snapshot.value,
@@ -394,7 +640,7 @@ async function applyScriptedDecision(machine, step, request, decisionSrc, invoke
 		});
 	} catch (error) {
 		if (!(error instanceof require_decision.AgentDecisionExhaustedError)) throw error;
-		const next = require_run_agent.rejectAgentStep(machine, step, request.id, error);
+		const next = rejectAgentStep(machine, step, request.id, error);
 		if (next.snapshot.status === "error") throw error;
 		trail.push({
 			state: next.snapshot.value,
@@ -402,7 +648,7 @@ async function applyScriptedDecision(machine, step, request, decisionSrc, invoke
 		});
 		return next;
 	}
-	const next = require_run_agent.transitionAgentStep(machine, step, chosen);
+	const next = transitionAgentStep(machine, step, chosen);
 	const rejected = dequeued.slice(0, -1);
 	trail.push({
 		state: next.snapshot.value,
@@ -412,7 +658,7 @@ async function applyScriptedDecision(machine, step, request, decisionSrc, invoke
 	return next;
 }
 function findInvokeMetadata(step, id) {
-	for (const metadata of require_run_agent.getPendingInvokes(step.snapshot)) {
+	for (const metadata of getPendingInvokes(step.snapshot)) {
 		if (metadata.id !== id) continue;
 		return {
 			...typeof metadata.src === "string" ? { src: metadata.src } : {},
@@ -472,7 +718,7 @@ async function explore(machine, options, stopWhen) {
 			reachedValues.push(snapshot.value);
 		}
 	};
-	const initial = require_run_agent.initialAgentStep(machine, options.input);
+	const initial = initialAgentStep(machine, options.input);
 	recordState(initial.snapshot);
 	if (stopWhen?.(initial.snapshot)) witness = [];
 	const advance = (step) => {
@@ -493,7 +739,7 @@ async function explore(machine, options, stopWhen) {
 					step: current,
 					blockedSrc: request.src
 				};
-				current = require_run_agent.resolveAgentStep(machine, current, request, asTextResult(textScript[request.src]));
+				current = resolveAgentStep(machine, current, request, asTextResult(textScript[request.src]));
 				recordState(current.snapshot);
 				continue;
 			}
@@ -520,7 +766,7 @@ async function explore(machine, options, stopWhen) {
 					step: current,
 					blockedSrc: invoke.src
 				};
-				current = require_run_agent.resolveAgentStep(machine, current, invoke.id, invokeOutputs[invoke.src]);
+				current = resolveAgentStep(machine, current, invoke.id, invokeOutputs[invoke.src]);
 				recordState(current.snapshot);
 				continue;
 			}
@@ -551,12 +797,12 @@ async function explore(machine, options, stopWhen) {
 				unexplored.push(`max-depth: stopped at path [${path.map((e) => e.type).join(", ")}]`);
 				return;
 			}
-			const failed = require_run_agent.rejectAgentStep(machine, settled, fork.id, errorScript[fork.src]);
+			const failed = rejectAgentStep(machine, settled, fork.id, errorScript[fork.src]);
 			recordState(failed.snapshot);
 			await visit(failed, [...path, { type: `xstate.error.actor.${fork.id}` }], depth + 1);
 			if (!fork.isDecision) {
 				if (fork.hasOutput) {
-					const resolved = require_run_agent.resolveAgentStep(machine, settled, fork.id, fork.output);
+					const resolved = resolveAgentStep(machine, settled, fork.id, fork.output);
 					recordState(resolved.snapshot);
 					await visit(resolved, path, depth + 1);
 				}
@@ -625,7 +871,7 @@ async function explore(machine, options, stopWhen) {
 				prunedByGuard++;
 				continue;
 			}
-			const next = require_run_agent.transitionAgentStep(machine, settled, event);
+			const next = transitionAgentStep(machine, settled, event);
 			recordState(next.snapshot);
 			await visit(next, [...path, event], depth + 1);
 		}
@@ -812,11 +1058,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);
@@ -870,43 +1118,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",
@@ -925,123 +1137,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 require_decision.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 = require_decision.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(require_decision.isRecord(value) && typeof value["type"] !== "string" && "event" in value ? value : { event: value });
-		}
-	};
-}
-//#endregion
-//#region src/seam.ts
-/**
 * The seam's own answer, for scoring: the executor result's `result`.
 * @internal
 */
@@ -1063,8 +1178,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),
 * });
 *
@@ -1100,7 +1215,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);
@@ -1157,9 +1272,7 @@ async function runSeam(machine, options) {
 	let result;
 	const maxTurns = options.maxTurns ?? 12;
 	for (let turn = 0; turn <= maxTurns; turn++) {
-		result = await require_run_agent.runAgent(machine, {
-			...snapshot ? { snapshot } : { input: options.input },
-			...event ? { event } : {},
+		result = await require_run_agent.runToQuiescence(require_run_agent.createAgentRuntime(machine, {
 			...options.actors ? { actors: options.actors } : {},
 			executors,
 			onTransition: (next, causedBy) => {
@@ -1168,6 +1281,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?.({
@@ -1214,7 +1330,6 @@ exports.AgentLintError = AgentLintError;
 exports.AgentUnknownStateError = AgentUnknownStateError;
 exports.assertAgentMachine = assertAgentMachine;
 exports.canReach = canReach;
-exports.createScriptedExecutors = createScriptedExecutors;
 exports.explorePaths = explorePaths;
 exports.lintAgentMachine = lintAgentMachine;
 exports.matchesTrajectory = matchesTrajectory;