@statelyai/agent 1.1.5 → 2.0.0-alpha.10

package/dist/ai-sdk.d.mts

@@ -0,0 +1,206 @@
+import { C as StandardSchemaV1, m as ChosenEvent, n as AgentEventSchemaInputMap, u as AgentTools } from "./types-qm00QF91.mjs";
+import { H as AgentEventDescriptor, i as AgentRequestExecutor, j as AgentDecisionRequest, k as AgentDecisionExecutor, l as AgentTextRequest, s as AgentRequestExecutors } from "./text-logic-C7WJpCIc.mjs";
+import { D as AgentMachine, O as AgentMachineConfig, l as RunAgentOptions, u as RunAgentResult } from "./run-agent-DzYJb3CK.mjs";
+import * as _$xstate from "xstate";
+import { FinishReason, LanguageModel, LanguageModelUsage, ModelMessage, Tool, ToolSet, TypedToolCall, TypedToolResult } from "ai";
+
+//#region src/ai-sdk/index.d.ts
+/**
+ * Maps an {@link AgentTools} map onto AI SDK `tool()` definitions. A tool that
+ * already carries its own Standard Schema `inputSchema` — an AI SDK
+ * `tool({...})`, or any equivalent descriptor — is passed through **unchanged**,
+ * so the SDK applies its own validation, calls `execute(input, options)`, and
+ * every extra property (`providerOptions`, `toModelOutput`, …) survives. A bare
+ * `AgentToolExecute` function becomes a tool with an unconstrained input schema;
+ * a minimal descriptor with no readable schema is converted with a permissive
+ * fallback. Used internally by {@link toAiSdkCallSettings}; exported for callers
+ * building AI SDK calls by hand outside `createAiSdkExecutors`.
+ */
+declare function toAiSdkTools(tools: AgentTools): {
+  [k: string]: Tool<unknown, unknown> | Tool<unknown, never>;
+};
+/** AI SDK model registry: maps model refs (as used in `setupAgent({ models })`/`AgentTextRequest.model`) to AI SDK `LanguageModel` values. The optional `TKey` parameter pins the ref keys (see {@link defineModels}); it defaults to `string`, so bare `AiSdkModelMap` stays `Record<string, LanguageModel>`. */
+type AiSdkModelMap<TKey extends string = string> = Record<TKey, LanguageModel>;
+/**
+ * Identity helper for a `models` map whose value is exported. Returns the map
+ * unchanged, but types it as {@link AiSdkModelMap}`<keyof T & string>` — a
+ * portable, nameable type — so an exported `const models = defineModels({...})`
+ * needs no `Record<'a' | 'b', LanguageModel>` annotation and never triggers
+ * TS2742 ("inferred type cannot be named without a reference to …"). The exact
+ * ref keys survive, so `createAiSdkExecutors({ models })` and
+ * `setupAgent({ models })` still infer/autocomplete them.
+ *
+ * @example
+ * ```ts
+ * export const models = defineModels({
+ *   quick: openai('gpt-5.4-mini'),
+ *   deep: openai('gpt-5.4'),
+ * });
+ * // typeof models === AiSdkModelMap<'quick' | 'deep'>
+ * ```
+ */
+declare function defineModels<T extends Record<string, LanguageModel>>(models: T): AiSdkModelMap<keyof T & string>;
+/**
+ * Options for {@link createAiSdkExecutors}: either a static `models` map
+ * (model refs resolved by lookup), a `resolveModel` function (refs resolved
+ * dynamically, e.g. `"openai/gpt-5.4-mini"` → `openai('gpt-5.4-mini')`), or
+ * both — `resolveModel` takes precedence when both are supplied.
+ */
+type CreateAiSdkExecutorsOptions<TModels extends AiSdkModelMap = AiSdkModelMap> = {
+  models: TModels;
+  resolveModel?: (modelRef: keyof TModels & string) => LanguageModel;
+} | {
+  models?: TModels;
+  resolveModel: (modelRef: string) => LanguageModel;
+};
+/**
+ * AI SDK request-mapping settings shared by `generateText`/`streamText`.
+ * `AgentTextRequest.messages` (`AgentMessage[]`) and AI SDK's `ModelMessage[]`
+ * are structurally compatible by design (§1 of .scratch/p0-design.md) — the cast
+ * below is a typed identity mapping, not a semantic conversion.
+ */
+declare function toAiSdkCallSettings(request: AgentTextRequest & {
+  tools?: AgentTools;
+}): {
+  temperature: number | undefined;
+  maxOutputTokens: number | undefined;
+  topP: number | undefined;
+  topK: number | undefined;
+  seed: number | undefined;
+  stopSequences: string[] | undefined;
+  tools: {
+    [k: string]: Tool<unknown, unknown> | Tool<unknown, never>;
+  } | undefined;
+  toolChoice: "auto" | "none" | "required" | {
+    type: "tool";
+    toolName: string;
+  } | undefined;
+  messages: ModelMessage[];
+  system: string | undefined;
+} | {
+  temperature: number | undefined;
+  maxOutputTokens: number | undefined;
+  topP: number | undefined;
+  topK: number | undefined;
+  seed: number | undefined;
+  stopSequences: string[] | undefined;
+  tools: {
+    [k: string]: Tool<unknown, unknown> | Tool<unknown, never>;
+  } | undefined;
+  toolChoice: "auto" | "none" | "required" | {
+    type: "tool";
+    toolName: string;
+  } | undefined;
+  prompt: string;
+  system: string | undefined;
+};
+/** Maps an {@link AgentToolChoice} to AI SDK's tool-choice shape — `{ type: 'tool'; name }` becomes `{ type: 'tool'; toolName }`; `'auto'`/`'none'`/`'required'`/`undefined` pass through unchanged. */
+declare function toAiSdkToolChoice(toolChoice: AgentTextRequest["toolChoice"]): "auto" | "none" | "required" | {
+  type: "tool";
+  toolName: string;
+} | undefined;
+/** `true` when the request should use AI SDK structured `Output.object`. */
+declare function isStructuredOutputRequest(request: Pick<AgentTextRequest, "outputSchema">): boolean;
+/**
+ * Extracts the first complete top-level JSON value from `text`, or returns
+ * `undefined` when there is nothing to repair (no complete value, or the value
+ * already spans the whole text). Models occasionally emit two structured-output
+ * envelopes back to back (`{"result":{…}}{"result":{…}}`), which fails JSON
+ * parsing wholesale; the balanced scan below recovers the first value and
+ * drops the rest.
+ */
+declare function extractFirstJsonValue(text: string): string | undefined;
+/**
+ * Raw result shape from {@link AiSdkExecutors.generateText} — the `{ output }`
+ * envelope (the validated structured object for structured-output requests,
+ * or the accumulated text string otherwise; unwrapped by
+ * `normalizeGeneratorResult`) plus the AI SDK call metadata. Core only reads
+ * `output`; everything else flows verbatim to `runAgent`'s
+ * `onResult(request, { raw })`, so `raw as AiSdkGenerateResult` is the
+ * supported cast for token accounting and tracing.
+ */
+type AiSdkGenerateResult = {
+  output: unknown;
+  /** The model's reasoning, present only when the request opted in via
+   * `reasoning: true` and the model produced it (see the structured-output
+   * envelope in {@link buildEnvelopeSchema}). Never enters machine context/output. */
+  reasoning?: string;
+  usage: LanguageModelUsage;
+  finishReason: FinishReason;
+  toolCalls: TypedToolCall<ToolSet>[];
+  toolResults: TypedToolResult<ToolSet>[];
+};
+/** Raw result shape from {@link AiSdkExecutors.streamText} — the `{ output }` envelope carrying the fully-accumulated text once the stream finishes (chunks are delivered separately via `onChunk`), plus the stream's final usage/finish metadata for `onResult`. */
+type AiSdkStreamResult = {
+  output: string;
+  usage: LanguageModelUsage;
+  finishReason: FinishReason;
+};
+/** Raw result shape from {@link AiSdkExecutors.decide} — the chosen event plus the AI SDK call metadata, delivered per decision attempt to `onResult`. */
+type AiSdkDecideResult = {
+  event: ChosenEvent;
+  usage: LanguageModelUsage;
+  finishReason: FinishReason;
+};
+/** `createAiSdkExecutors` always populates all three slots (unlike the
+ * general `AgentRequestExecutors`, where `streamText`/`decide` are optional),
+ * and its `generateText`/`streamText` results are concretely typed. */
+interface AiSdkExecutors extends AgentRequestExecutors<AiSdkGenerateResult, AiSdkStreamResult> {
+  streamText: AgentRequestExecutor<AiSdkStreamResult>;
+  decide: AgentDecisionExecutor;
+}
+/**
+ * The canonical Vercel AI SDK adapter: builds the `{ generateText, streamText,
+ * decide }` executor set consumed by `runAgent`/`executeAgentRequest`. `ai`
+ * must not become a dependency of core `src/` files — this subpath is the one
+ * place it's imported, and callers must supply their own model resolver so no
+ * concrete provider package (e.g. `@ai-sdk/openai`) becomes a dependency here
+ * either.
+ *
+ * @example
+ * ```ts
+ * const executors = createAiSdkExecutors({ models: { quick: openai('gpt-5.4-mini') } });
+ * const result = await runAgent(machine, { input, executors });
+ * ```
+ */
+declare function createAiSdkExecutors<TModels extends AiSdkModelMap>(options: CreateAiSdkExecutorsOptions<TModels>): AiSdkExecutors;
+/** AI SDK host for a machine authored with `setupAgent({ models })`. */
+declare function runAgent<TMachine extends _$xstate.AnyStateMachine>(machine: TMachine, options: Omit<RunAgentOptions<TMachine>, "executors">): Promise<RunAgentResult<TMachine>>;
+type CreateAgentMachineConfig<TContextSchema extends StandardSchemaV1<Record<string, unknown>>, TInputSchema extends StandardSchemaV1, TEventSchemas extends AgentEventSchemaInputMap, TOutputSchema extends StandardSchemaV1, TModels extends AiSdkModelMap> = Omit<AgentMachineConfig<TContextSchema, TInputSchema, TEventSchemas, TOutputSchema, TModels>, "schemas">;
+type CreateAgentBaseConfig<TContextSchema extends StandardSchemaV1<Record<string, unknown>>, TInputSchema extends StandardSchemaV1, TEventSchemas extends AgentEventSchemaInputMap, TOutputSchema extends StandardSchemaV1, TModels extends AiSdkModelMap> = CreateAgentMachineConfig<TContextSchema, TInputSchema, TEventSchemas, TOutputSchema, TModels> & {
+  schemas: {
+    context: TContextSchema;
+    input: TInputSchema;
+    events?: TEventSchemas;
+    output?: TOutputSchema;
+  };
+};
+interface CreatedAgent<TMachine extends _$xstate.AnyStateMachine> {
+  machine: TMachine;
+  run(input: _$xstate.InputFrom<TMachine>, options?: Omit<RunAgentOptions<TMachine>, "input" | "executors">): Promise<RunAgentResult<TMachine>>;
+}
+/**
+ * One-call AI SDK entry point for the common case: creates a typed machine and
+ * a `run(input)` method with model executors already wired.
+ */
+declare function createAgent<TContextSchema extends StandardSchemaV1<Record<string, unknown>>, TInputSchema extends StandardSchemaV1, TEventSchemas extends AgentEventSchemaInputMap = {}, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1>(config: CreateAgentBaseConfig<TContextSchema, TInputSchema, TEventSchemas, TOutputSchema, AiSdkModelMap<"default">> & {
+  model: LanguageModel;
+  models?: never;
+}): CreatedAgent<AgentMachine<TContextSchema, TInputSchema, TEventSchemas, TOutputSchema, AiSdkModelMap<"default">>>;
+declare function createAgent<TModels extends AiSdkModelMap, TContextSchema extends StandardSchemaV1<Record<string, unknown>>, TInputSchema extends StandardSchemaV1, TEventSchemas extends AgentEventSchemaInputMap = {}, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1>(config: CreateAgentBaseConfig<TContextSchema, TInputSchema, TEventSchemas, TOutputSchema, TModels> & {
+  models: TModels;
+  model?: never;
+}): CreatedAgent<AgentMachine<TContextSchema, TInputSchema, TEventSchemas, TOutputSchema, TModels>>;
+/** One AI SDK `tool()` per candidate event — the "tool-per-event +
+ * toolChoice: 'required'" recipe from .scratch/p0-design.md §2.6. */
+declare function toAiSdkEventTools(events: AgentEventDescriptor[]): {
+  [k: string]: Tool<unknown, never>;
+};
+/**
+ * Messages for a decision request, with prior failed `attempts` (§2.6)
+ * rendered as appended user messages (via core's {@link renderDecisionAttempts})
+ * so retries converge. Core never rewrites prompts — this is adapter business.
+ */
+declare function toDecisionMessages(request: Pick<AgentDecisionRequest, "messages" | "prompt" | "events" | "attempts">): ModelMessage[] | undefined;
+//#endregion
+export { AiSdkDecideResult, AiSdkExecutors, AiSdkGenerateResult, AiSdkModelMap, AiSdkStreamResult, CreateAiSdkExecutorsOptions, CreatedAgent, createAgent, createAiSdkExecutors, defineModels, extractFirstJsonValue, isStructuredOutputRequest, runAgent, toAiSdkCallSettings, toAiSdkEventTools, toAiSdkToolChoice, toAiSdkTools, toDecisionMessages };

package/dist/ai-sdk.mjs

@@ -0,0 +1,331 @@
+import { a as runAgent$1, c as setupAgent } from "./run-agent-BoAOq_0Z.mjs";
+import { J as isStandardSchema, L as getRegisteredAgentModels, T as getAgentOutputMode, l as renderDecisionAttempts, x as buildEnvelopeSchema } from "./decision-CQdrKc8k.mjs";
+import { NoObjectGeneratedError, Output, generateText, stepCountIs, streamText, tool } from "ai";
+//#region src/ai-sdk/index.ts
+/**
+* Maps an {@link AgentTools} map onto AI SDK `tool()` definitions. A tool that
+* already carries its own Standard Schema `inputSchema` — an AI SDK
+* `tool({...})`, or any equivalent descriptor — is passed through **unchanged**,
+* so the SDK applies its own validation, calls `execute(input, options)`, and
+* every extra property (`providerOptions`, `toModelOutput`, …) survives. A bare
+* `AgentToolExecute` function becomes a tool with an unconstrained input schema;
+* a minimal descriptor with no readable schema is converted with a permissive
+* fallback. Used internally by {@link toAiSdkCallSettings}; exported for callers
+* building AI SDK calls by hand outside `createAiSdkExecutors`.
+*/
+function toAiSdkTools(tools) {
+	const entries = [];
+	for (const [name, descriptor] of Object.entries(tools)) {
+		if (!descriptor) continue;
+		if (typeof descriptor === "function") {
+			entries.push([name, tool({
+				inputSchema: unknownSchema,
+				execute: (input) => descriptor(input)
+			})]);
+			continue;
+		}
+		if (isStandardSchema(descriptor.inputSchema)) {
+			entries.push([name, descriptor]);
+			continue;
+		}
+		const inputSchema = descriptor.inputSchema ?? descriptor.schemas?.input;
+		const toolOptions = {
+			description: descriptor.description,
+			inputSchema: inputSchema ? inputSchema : unknownSchema
+		};
+		if (descriptor.execute) {
+			entries.push([name, tool({
+				...toolOptions,
+				execute: (input) => descriptor.execute?.(input)
+			})]);
+			continue;
+		}
+		entries.push([name, tool(toolOptions)]);
+	}
+	return Object.fromEntries(entries);
+}
+function maxStepsSetting(request) {
+	return typeof request.metadata?.maxSteps === "number" ? { stopWhen: stepCountIs(request.metadata.maxSteps) } : {};
+}
+const unknownSchema = { "~standard": {
+	version: 1,
+	vendor: "statelyai-agent",
+	validate: (value) => ({ value }),
+	jsonSchema: { input: () => ({}) }
+} };
+/**
+* Identity helper for a `models` map whose value is exported. Returns the map
+* unchanged, but types it as {@link AiSdkModelMap}`<keyof T & string>` — a
+* portable, nameable type — so an exported `const models = defineModels({...})`
+* needs no `Record<'a' | 'b', LanguageModel>` annotation and never triggers
+* TS2742 ("inferred type cannot be named without a reference to …"). The exact
+* ref keys survive, so `createAiSdkExecutors({ models })` and
+* `setupAgent({ models })` still infer/autocomplete them.
+*
+* @example
+* ```ts
+* export const models = defineModels({
+*   quick: openai('gpt-5.4-mini'),
+*   deep: openai('gpt-5.4'),
+* });
+* // typeof models === AiSdkModelMap<'quick' | 'deep'>
+* ```
+*/
+function defineModels(models) {
+	return models;
+}
+function resolveAiSdkModel(options, modelRef) {
+	if (options.resolveModel) return options.resolveModel(modelRef);
+	const models = options.models;
+	if (!models) throw new Error(`createAiSdkExecutors: no model resolver configured for '${modelRef}'.`);
+	const model = models[modelRef];
+	if (!model) throw new Error(`createAiSdkExecutors: unknown model '${modelRef}'.`);
+	return model;
+}
+/**
+* AI SDK request-mapping settings shared by `generateText`/`streamText`.
+* `AgentTextRequest.messages` (`AgentMessage[]`) and AI SDK's `ModelMessage[]`
+* are structurally compatible by design (§1 of .scratch/p0-design.md) — the cast
+* below is a typed identity mapping, not a semantic conversion.
+*/
+function toAiSdkCallSettings(request) {
+	const messages = request.messages;
+	return {
+		system: request.system,
+		...messages ? { messages } : { prompt: request.prompt ?? "" },
+		temperature: request.temperature,
+		maxOutputTokens: request.maxOutputTokens,
+		topP: request.topP,
+		topK: request.topK,
+		seed: request.seed,
+		stopSequences: request.stopSequences,
+		tools: request.tools ? toAiSdkTools(request.tools) : void 0,
+		toolChoice: toAiSdkToolChoice(request.toolChoice)
+	};
+}
+/** Maps an {@link AgentToolChoice} to AI SDK's tool-choice shape — `{ type: 'tool'; name }` becomes `{ type: 'tool'; toolName }`; `'auto'`/`'none'`/`'required'`/`undefined` pass through unchanged. */
+function toAiSdkToolChoice(toolChoice) {
+	return typeof toolChoice === "object" ? {
+		type: "tool",
+		toolName: toolChoice.name
+	} : toolChoice;
+}
+/** `true` when the request should use AI SDK structured `Output.object`. */
+function isStructuredOutputRequest(request) {
+	return getAgentOutputMode(request.outputSchema) === "structured";
+}
+/**
+* Extracts the first complete top-level JSON value from `text`, or returns
+* `undefined` when there is nothing to repair (no complete value, or the value
+* already spans the whole text). Models occasionally emit two structured-output
+* envelopes back to back (`{"result":{…}}{"result":{…}}`), which fails JSON
+* parsing wholesale; the balanced scan below recovers the first value and
+* drops the rest.
+*/
+function extractFirstJsonValue(text) {
+	const start = text.search(/[{[]/);
+	if (start === -1) return;
+	let depth = 0;
+	let inString = false;
+	let escaped = false;
+	for (let i = start; i < text.length; i++) {
+		const char = text[i];
+		if (inString) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === "\"") inString = false;
+			continue;
+		}
+		if (char === "\"") inString = true;
+		else if (char === "{" || char === "[") depth++;
+		else if (char === "}" || char === "]") {
+			depth--;
+			if (depth === 0) {
+				const value = text.slice(start, i + 1);
+				return value === text.trim() ? void 0 : value;
+			}
+		}
+	}
+}
+function withJsonRepair(output) {
+	return {
+		...output,
+		parseCompleteOutput: async (options, context) => {
+			try {
+				return await output.parseCompleteOutput(options, context);
+			} catch (error) {
+				const repaired = extractFirstJsonValue(options.text);
+				if (repaired === void 0) throw error;
+				return await output.parseCompleteOutput({
+					...options,
+					text: repaired
+				}, context);
+			}
+		}
+	};
+}
+/**
+* The canonical Vercel AI SDK adapter: builds the `{ generateText, streamText,
+* decide }` executor set consumed by `runAgent`/`executeAgentRequest`. `ai`
+* must not become a dependency of core `src/` files — this subpath is the one
+* place it's imported, and callers must supply their own model resolver so no
+* concrete provider package (e.g. `@ai-sdk/openai`) becomes a dependency here
+* either.
+*
+* @example
+* ```ts
+* const executors = createAiSdkExecutors({ models: { quick: openai('gpt-5.4-mini') } });
+* const result = await runAgent(machine, { input, executors });
+* ```
+*/
+function createAiSdkExecutors(options) {
+	const generateText$1 = async (request, info) => {
+		const common = {
+			model: resolveAiSdkModel(options, request.model),
+			abortSignal: info?.signal,
+			...toAiSdkCallSettings(request),
+			...maxStepsSetting(request)
+		};
+		if (isStructuredOutputRequest(request)) {
+			const envelope = buildEnvelopeSchema(request.outputSchema, { reasoning: request.reasoning });
+			const structuredOutput = withJsonRepair(Output.object({ schema: envelope }));
+			const canRetry = !request.tools || Object.keys(request.tools).length === 0;
+			let result;
+			try {
+				result = await generateText({
+					...common,
+					output: structuredOutput
+				});
+			} catch (error) {
+				if (!canRetry || !NoObjectGeneratedError.isInstance(error) || info?.signal?.aborted) throw error;
+				result = await generateText({
+					...common,
+					output: structuredOutput
+				});
+			}
+			const { result: output, reasoning } = result.output;
+			return {
+				output,
+				...reasoning !== void 0 ? { reasoning } : {},
+				usage: result.usage,
+				finishReason: result.finishReason,
+				toolCalls: result.toolCalls,
+				toolResults: result.toolResults
+			};
+		}
+		const result = await generateText(common);
+		return {
+			output: result.text,
+			usage: result.usage,
+			finishReason: result.finishReason,
+			toolCalls: result.toolCalls,
+			toolResults: result.toolResults
+		};
+	};
+	const streamText$1 = async (request, info) => {
+		const result = streamText({
+			model: resolveAiSdkModel(options, request.model),
+			abortSignal: info?.signal,
+			...toAiSdkCallSettings(request),
+			...maxStepsSetting(request)
+		});
+		for await (const chunk of result.textStream) info?.onChunk?.(chunk);
+		return {
+			output: await result.text,
+			usage: await result.usage,
+			finishReason: await result.finishReason
+		};
+	};
+	const decide = async (request) => {
+		const model = resolveAiSdkModel(options, request.model);
+		const tools = toAiSdkEventTools(request.events);
+		const messages = toDecisionMessages(request);
+		const result = await generateText({
+			model,
+			abortSignal: request.signal,
+			system: request.system,
+			...messages ? { messages } : { prompt: request.prompt ?? "" },
+			tools,
+			toolChoice: "required",
+			stopWhen: stepCountIs(1),
+			temperature: request.temperature,
+			maxOutputTokens: request.maxOutputTokens,
+			topP: request.topP,
+			topK: request.topK,
+			seed: request.seed,
+			stopSequences: request.stopSequences
+		});
+		const toolCall = result.toolCalls[0];
+		if (!toolCall) throw new Error("createAiSdkExecutors: decide — model did not call an event tool.");
+		const chosenEvent = request.events.find((event) => event.toolName === toolCall.toolName);
+		if (!chosenEvent) throw new Error(`createAiSdkExecutors: decide — model called unknown tool '${toolCall.toolName}'.`);
+		return {
+			event: {
+				...toolCall.input && typeof toolCall.input === "object" ? toolCall.input : {},
+				type: chosenEvent.type
+			},
+			usage: result.usage,
+			finishReason: result.finishReason
+		};
+	};
+	return {
+		generateText: generateText$1,
+		streamText: streamText$1,
+		decide
+	};
+}
+/** AI SDK host for a machine authored with `setupAgent({ models })`. */
+function runAgent(machine, options) {
+	const models = getRegisteredAgentModels(machine);
+	if (!models || Object.keys(models).length === 0) throw new Error("AI SDK runAgent: machine has no models. Pass `models` to setupAgent, or use core runAgent with explicit executors.");
+	return runAgent$1(machine, {
+		...options,
+		executors: createAiSdkExecutors({ models })
+	});
+}
+function createAgent(config) {
+	const { model, models: configuredModels, schemas, ...machineConfig } = config;
+	const models = configuredModels ?? { default: model };
+	const executors = createAiSdkExecutors({ models });
+	const machine = setupAgent({
+		...schemas,
+		models
+	}).createMachine(machineConfig);
+	return {
+		machine,
+		run(runInput, options = {}) {
+			return runAgent$1(machine, {
+				...options,
+				input: runInput,
+				executors
+			});
+		}
+	};
+}
+/** One AI SDK `tool()` per candidate event — the "tool-per-event +
+* toolChoice: 'required'" recipe from .scratch/p0-design.md §2.6. */
+function toAiSdkEventTools(events) {
+	return Object.fromEntries(events.map((event) => [event.toolName, tool({
+		description: `Choose the '${event.type}' move.`,
+		inputSchema: event.inputSchema ? event.inputSchema : unknownSchema
+	})]));
+}
+/**
+* Messages for a decision request, with prior failed `attempts` (§2.6)
+* rendered as appended user messages (via core's {@link renderDecisionAttempts})
+* so retries converge. Core never rewrites prompts — this is adapter business.
+*/
+function toDecisionMessages(request) {
+	if (!request.messages && request.attempts.length === 0) return;
+	const messages = [...request.messages ?? (request.prompt !== void 0 ? [{
+		role: "user",
+		content: request.prompt
+	}] : [])];
+	for (const attempt of renderDecisionAttempts(request)) messages.push({
+		role: "user",
+		content: attempt.content
+	});
+	return messages;
+}
+//#endregion
+export { createAgent, createAiSdkExecutors, defineModels, extractFirstJsonValue, isStructuredOutputRequest, runAgent, toAiSdkCallSettings, toAiSdkEventTools, toAiSdkToolChoice, toAiSdkTools, toDecisionMessages };

package/dist/cli.cjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+const require_run_agent = require("./run-agent-BFMkuI1F.cjs");
+const require_src = require("./src-D-77Ha5p.cjs");
+let node_fs = require("node:fs");
+//#region src/cli.ts
+/**
+* `statelyai-agent lint <workflow.json>` — keyless static verification for an
+* agent machine authored as data (an {@link AgentWorkflowConfig} JSON file).
+*
+* The library bundles no JSON Schema engine, so the CLI lints STRUCTURE ONLY:
+* it compiles the config with a permissive pass-through schema compiler (each
+* JSON Schema is kept as-is for structural checks, validation is a no-op) and
+* runs {@link lintAgentMachine}. Exits `1` on any error-severity finding.
+*
+* For full schema-aware linting, import the API and compile with a real engine:
+* `lintAgentMachine(setupAgent.fromConfig(config, { compileSchema }))`.
+*
+* @module
+*/
+function stubCompileSchema(jsonSchema) {
+	return { "~standard": {
+		version: 1,
+		vendor: "statelyai-agent-cli",
+		validate: (value) => ({ value }),
+		jsonSchema: { input: () => jsonSchema }
+	} };
+}
+function printUsage() {
+	process.stderr.write("Usage: statelyai-agent lint <workflow.json> [--no-schemas]\n\n  Statically verifies an agent-machine JSON config (structure-only).\n  Exits 1 on any error-severity finding.\n");
+}
+function main(argv) {
+	const args = argv.slice(2);
+	const command = args[0];
+	const file = args.find((arg, index) => index > 0 && !arg.startsWith("-"));
+	if (command !== "lint" || !file) {
+		printUsage();
+		return 2;
+	}
+	let config;
+	try {
+		config = JSON.parse((0, node_fs.readFileSync)(file, "utf8"));
+	} catch (error) {
+		process.stderr.write(`statelyai-agent: could not read/parse '${file}': ${error instanceof Error ? error.message : String(error)}\n`);
+		return 2;
+	}
+	let machine;
+	try {
+		machine = require_run_agent.setupAgent.fromConfig(config, { compileSchema: stubCompileSchema });
+	} catch (error) {
+		process.stderr.write(`statelyai-agent: '${file}' is not a valid agent-machine config: ${error instanceof Error ? error.message : String(error)}\n`);
+		return 2;
+	}
+	const diagnostics = require_src.lintAgentMachine(machine);
+	const errors = diagnostics.filter((d) => d.severity === "error");
+	const warnings = diagnostics.filter((d) => d.severity === "warning");
+	for (const d of diagnostics) {
+		const label = d.severity === "error" ? "error" : "warn ";
+		process.stdout.write(`  ${label}  ${d.code}  ${d.path}\n         ${d.message}\n`);
+	}
+	process.stdout.write(`\n${file}: ${errors.length} error(s), ${warnings.length} warning(s) (structure-only; schemas not compiled).\n`);
+	return errors.length > 0 ? 1 : 0;
+}
+process.exit(main(process.argv));
+//#endregion

package/dist/cli.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import { c as setupAgent } from "./run-agent-BoAOq_0Z.mjs";
+import { a as lintAgentMachine } from "./src-DUeIFjv-.mjs";
+import { readFileSync } from "node:fs";
+//#region src/cli.ts
+/**
+* `statelyai-agent lint <workflow.json>` — keyless static verification for an
+* agent machine authored as data (an {@link AgentWorkflowConfig} JSON file).
+*
+* The library bundles no JSON Schema engine, so the CLI lints STRUCTURE ONLY:
+* it compiles the config with a permissive pass-through schema compiler (each
+* JSON Schema is kept as-is for structural checks, validation is a no-op) and
+* runs {@link lintAgentMachine}. Exits `1` on any error-severity finding.
+*
+* For full schema-aware linting, import the API and compile with a real engine:
+* `lintAgentMachine(setupAgent.fromConfig(config, { compileSchema }))`.
+*
+* @module
+*/
+function stubCompileSchema(jsonSchema) {
+	return { "~standard": {
+		version: 1,
+		vendor: "statelyai-agent-cli",
+		validate: (value) => ({ value }),
+		jsonSchema: { input: () => jsonSchema }
+	} };
+}
+function printUsage() {
+	process.stderr.write("Usage: statelyai-agent lint <workflow.json> [--no-schemas]\n\n  Statically verifies an agent-machine JSON config (structure-only).\n  Exits 1 on any error-severity finding.\n");
+}
+function main(argv) {
+	const args = argv.slice(2);
+	const command = args[0];
+	const file = args.find((arg, index) => index > 0 && !arg.startsWith("-"));
+	if (command !== "lint" || !file) {
+		printUsage();
+		return 2;
+	}
+	let config;
+	try {
+		config = JSON.parse(readFileSync(file, "utf8"));
+	} catch (error) {
+		process.stderr.write(`statelyai-agent: could not read/parse '${file}': ${error instanceof Error ? error.message : String(error)}\n`);
+		return 2;
+	}
+	let machine;
+	try {
+		machine = setupAgent.fromConfig(config, { compileSchema: stubCompileSchema });
+	} catch (error) {
+		process.stderr.write(`statelyai-agent: '${file}' is not a valid agent-machine config: ${error instanceof Error ? error.message : String(error)}\n`);
+		return 2;
+	}
+	const diagnostics = lintAgentMachine(machine);
+	const errors = diagnostics.filter((d) => d.severity === "error");
+	const warnings = diagnostics.filter((d) => d.severity === "warning");
+	for (const d of diagnostics) {
+		const label = d.severity === "error" ? "error" : "warn ";
+		process.stdout.write(`  ${label}  ${d.code}  ${d.path}\n         ${d.message}\n`);
+	}
+	process.stdout.write(`\n${file}: ${errors.length} error(s), ${warnings.length} warning(s) (structure-only; schemas not compiled).\n`);
+	return errors.length > 0 ? 1 : 0;
+}
+process.exit(main(process.argv));
+//#endregion
+export {};