@statelyai/agent 2.0.0-alpha.11 → 2.0.0-alpha.13

package/dist/machines.mjs

@@ -0,0 +1,741 @@
+import { n as setupAgent } from "./setup-agent-DAZZSjDS.mjs";
+//#region src/machines/internal.ts
+/** The builtin inline text request every preset lowers a request entry to. */
+const GENERATE_TEXT_SRC = "agent.generateText";
+/** The builtin decision actor the router and supervisor presets invoke. */
+const DECIDE_SRC = "agent.decide";
+/**
+* A permissive Standard Schema that carries a JSON Schema. Presets build their
+* own context/input/output schemas this way so the module stays dependency-free
+* (no Zod in `src/`) while `lintAgentMachine` and JSON tooling still see a
+* serializable shape.
+*
+* @internal
+*/
+function objectSchema(properties, required = []) {
+	const json = {
+		type: "object",
+		properties,
+		required: [...required]
+	};
+	return { "~standard": {
+		version: 1,
+		vendor: "statelyai-agent-machines",
+		validate: (value) => value !== null && typeof value === "object" ? { value } : { issues: [{ message: "Expected an object" }] },
+		jsonSchema: { input: () => json }
+	} };
+}
+/** A payload-less event schema (`{}` shorthand equivalent) with a JSON Schema. @internal */
+const emptyPayload = objectSchema({});
+/** JSON Schema fragments reused across preset context schemas. @internal */
+const jsonString = { type: "string" };
+/** @internal */
+const jsonNumber = { type: "number" };
+/** @internal */
+const jsonRecord = {
+	type: "object",
+	additionalProperties: true
+};
+/** @internal */
+const jsonArray = { type: "array" };
+/** @internal */
+const jsonAny = {};
+/** True when `entry` delegates to a child machine rather than an inline request. @internal */
+function isMachineEntry(entry) {
+	return "machine" in entry && !!entry.machine;
+}
+/** The actor sources a preset must register: one per child-machine entry. @internal */
+function machineActors(entries) {
+	return Object.fromEntries(Object.entries(entries).filter(([, entry]) => isMachineEntry(entry)).map(([name, entry]) => [name, entry.machine]));
+}
+/** The `src` an entry invokes: its own actor key (child machine) or the inline text builtin. @internal */
+function entrySrc(name, entry) {
+	return isMachineEntry(entry) ? name : GENERATE_TEXT_SRC;
+}
+/** Builds an entry's invoke `input` from the current prompt. @internal */
+function entryInput(name, entry, defaultModel, prompt) {
+	if (isMachineEntry(entry)) return entry.input ? entry.input({ prompt }) : { prompt };
+	return requestInput(name, entry, defaultModel, prompt);
+}
+/** Builds the inline `agent.generateText` input for a request entry. @internal */
+function requestInput(name, entry, defaultModel, prompt) {
+	const model = entry.model ?? defaultModel;
+	if (!model) throw new Error(`Preset request '${name}' has no model. Set 'model' on the entry or on the factory config.`);
+	return {
+		name,
+		model,
+		...entry.instructions ? { system: entry.instructions } : {},
+		prompt,
+		...entry.tools ? { tools: entry.tools } : {},
+		...entry.outputSchema ? { outputSchema: entry.outputSchema } : {},
+		...entry.maxTurns !== void 0 ? { metadata: { maxSteps: entry.maxTurns } } : {}
+	};
+}
+/**
+* Rejects an entry name that would collide with a preset's own state names or
+* with the reserved `agent.*` actor namespace. A collision is otherwise a
+* confusing machine-build failure far from its cause.
+*
+* @internal
+*/
+function assertEntryNames(kind, names, reserved) {
+	if (names.length === 0) throw new Error(`Preset requires at least one ${kind}.`);
+	for (const name of names) {
+		if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) throw new Error(`Invalid ${kind} name '${name}'. Names must be identifier-like (letters, digits, underscore; not starting with a digit) — they become state names and event types.`);
+		if (reserved.includes(name)) throw new Error(`Invalid ${kind} name '${name}': it collides with a state this preset already declares (${reserved.join(", ")}). Rename it.`);
+	}
+}
+/** Renders the `name: description` list a routing/supervising model chooses from. @internal */
+function renderEntryList(entries) {
+	return Object.entries(entries).map(([name, entry]) => `- ${name}: ${entry.description ?? "(no description)"}`).join("\n");
+}
+//#endregion
+//#region src/machines/tool-loop.ts
+const contextSchema$6 = objectSchema({
+	prompt: jsonString,
+	result: jsonAny
+}, ["prompt"]);
+const inputSchema$6 = objectSchema({ prompt: jsonString }, ["prompt"]);
+const outputSchema$5 = objectSchema({ result: jsonAny }, ["result"]);
+/**
+* The single-state tool loop: one text request carries the `tools`, and the
+* host runs the tool loop inside it (`maxTurns` bounds it). Selecting and
+* executing tools is the model + host's business, not machine states.
+*
+* States: `answering` → `done`.
+*
+* ```ts
+* const machine = createToolLoopMachine({
+*   model: "quick",
+*   instructions: "Answer using the tools.",
+*   tools: { calculate },
+*   maxTurns: 5,
+* });
+*
+* const result = await runAgent(machine, {
+*   input: { prompt: "What is 42 * 17?" },
+*   executors,
+* });
+* // Snapshots and log entries carry machine.version ("1") automatically.
+* ```
+*/
+function createToolLoopMachine(config) {
+	const { model, instructions, tools, outputSchema: resultSchema, maxTurns, interruptOn } = config;
+	const metadata = {
+		...maxTurns !== void 0 ? { maxSteps: maxTurns } : {},
+		...interruptOn && interruptOn.length > 0 ? { interruptOn: [...interruptOn] } : {}
+	};
+	return setupAgent({
+		context: contextSchema$6,
+		input: inputSchema$6,
+		output: outputSchema$5
+	}).createMachine({
+		id: "tool-loop",
+		version: "1",
+		context: ({ input }) => ({
+			prompt: input.prompt,
+			result: null
+		}),
+		initial: "answering",
+		states: {
+			answering: { invoke: {
+				id: "answer",
+				src: GENERATE_TEXT_SRC,
+				input: ({ context }) => ({
+					name: "answer",
+					model,
+					...instructions ? { system: instructions } : {},
+					prompt: context.prompt,
+					...tools ? { tools } : {},
+					...resultSchema ? { outputSchema: resultSchema } : {},
+					...Object.keys(metadata).length > 0 ? { metadata } : {}
+				}),
+				onDone: ({ output }) => ({
+					target: "done",
+					context: { result: output }
+				})
+			} },
+			done: {
+				type: "final",
+				output: ({ context }) => ({ result: context.result })
+			}
+		}
+	});
+}
+//#endregion
+//#region src/machines/sequential.ts
+const contextSchema$5 = objectSchema({
+	prompt: jsonString,
+	results: jsonRecord,
+	previous: jsonAny
+}, ["prompt", "results"]);
+const inputSchema$5 = objectSchema({ prompt: jsonString }, ["prompt"]);
+const outputSchema$4 = objectSchema({
+	results: jsonRecord,
+	output: jsonAny
+}, ["results"]);
+/**
+* A prompt chain: each step is one state, and each step's output feeds the
+* next. The default prompt for a step is the previous step's output, so a
+* chain needs no `prompt` functions at all.
+*
+* States: one per step, in order → `done`.
+*
+* ```ts
+* const machine = createSequentialMachine({
+*   model: "quick",
+*   steps: [
+*     { name: "outline", instructions: "Outline the post." },
+*     { name: "draft", instructions: "Write the post from the outline." },
+*     { name: "polish", instructions: "Tighten the prose." },
+*   ],
+* });
+* ```
+*/
+function createSequentialMachine(config) {
+	const { model, steps } = config;
+	assertEntryNames("step", steps.map((step) => step.name), ["done"]);
+	const agentSetup = setupAgent({
+		context: contextSchema$5,
+		input: inputSchema$5,
+		output: outputSchema$4
+	});
+	const states = {};
+	steps.forEach((step, index) => {
+		const next = steps[index + 1]?.name ?? "done";
+		states[step.name] = { invoke: {
+			id: step.name,
+			src: GENERATE_TEXT_SRC,
+			input: ({ context }) => requestInput(step.name, {
+				instructions: step.instructions,
+				model: step.model,
+				outputSchema: step.outputSchema,
+				tools: step.tools,
+				maxTurns: step.maxTurns
+			}, model, step.prompt ? step.prompt({
+				prompt: context.prompt,
+				results: context.results,
+				previous: context.previous
+			}) : context.previous === null || context.previous === void 0 ? context.prompt : String(context.previous)),
+			onDone: ({ context, output }) => ({
+				target: next,
+				context: {
+					results: {
+						...context.results,
+						[step.name]: output
+					},
+					previous: output
+				}
+			})
+		} };
+	});
+	states.done = {
+		type: "final",
+		output: ({ context }) => ({
+			results: context.results,
+			output: context.previous
+		})
+	};
+	const machineConfig = {
+		id: "sequential",
+		version: "1",
+		context: ({ input }) => ({
+			prompt: input.prompt,
+			results: {},
+			previous: null
+		}),
+		initial: steps[0].name,
+		states
+	};
+	return agentSetup.createMachine(machineConfig);
+}
+//#endregion
+//#region src/machines/router.ts
+const contextSchema$4 = objectSchema({
+	prompt: jsonString,
+	route: { type: ["string", "null"] },
+	result: jsonAny
+}, ["prompt"]);
+const inputSchema$4 = objectSchema({ prompt: jsonString }, ["prompt"]);
+const outputSchema$3 = objectSchema({
+	route: { type: ["string", "null"] },
+	result: jsonAny
+}, ["route"]);
+/** The event a route decision chooses: `ROUTE_<name>`. */
+function routeEventType(route) {
+	return `ROUTE_${route}`;
+}
+/**
+* One `agent.decide` picks exactly one declared route, then the machine runs
+* it. Only the declared routes have events and transitions, so a model naming
+* anything else is rejected before any work happens — illegal routes are
+* impossible, not discouraged.
+*
+* States: `routing` → one state per route → `done`.
+*
+* ```ts
+* const machine = createRouterMachine({
+*   model: "quick",
+*   routes: {
+*     billing: { description: "Payments and invoices", instructions: "Answer the billing question." },
+*     technical: { description: "Bugs and outages", machine: technicalMachine },
+*   },
+*   fallback: "technical",
+* });
+* ```
+*/
+function createRouterMachine(config) {
+	const { model, instructions, routes, fallback } = config;
+	const names = Object.keys(routes);
+	assertEntryNames("route", names, ["routing", "done"]);
+	if (fallback !== void 0 && !names.includes(fallback)) throw new Error(`createRouterMachine: fallback '${fallback}' is not a declared route (${names.join(", ")}).`);
+	const agentSetup = setupAgent({
+		context: contextSchema$4,
+		input: inputSchema$4,
+		output: outputSchema$3,
+		events: Object.fromEntries(names.map((name) => [routeEventType(name), emptyPayload])),
+		actors: machineActors(routes)
+	});
+	const routeList = renderEntryList(routes);
+	const states = {
+		routing: {
+			invoke: {
+				id: "route",
+				src: DECIDE_SRC,
+				input: ({ context }) => ({
+					model,
+					system: instructions ?? "Route the request to exactly one destination. Choose the single best fit.",
+					prompt: `Request:\n${context.prompt}\n\nDestinations:\n${routeList}`,
+					allowedEvents: names.map(routeEventType)
+				}),
+				...fallback ? { onError: {
+					target: fallback,
+					context: { route: fallback }
+				} } : {}
+			},
+			on: Object.fromEntries(names.map((name) => [routeEventType(name), {
+				target: name,
+				context: { route: name }
+			}]))
+		},
+		done: {
+			type: "final",
+			output: ({ context }) => ({
+				route: context.route,
+				result: context.result
+			})
+		}
+	};
+	for (const [name, entry] of Object.entries(routes)) states[name] = { invoke: {
+		id: name,
+		src: entrySrc(name, entry),
+		input: ({ context }) => entryInput(name, entry, model, context.prompt),
+		onDone: ({ output }) => ({
+			target: "done",
+			context: { result: output }
+		})
+	} };
+	const machineConfig = {
+		id: "router",
+		version: "1",
+		context: ({ input }) => ({
+			prompt: input.prompt,
+			route: null,
+			result: null
+		}),
+		initial: "routing",
+		states
+	};
+	return agentSetup.createMachine(machineConfig);
+}
+//#endregion
+//#region src/machines/parallel.ts
+const contextSchema$3 = objectSchema({
+	prompt: jsonString,
+	results: jsonRecord
+}, ["prompt", "results"]);
+const inputSchema$3 = objectSchema({ prompt: jsonString }, ["prompt"]);
+const outputSchema$2 = objectSchema({ results: jsonRecord }, ["results"]);
+/**
+* Static fan-out: every branch runs concurrently as its own region of one
+* parallel state, and the run joins when all of them finish. Results are keyed
+* by branch name.
+*
+* Branch count is fixed at author time. For an N decided at run time (a planner
+* choosing subtopics), eject to `examples/fan-out`, which spawns branches
+* dynamically.
+*
+* States: `running` (one region per branch) → `done`.
+*
+* ```ts
+* const machine = createParallelMachine({
+*   model: "quick",
+*   branches: {
+*     security: { instructions: "Review for security issues." },
+*     performance: { instructions: "Review for performance issues." },
+*   },
+* });
+* ```
+*/
+function createParallelMachine(config) {
+	const { model, branches } = config;
+	assertEntryNames("branch", Object.keys(branches), ["running", "done"]);
+	const agentSetup = setupAgent({
+		context: contextSchema$3,
+		input: inputSchema$3,
+		output: outputSchema$2,
+		actors: machineActors(branches)
+	});
+	const regions = {};
+	for (const [name, entry] of Object.entries(branches)) regions[name] = {
+		initial: "running",
+		states: {
+			running: { invoke: {
+				id: name,
+				src: entrySrc(name, entry),
+				input: ({ context }) => entryInput(name, entry, model, context.prompt),
+				onDone: ({ context, output }) => ({
+					target: "done",
+					context: { results: {
+						...context.results,
+						[name]: output
+					} }
+				})
+			} },
+			done: { type: "final" }
+		}
+	};
+	const machineConfig = {
+		id: "parallel",
+		version: "1",
+		context: ({ input }) => ({
+			prompt: input.prompt,
+			results: {}
+		}),
+		initial: "running",
+		states: {
+			running: {
+				type: "parallel",
+				states: regions,
+				onDone: { target: "done" }
+			},
+			done: {
+				type: "final",
+				output: ({ context }) => ({ results: context.results })
+			}
+		}
+	};
+	return agentSetup.createMachine(machineConfig);
+}
+//#endregion
+//#region src/machines/loop.ts
+const contextSchema$2 = objectSchema({
+	prompt: jsonString,
+	iterations: jsonNumber,
+	results: jsonArray,
+	last: jsonAny
+}, [
+	"prompt",
+	"iterations",
+	"results"
+]);
+const inputSchema$2 = objectSchema({ prompt: jsonString }, ["prompt"]);
+const outputSchema$1 = objectSchema({
+	iterations: jsonNumber,
+	results: jsonArray,
+	last: jsonAny
+}, ["iterations", "results"]);
+/**
+* A bounded repeat: run the body, check `until` over the accumulated state,
+* and either stop or go again. `maxIterations` is a guard, so the loop cannot
+* run away even if `until` never returns `true`.
+*
+* States: `running` → `checking` → (`running` | `done`).
+*
+* ```ts
+* const machine = createLoopMachine({
+*   model: "quick",
+*   body: { instructions: "Improve the draft. Return only the draft." },
+*   until: ({ last }) => String(last).length > 500,
+*   maxIterations: 4,
+* });
+* ```
+*/
+function createLoopMachine(config) {
+	const { model, body, until, maxIterations } = config;
+	if (!Number.isInteger(maxIterations) || maxIterations < 1) throw new Error("createLoopMachine: maxIterations must be an integer >= 1.");
+	const agentSetup = setupAgent({
+		context: contextSchema$2,
+		input: inputSchema$2,
+		output: outputSchema$1,
+		actors: isMachineEntry(body) ? { body: body.machine } : {}
+	});
+	const loopState = (context) => ({
+		prompt: context.prompt,
+		iterations: context.iterations,
+		results: context.results,
+		last: context.last
+	});
+	const machineConfig = {
+		id: "loop",
+		version: "1",
+		context: ({ input }) => ({
+			prompt: input.prompt,
+			iterations: 0,
+			results: [],
+			last: null
+		}),
+		initial: "running",
+		states: {
+			running: { invoke: {
+				id: "body",
+				src: entrySrc("body", body),
+				input: ({ context }) => entryInput("body", body, model, body.prompt ? body.prompt(loopState(context)) : context.prompt),
+				onDone: ({ context, output }) => ({
+					target: "checking",
+					context: {
+						iterations: context.iterations + 1,
+						results: [...context.results, output],
+						last: output
+					}
+				})
+			} },
+			checking: {
+				type: "choice",
+				choice: ({ context }) => context.iterations >= maxIterations || until(loopState(context)) ? { target: "done" } : { target: "running" }
+			},
+			done: {
+				type: "final",
+				output: ({ context }) => ({
+					iterations: context.iterations,
+					results: context.results,
+					last: context.last
+				})
+			}
+		}
+	};
+	return agentSetup.createMachine(machineConfig);
+}
+//#endregion
+//#region src/machines/supervisor.ts
+const contextSchema$1 = objectSchema({
+	task: jsonString,
+	results: jsonRecord,
+	turns: jsonNumber,
+	worker: { type: ["string", "null"] }
+}, [
+	"task",
+	"results",
+	"turns"
+]);
+const inputSchema$1 = objectSchema({ task: jsonString }, ["task"]);
+const outputSchema = objectSchema({
+	results: jsonRecord,
+	turns: jsonNumber
+}, ["results", "turns"]);
+/** The event a supervising decision chooses to delegate to a worker: `DELEGATE_<name>`. */
+function delegateEventType(worker) {
+	return `DELEGATE_${worker}`;
+}
+/** The event a supervising decision chooses to stop. */
+const FINISH_EVENT_TYPE = "FINISH";
+/**
+* A supervisor delegating to typed workers: each turn, one `agent.decide`
+* picks a worker or `FINISH`. Worker results accumulate in context and are fed
+* back into the next decision.
+*
+* Control always returns to the supervisor after a worker finishes — that is
+* what separates this from {@link createHandoffMachine}, where control
+* transfers and does not come back.
+*
+* `maxTurns` bounds the delegations twice over: a spent budget removes every
+* `DELEGATE_*` from the decision's candidate events, and a guard on each
+* delegate transition rejects one anyway. `FINISH` is all that is left.
+*
+* States: `supervising` → one state per worker → `supervising` → … → `done`.
+*
+* ```ts
+* const machine = createSupervisorMachine({
+*   model: "quick",
+*   workers: {
+*     researcher: { description: "Facts and background", instructions: "Research it." },
+*     writer: { description: "Prose and summaries", instructions: "Write it up." },
+*   },
+*   maxTurns: 4,
+* });
+* ```
+*/
+function createSupervisorMachine(config) {
+	const { model, instructions, workers, maxTurns = 6 } = config;
+	const names = Object.keys(workers);
+	assertEntryNames("worker", names, ["supervising", "done"]);
+	if (!Number.isInteger(maxTurns) || maxTurns < 1) throw new Error("createSupervisorMachine: maxTurns must be an integer >= 1.");
+	const agentSetup = setupAgent({
+		context: contextSchema$1,
+		input: inputSchema$1,
+		output: outputSchema,
+		events: {
+			...Object.fromEntries(names.map((name) => [delegateEventType(name), emptyPayload])),
+			[FINISH_EVENT_TYPE]: emptyPayload
+		},
+		actors: machineActors(workers)
+	});
+	const workerList = renderEntryList(workers);
+	const states = {
+		supervising: {
+			invoke: {
+				id: "supervise",
+				src: DECIDE_SRC,
+				input: ({ context }) => ({
+					model,
+					system: instructions ?? "You are a supervisor. Delegate the task to one worker at a time, then finish once the accumulated results answer it.",
+					prompt: `Task:\n${context.task}\n\nWorkers:\n${workerList}\n\nResults so far:\n${renderResults(context.results)}\n\nTurns used: ${context.turns} of ${maxTurns}.`,
+					allowedEvents: context.turns < maxTurns ? [...names.map(delegateEventType), FINISH_EVENT_TYPE] : [FINISH_EVENT_TYPE]
+				})
+			},
+			on: {
+				...Object.fromEntries(names.map((name) => [delegateEventType(name), ({ context }) => context.turns < maxTurns ? {
+					target: name,
+					context: { worker: name }
+				} : void 0])),
+				[FINISH_EVENT_TYPE]: { target: "done" }
+			}
+		},
+		done: {
+			type: "final",
+			output: ({ context }) => ({
+				results: context.results,
+				turns: context.turns
+			})
+		}
+	};
+	for (const [name, entry] of Object.entries(workers)) states[name] = { invoke: {
+		id: name,
+		src: entrySrc(name, entry),
+		input: ({ context }) => entryInput(name, entry, model, context.task),
+		onDone: ({ context, output }) => ({
+			target: "supervising",
+			context: {
+				results: {
+					...context.results,
+					[name]: output
+				},
+				turns: context.turns + 1
+			}
+		})
+	} };
+	const machineConfig = {
+		id: "supervisor",
+		version: "1",
+		context: ({ input }) => ({
+			task: input.task,
+			results: {},
+			turns: 0,
+			worker: null
+		}),
+		initial: "supervising",
+		states
+	};
+	return agentSetup.createMachine(machineConfig);
+}
+function renderResults(results) {
+	const entries = Object.entries(results);
+	if (entries.length === 0) return "(none yet)";
+	return entries.map(([name, value]) => `- ${name}: ${typeof value === "string" ? value : JSON.stringify(value)}`).join("\n");
+}
+//#endregion
+//#region src/machines/handoff.ts
+const contextSchema = objectSchema({
+	message: jsonString,
+	activeAgent: jsonString,
+	reply: jsonAny
+}, ["message", "activeAgent"]);
+const inputSchema = objectSchema({
+	message: jsonString,
+	activeAgent: jsonString
+}, ["message"]);
+const transferPayload = objectSchema({ message: jsonString });
+/** The event that hands the mic to a peer: `transfer_to_<name>`. */
+function transferEventType(agent) {
+	return `transfer_to_${agent}`;
+}
+/**
+* Peer handoff (the swarm shape): `context.activeAgent` holds the mic, runs one
+* turn, then the machine settles idle in `waiting`. A `transfer_to_<name>`
+* event moves the mic to a peer and re-routes.
+*
+* Control TRANSFERS and does not return — the opposite of
+* {@link createSupervisorMachine}, where every worker hands control back.
+*
+* There is no final state: a conversation ends when the host stops resuming it.
+* Persist the idle snapshot between turns; `activeAgent` round-trips with it.
+*
+* States: `routing` → one turn state per agent → `waiting` → `routing` → …
+*
+* ```ts
+* const machine = createHandoffMachine({
+*   model: "quick",
+*   defaultActiveAgent: "travel",
+*   agents: {
+*     travel: { description: "Destinations and itineraries", instructions: "You are a travel concierge." },
+*     food: { description: "Restaurants and dishes", instructions: "You are a food concierge." },
+*   },
+* });
+*
+* const next = await runAgent(machine, {
+*   snapshot,
+*   event: { type: "transfer_to_food", message: "What should I eat there?" },
+*   executors,
+* });
+* ```
+*/
+function createHandoffMachine(config) {
+	const { agents, defaultActiveAgent, model } = config;
+	const names = Object.keys(agents);
+	assertEntryNames("agent", names, ["routing", "waiting"]);
+	if (!names.includes(defaultActiveAgent)) throw new Error(`createHandoffMachine: defaultActiveAgent '${defaultActiveAgent}' is not a declared agent (${names.join(", ")}).`);
+	const agentSetup = setupAgent({
+		context: contextSchema,
+		input: inputSchema,
+		events: Object.fromEntries(names.map((name) => [transferEventType(name), transferPayload])),
+		actors: machineActors(agents),
+		isSuspended: (snapshot) => snapshot.matches("waiting")
+	});
+	const turnState = (name) => `${name}Turn`;
+	const states = {
+		routing: {
+			type: "choice",
+			choice: ({ context }) => ({ target: names.includes(context.activeAgent) ? turnState(context.activeAgent) : turnState(defaultActiveAgent) })
+		},
+		waiting: { on: Object.fromEntries(names.map((name) => [transferEventType(name), ({ context, event }) => ({
+			target: "routing",
+			context: {
+				activeAgent: name,
+				message: event.message ?? context.message
+			}
+		})])) }
+	};
+	for (const [name, entry] of Object.entries(agents)) states[turnState(name)] = { invoke: {
+		id: name,
+		src: entrySrc(name, entry),
+		input: ({ context }) => entryInput(name, entry, model, context.message),
+		onDone: ({ output }) => ({
+			target: "waiting",
+			context: { reply: output }
+		})
+	} };
+	const machineConfig = {
+		id: "handoff",
+		version: "1",
+		context: ({ input }) => ({
+			message: input.message,
+			activeAgent: input.activeAgent ?? defaultActiveAgent,
+			reply: null
+		}),
+		initial: "routing",
+		states
+	};
+	return agentSetup.createMachine(machineConfig);
+}
+//#endregion
+export { FINISH_EVENT_TYPE, createHandoffMachine, createLoopMachine, createParallelMachine, createRouterMachine, createSequentialMachine, createSupervisorMachine, createToolLoopMachine, delegateEventType, routeEventType, transferEventType };