@statelyai/agent 2.0.0-alpha.28 → 2.0.0-alpha.30

package/dist/ai-sdk.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_text_logic = require("./text-logic-f5F5sCdc.cjs");
-const require_decision = require("./decision-CmM8-HHz.cjs");
-require("./validate.cjs");
+const require_event_log = require("./event-log-BZRfBRd7.cjs");
+const require_decision = require("./decision-CIb7ddIv.cjs");
+const require_model_source = require("./model-source-BCKg4qJ1.cjs");
 let ai = require("ai");
 //#region src/ai-sdk/mappers.ts
 /**
@@ -25,7 +25,7 @@ function toAiSdkTools(tools) {
 			})]);
 			continue;
 		}
-		if (require_text_logic.isStandardSchema(descriptor.inputSchema)) {
+		if (require_event_log.isStandardSchema(descriptor.inputSchema) || descriptor.type === "provider") {
 			entries.push([name, descriptor]);
 			continue;
 		}
@@ -132,7 +132,7 @@ function toAiSdkToolChoice(toolChoice) {
 }
 /** `true` when the request should use AI SDK structured `Output.object`. */
 function isStructuredOutputRequest(request) {
-	return require_text_logic.getAgentOutputMode(request.outputSchema) === "structured";
+	return require_event_log.getAgentOutputMode(request.outputSchema) === "structured";
 }
 /**
 * Extracts the first complete top-level JSON value from `text`, or returns
@@ -175,6 +175,53 @@ function toAiSdkEventTools(events) {
 		inputSchema: event.inputSchema ? event.inputSchema : unknownSchema
 	})]));
 }
+/** Tool name of the single closed-choice tool {@link toAiSdkOptionTool} builds. */
+const OPTION_TOOL_NAME = "choose_option";
+/**
+* A closed choice as ONE AI SDK tool: its input is `{ option }`, an enum of
+* option ids (see core's `decisionOptionIds`), with each id's description in
+* the tool description. Map the answer back with `ids.indexOf(input.option)`.
+*/
+function toAiSdkOptionTool(options) {
+	const ids = require_decision.decisionOptionIds(options);
+	const lines = options.map((option, index) => option.description ? `- ${ids[index]}: ${option.description}` : `- ${ids[index]}`);
+	return {
+		ids,
+		tools: { [OPTION_TOOL_NAME]: (0, ai.tool)({
+			description: `Choose exactly one option:\n${lines.join("\n")}`,
+			inputSchema: (0, ai.jsonSchema)({
+				type: "object",
+				properties: { option: {
+					type: "string",
+					enum: ids,
+					description: "The id of the chosen option."
+				} },
+				required: ["option"],
+				additionalProperties: false
+			})
+		}) }
+	};
+}
+/**
+* The event a closed-choice tool call names: the offered option whose id is
+* `input.option`. A call to another tool, or an id that is not offered, maps
+* to {@link unofferedOption}, so the choice is retried instead of thrown.
+*/
+function fromAiSdkOptionCall(toolCall, options, ids) {
+	if (toolCall.toolName !== OPTION_TOOL_NAME) return unofferedOption(`tool '${toolCall.toolName}'`, ids);
+	const id = require_decision.isRecord(toolCall.input) ? toolCall.input.option : void 0;
+	const option = typeof id === "string" ? options[ids.indexOf(id)] : void 0;
+	return option ? option.event : unofferedOption(`option ${JSON.stringify(id)}`, ids);
+}
+/**
+* A stand-in event for a closed-choice answer that names no offered option.
+* Its `type` is no candidate event, so `resolveDecision` records it as a
+* failed `'unknown-event'` attempt (the type, which names the answer and the
+* valid ids, is the attempt's reason) and asks again.
+*/
+function unofferedOption(answer, ids) {
+	return { type: `${answer} was not offered (valid ids: ${ids.join(", ") || "none"})` };
+}
 /**
 * Messages for a decision request, with prior failed `attempts` (§2.6)
 * rendered as appended user messages (via core's {@link renderDecisionAttempts})
@@ -198,9 +245,12 @@ function maxStepsSetting(request) {
 	const maxSteps = request.maxSteps;
 	return typeof maxSteps === "number" ? { stopWhen: (0, ai.stepCountIs)(maxSteps) } : {};
 }
+function isDecisionModel(model) {
+	return require_decision.isRecord(model) && (typeof model.doDecide === "function" || typeof model.doEvaluate === "function");
+}
 /**
 * Splits a portable `"provider/model-id"` model ref (the convention JSON
-* workflows and registry-less hosts use, e.g. `"openai/gpt-5.4-mini"`) into
+* workflows and registry-less hosts use, e.g. `"openai/gpt-6-luna"`) into
 * its parts. A ref with no `/` has no provider — `modelId` is the whole ref.
 * The standard building block for a host's `resolveModel`:
 *
@@ -232,12 +282,22 @@ function resolveAiSdkModel(options, modelRef) {
 	if (!entry) throw new Error(`createAiSdkExecutors: unknown model '${modelRef}'.`);
 	return isModelWithSettings(entry) ? entry : { model: entry };
 }
+function resolveLanguageModel(options, request) {
+	const { model, settings } = resolveAiSdkModel(options, request.model);
+	if (isDecisionModel(model)) throw new Error(`createAiSdkExecutors: model '${request.model}' is a decision model, which only answers decide requests with options; text request '${request.name ?? "(unnamed)"}' needs a language model.`);
+	return {
+		model,
+		...settings ? { settings } : {}
+	};
+}
 /**
 * The `LanguageModel` inside a map entry, whichever form it takes. `AiSdkModelMap`
 * widens its return to {@link AiSdkModelMap}, so reading an entry out of the map
-* to hand to a raw AI SDK call needs this to get past the union.
+* to hand to a raw AI SDK call needs this to get past the union. Throws for a
+* decision model.
 */
 function toLanguageModel(entry) {
+	if (isDecisionModel(entry)) throw new TypeError("toLanguageModel: the entry is a decision model, not a language model.");
 	return isModelWithSettings(entry) ? entry.model : entry;
 }
 function isModelWithSettings(entry) {
@@ -261,30 +321,17 @@ function withJsonRepair(output) {
 	};
 }
 function truncated(request, info, partialOutput, cause) {
-	return new require_text_logic.AgentTruncatedError(`createAiSdkExecutors: request '${request.name ?? "(unnamed)"}' hit the output token limit — its structured output never completed. Raise \`maxOutputTokens\`, shorten the input, or ask for a smaller output schema.`, {
+	return new require_event_log.AgentTruncatedError(`createAiSdkExecutors: request '${request.name ?? "(unnamed)"}' hit the output token limit — its structured output never completed. Raise \`maxOutputTokens\`, shorten the input, or ask for a smaller output schema.`, {
 		requestName: request.name ?? "(unnamed)",
 		...info?.requestId !== void 0 ? { requestId: info.requestId } : {},
 		...partialOutput !== void 0 ? { partialOutput } : {},
 		...cause !== void 0 ? { cause } : {}
 	});
 }
-/**
-* The canonical Vercel AI SDK adapter: builds the `{ generateText, streamText,
-* decide }` executor set consumed by `createAgentRuntime`/`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 runToQuiescence(createAgentRuntime(machine, { executors }), { input });
-* ```
-*/
-function createAiSdkExecutors(options) {
+function createAiSdkExecutors(source) {
+	const options = require_model_source.resolveModelSource("createAiSdkExecutors", source);
 	const generateText = async (request, info) => {
-		const { model, settings: modelSettings } = resolveAiSdkModel(options, request.model);
+		const { model, settings: modelSettings } = resolveLanguageModel(options, request);
 		const common = {
 			model,
 			abortSignal: info?.signal,
@@ -294,7 +341,7 @@ function createAiSdkExecutors(options) {
 			...maxStepsSetting(request)
 		};
 		if (isStructuredOutputRequest(request)) {
-			const outputSchema = require_text_logic.providerOutputSchema(request.outputSchema, { reasoning: request.includeReasoning });
+			const outputSchema = require_event_log.providerOutputSchema(request.outputSchema, { reasoning: request.includeReasoning });
 			const structuredOutput = withJsonRepair(ai.Output.object({ schema: outputSchema }));
 			const result = await (0, ai.generateText)({
 				...common,
@@ -333,7 +380,7 @@ function createAiSdkExecutors(options) {
 		};
 	};
 	const streamText = async (request, info) => {
-		const { model, settings: modelSettings } = resolveAiSdkModel(options, request.model);
+		const { model, settings: modelSettings } = resolveLanguageModel(options, request);
 		const result = (0, ai.streamText)({
 			model,
 			abortSignal: info?.signal,
@@ -353,7 +400,9 @@ function createAiSdkExecutors(options) {
 	};
 	const decide = async (request, info) => {
 		const { model, settings: modelSettings } = resolveAiSdkModel(options, request.model);
-		const tools = toAiSdkEventTools(request.events);
+		if (isDecisionModel(model)) return decideWithDecisionModel(model, request, info);
+		const choice = request.options ? toAiSdkOptionTool(request.options) : void 0;
+		const tools = choice ? choice.tools : toAiSdkEventTools(request.events);
 		const messages = toDecisionMessages(request);
 		const result = await (0, ai.generateText)({
 			model,
@@ -372,6 +421,11 @@ function createAiSdkExecutors(options) {
 		});
 		const toolCall = result.toolCalls[0];
 		if (!toolCall) throw new Error("createAiSdkExecutors: decide — model did not call an event tool.");
+		if (choice) return {
+			event: fromAiSdkOptionCall(toolCall, request.options, choice.ids),
+			usage: toAgentCallUsage(result.usage),
+			finishReason: result.finishReason
+		};
 		const chosenEvent = request.events.find((event) => event.toolName === toolCall.toolName);
 		if (!chosenEvent) throw new Error(`createAiSdkExecutors: decide — model called unknown tool '${toolCall.toolName}'.`);
 		return {
@@ -389,6 +443,75 @@ function createAiSdkExecutors(options) {
 		decide
 	};
 }
+/** The question id a decision model's closed choice is asked under. */
+const DECISION_QUESTION_ID = "next";
+async function decideWithDecisionModel(model, request, info) {
+	const offered = request.options;
+	if (!offered?.length) throw new Error(`createAiSdkExecutors: decision '${request.name ?? "(unnamed)"}' uses decision model '${request.model}', which needs a closed choice: pass \`payloads\` on agent.decide, or use decideNext.`);
+	const ids = require_decision.decisionOptionIds(offered);
+	const criteria = Object.fromEntries(offered.map((option, index) => [ids[index], option.description ?? JSON.stringify(option.event)]));
+	const instructions = [[request.system, request.prompt].filter(Boolean).join("\n\n") || "Which option should happen next?", ...require_decision.renderDecisionAttempts(request).map((message) => message.content)].join("\n\n");
+	const ask = () => (0, ai.experimental_decide)({
+		model,
+		state: toDecisionState(request.input),
+		questions: { [DECISION_QUESTION_ID]: {
+			type: "choice",
+			instructions,
+			criteria
+		} },
+		...info?.signal ? { abortSignal: info.signal } : {}
+	});
+	let result;
+	try {
+		result = await ask();
+	} catch (error) {
+		const chosen = unofferedChoice(error, ids);
+		if (chosen === void 0) throw error;
+		return decisionResult(unofferedOption(`option ${JSON.stringify(chosen)}`, ids));
+	}
+	const answer = result.answers[DECISION_QUESTION_ID];
+	const option = offered[ids.indexOf(answer.choice)];
+	if (!option) return decisionResult(unofferedOption(`option ${JSON.stringify(answer.choice)}`, ids));
+	const reported = (result.providerMetadata?.typesafe?.confidence)?.[DECISION_QUESTION_ID];
+	const confidence = typeof reported === "number" ? reported : answer.probabilities?.[answer.choice];
+	return decisionResult(option.event, result.usage, confidence);
+}
+function decisionResult(event, usage = {}, confidence) {
+	return {
+		event,
+		usage: toAgentCallUsage({
+			inputTokens: usage.inputTokens,
+			outputTokens: usage.outputTokens,
+			totalTokens: usage.totalTokens,
+			inputTokenDetails: {
+				noCacheTokens: void 0,
+				cacheReadTokens: void 0,
+				cacheWriteTokens: void 0
+			},
+			outputTokenDetails: {
+				textTokens: void 0,
+				reasoningTokens: void 0
+			}
+		}),
+		finishReason: "stop",
+		...confidence !== void 0 ? { confidence } : {}
+	};
+}
+function unofferedChoice(error, ids) {
+	if (!ai.InvalidResponseDataError.isInstance(error) || !require_decision.isRecord(error.data)) return void 0;
+	const answer = error.data[DECISION_QUESTION_ID];
+	const choice = require_decision.isRecord(answer) ? answer.choice : void 0;
+	return typeof choice === "string" && !ids.includes(choice) ? choice : void 0;
+}
+function toDecisionState(value) {
+	if (typeof value === "string") return value;
+	try {
+		const json = JSON.parse(JSON.stringify(value ?? {}));
+		return require_decision.isRecord(json) ? json : { value: json };
+	} catch {
+		return String(value);
+	}
+}
 //#endregion
 exports.createAiSdkExecutors = createAiSdkExecutors;
 exports.parseModelRef = parseModelRef;

package/dist/ai-sdk.d.cts

@@ -1,7 +1,7 @@
-import { s as AgentTools, u as ChosenEvent } from "./types-hR5f5YXa.cjs";
-import { M as AgentDecisionRequest, c as AgentRequestExecutorInfo, f as AgentTextRequest, r as AgentFinishReason, t as AgentCallUsage } from "./text-logic-IjfYy9DP.cjs";
-import { FinishReason, LanguageModel, LanguageModelUsage, ModelMessage, ToolSet, TypedToolCall, TypedToolResult, generateText } from "ai";
-
+import { s as AgentTools, u as ChosenEvent } from "./types-Dp5_Ru4R.cjs";
+import { N as AgentDecisionRequest, c as AgentRequestExecutorInfo, f as AgentTextRequest, r as AgentFinishReason, t as AgentCallUsage } from "./text-logic-DmciuVUQ.cjs";
+import { Experimental_DecisionModel, FinishReason, LanguageModel, LanguageModelUsage, ModelMessage, ToolSet, TypedToolCall, TypedToolResult, generateText } from "ai";
+import { AnyStateMachine } from "xstate";
 //#region src/ai-sdk/mappers.d.ts
 /**
  * One call's usage as the adapter reports it: the AI SDK's `LanguageModelUsage`
@@ -12,18 +12,23 @@ type AiSdkCallUsage = LanguageModelUsage & Pick<AgentCallUsage, "reasoningTokens
 //#endregion
 //#region src/ai-sdk/index.d.ts
 /**
- * One entry in an {@link AiSdkModelMap}: a bare `LanguageModel`, or a model
- * paired with the {@link AiSdkCallSettings} that ref always runs with. The
- * paired form is how a host gives a ref a persona — `deep` thinks harder than
- * `quick` — without the machine naming a provider knob.
+ * One entry in an {@link AiSdkModelMap}: a bare `LanguageModel`, a model
+ * paired with the {@link AiSdkCallSettings} that ref always runs with, or an
+ * AI SDK decision model. The paired form is how a host gives a ref a persona —
+ * `deep` thinks harder than `quick` — without the machine naming a provider knob.
+ *
+ * A decision model (such as `typeSafeAi.decisionModel('jev-latest')`) answers
+ * `decide` requests that carry a closed choice (`options`) through
+ * `experimental_decide`. Text requests need a language model.
  */
-type AiSdkModelEntry = LanguageModel | {
+export type AiSdkModelEntry = LanguageModel | AiSdkDecisionModel | {
   model: LanguageModel;
   settings?: AiSdkCallSettings;
 };
+type AiSdkDecisionModel = Exclude<Experimental_DecisionModel, string>;
 /**
  * Splits a portable `"provider/model-id"` model ref (the convention JSON
- * workflows and registry-less hosts use, e.g. `"openai/gpt-5.4-mini"`) into
+ * workflows and registry-less hosts use, e.g. `"openai/gpt-6-luna"`) into
  * its parts. A ref with no `/` has no provider — `modelId` is the whole ref.
  * The standard building block for a host's `resolveModel`:
  *
@@ -32,12 +37,12 @@ type AiSdkModelEntry = LanguageModel | {
  * const resolveModel = (ref: string) => openai(parseModelRef(ref).modelId);
  * ```
  */
-declare function parseModelRef(modelRef: string): {
+export declare function parseModelRef(modelRef: string): {
   provider: string | undefined;
   modelId: string;
 };
 /** AI SDK model registry: maps model refs (as used in `setupAgent({ models })`/`AgentTextRequest.model`) to AI SDK `LanguageModel` values, or to `{ model, settings }` pairs. The optional `TKey` parameter pins the ref keys; it defaults to `string`, so bare `AiSdkModelMap` stays `Record<string, AiSdkModelEntry>`. */
-type AiSdkModelMap<TKey extends string = string> = Record<TKey, AiSdkModelEntry>;
+export type AiSdkModelMap<TKey extends string = string> = Record<TKey, AiSdkModelEntry>;
 /**
  * Per-call AI SDK settings a host can apply on top of what the machine asked
  * for — reasoning effort, `providerOptions`, and anything else the SDK's call
@@ -48,11 +53,11 @@ type AiSdkModelMap<TKey extends string = string> = Record<TKey, AiSdkModelEntry>
  * generation settings every provider shares) are excluded: those belong to the
  * machine, and a host override would silently contradict it.
  */
-type AiSdkCallSettings = Omit<Parameters<typeof generateText>[0], "model" | "prompt" | "messages" | "system" | "instructions" | "tools" | "toolChoice" | "output" | "abortSignal" | "stopWhen">;
+export type AiSdkCallSettings = Omit<Parameters<typeof generateText>[0], "model" | "prompt" | "messages" | "system" | "instructions" | "tools" | "toolChoice" | "output" | "abortSignal" | "stopWhen">;
 /**
  * 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
+ * dynamically, e.g. `"openai/gpt-6-luna"` → `openai('gpt-6-luna')`), or
  * both — `resolveModel` takes precedence when both are supplied.
  *
  * `settings` carries provider knobs that are the HOST's business rather than
@@ -61,21 +66,22 @@ type AiSdkCallSettings = Omit<Parameters<typeof generateText>[0], "model" | "pro
  * registered key). Core neither declares nor reads these: a machine stays
  * portable, and a host that cannot honor a knob simply does not set it.
  */
-type CreateAiSdkExecutorsOptions<TModels extends AiSdkModelMap = AiSdkModelMap> = {
+export type CreateAiSdkExecutorsOptions<TModels extends AiSdkModelMap = AiSdkModelMap> = {
   settings?: AiSdkCallSettings | ((request: AgentTextRequest | AgentDecisionRequest) => AiSdkCallSettings | undefined);
 } & ({
   models: TModels;
-  resolveModel?: (modelRef: keyof TModels & string) => LanguageModel;
+  resolveModel?: (modelRef: keyof TModels & string) => LanguageModel | AiSdkDecisionModel;
 } | {
   models?: TModels;
-  resolveModel: (modelRef: string) => LanguageModel;
+  resolveModel: (modelRef: string) => LanguageModel | AiSdkDecisionModel;
 });
 /**
  * The `LanguageModel` inside a map entry, whichever form it takes. `AiSdkModelMap`
  * widens its return to {@link AiSdkModelMap}, so reading an entry out of the map
- * to hand to a raw AI SDK call needs this to get past the union.
+ * to hand to a raw AI SDK call needs this to get past the union. Throws for a
+ * decision model.
  */
-declare function toLanguageModel(entry: AiSdkModelEntry): LanguageModel;
+export declare function toLanguageModel(entry: AiSdkModelEntry): LanguageModel;
 /**
  * Raw result shape from {@link AiSdkExecutors.generateText} — `result` (the
  * validated structured object for structured-output requests, or the
@@ -85,7 +91,7 @@ declare function toLanguageModel(entry: AiSdkModelEntry): LanguageModel;
  * `raw as AiSdkGenerateResult` is the supported cast for token accounting and
  * tracing.
  */
-type AiSdkGenerateResult = {
+export type AiSdkGenerateResult = {
   result: unknown;
   /** The model's reasoning, present only when the request opted in via
    * `reasoning: true` and the model produced it (see
@@ -95,31 +101,42 @@ type AiSdkGenerateResult = {
    * `reasoningTokens`/`cachedInputTokens` fields are what the runtime folds into
    * the run result's aggregated `AgentUsage`; the AI SDK's own nested
    * `inputTokenDetails`/`outputTokenDetails` and `raw` ride along untouched. */
-  usage: AiSdkCallUsage; /** Why the call stopped, normalized to the portable {@link AgentFinishReason}. The SDK's own value stays on `raw`. */
+  usage: AiSdkCallUsage;
+  /** Why the call stopped, normalized to the portable {@link AgentFinishReason}. The SDK's own value stays on `raw`. */
   finishReason: AgentFinishReason;
   toolCalls: TypedToolCall<ToolSet>[];
-  toolResults: TypedToolResult<ToolSet>[]; /** AI SDK response messages, including tool calls/results from every step. */
-  messages: ModelMessage[]; /** The untouched AI SDK result. */
+  toolResults: TypedToolResult<ToolSet>[];
+  /** AI SDK response messages, including tool calls/results from every step. */
+  messages: ModelMessage[];
+  /** The untouched AI SDK result. */
   raw: unknown;
 };
 /** Raw result shape from {@link AiSdkExecutors.streamText} — `result` is the fully-accumulated text once the stream finishes (chunks are delivered separately via `onChunk`), plus the response messages and the stream's final usage/finish metadata for `onResult`. */
-type AiSdkStreamResult = {
-  result: string; /** The stream's final (awaited) usage; aggregated into the run result's `AgentUsage`. */
-  usage: AiSdkCallUsage; /** Why the stream stopped, normalized to the portable {@link AgentFinishReason}. The SDK's own value stays on `raw`. */
-  finishReason: AgentFinishReason; /** AI SDK response messages, including tool calls/results from every step. */
-  messages: ModelMessage[]; /** The untouched AI SDK result. */
+export type AiSdkStreamResult = {
+  result: string;
+  /** The stream's final (awaited) usage; aggregated into the run result's `AgentUsage`. */
+  usage: AiSdkCallUsage;
+  /** Why the stream stopped, normalized to the portable {@link AgentFinishReason}. The SDK's own value stays on `raw`. */
+  finishReason: AgentFinishReason;
+  /** AI SDK response messages, including tool calls/results from every step. */
+  messages: ModelMessage[];
+  /** The untouched AI SDK result. */
   raw: unknown;
 };
 /** 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; /** This attempt's usage; aggregated into the run result's `AgentUsage`. */
+export type AiSdkDecideResult = {
+  event: ChosenEvent;
+  /** This attempt's usage; aggregated into the run result's `AgentUsage`. */
   usage: AiSdkCallUsage;
+  /** `'stop'` for a decision model, which reports no finish reason. */
   finishReason: FinishReason;
+  /** A decision model's confidence in the chosen option, when it reports one. */
+  confidence?: number;
 };
 /** `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 {
+export interface AiSdkExecutors {
   generateText: (request: AgentTextRequest & {
     tools: AgentTools;
   }, info?: AgentRequestExecutorInfo) => Promise<AiSdkGenerateResult>;
@@ -136,12 +153,18 @@ interface AiSdkExecutors {
  * concrete provider package (e.g. `@ai-sdk/openai`) becomes a dependency here
  * either.
  *
+ * Pass the options object, or pass the machine (or its `setupAgent(...)`
+ * result) to reuse the `models` declared in `setupAgent({ models })`. Anything
+ * else throws here, at construction.
+ *
  * @example
  * ```ts
- * const executors = createAiSdkExecutors({ models: { quick: openai('gpt-5.4-mini') } });
- * const result = await runToQuiescence(createAgentRuntime(machine, { executors }), { input });
+ * const agentSetup = setupAgent({ models: { quick: openai('gpt-6-luna') }, ... });
+ * const machine = agentSetup.createMachine({ ... });
+ * const result = await runAgent(machine, { input, executors: createAiSdkExecutors(machine) });
+ * // Or explicitly: createAiSdkExecutors({ models: { quick: openai('gpt-6-luna') } })
  * ```
  */
-declare function createAiSdkExecutors<TModels extends AiSdkModelMap>(options: CreateAiSdkExecutorsOptions<TModels>): AiSdkExecutors;
-//#endregion
-export { AiSdkCallSettings, AiSdkDecideResult, AiSdkExecutors, AiSdkGenerateResult, AiSdkModelEntry, AiSdkModelMap, AiSdkStreamResult, CreateAiSdkExecutorsOptions, createAiSdkExecutors, parseModelRef, toLanguageModel };
+export declare function createAiSdkExecutors<TModels extends AiSdkModelMap>(options: CreateAiSdkExecutorsOptions<TModels>): AiSdkExecutors;
+export declare function createAiSdkExecutors(machine: AnyStateMachine): AiSdkExecutors;
+//#endregion

package/dist/ai-sdk.d.mts

@@ -1,7 +1,7 @@
-import { s as AgentTools, u as ChosenEvent } from "./types-BgNbNKnJ.mjs";
-import { M as AgentDecisionRequest, c as AgentRequestExecutorInfo, f as AgentTextRequest, r as AgentFinishReason, t as AgentCallUsage } from "./text-logic-D-czVPYp.mjs";
-import { FinishReason, LanguageModel, LanguageModelUsage, ModelMessage, ToolSet, TypedToolCall, TypedToolResult, generateText } from "ai";
-
+import { s as AgentTools, u as ChosenEvent } from "./types-Dp5_Ru4R.mjs";
+import { N as AgentDecisionRequest, c as AgentRequestExecutorInfo, f as AgentTextRequest, r as AgentFinishReason, t as AgentCallUsage } from "./text-logic-BRYOPWvY.mjs";
+import { AnyStateMachine } from "xstate";
+import { Experimental_DecisionModel, FinishReason, LanguageModel, LanguageModelUsage, ModelMessage, ToolSet, TypedToolCall, TypedToolResult, generateText } from "ai";
 //#region src/ai-sdk/mappers.d.ts
 /**
  * One call's usage as the adapter reports it: the AI SDK's `LanguageModelUsage`
@@ -12,18 +12,23 @@ type AiSdkCallUsage = LanguageModelUsage & Pick<AgentCallUsage, "reasoningTokens
 //#endregion
 //#region src/ai-sdk/index.d.ts
 /**
- * One entry in an {@link AiSdkModelMap}: a bare `LanguageModel`, or a model
- * paired with the {@link AiSdkCallSettings} that ref always runs with. The
- * paired form is how a host gives a ref a persona — `deep` thinks harder than
- * `quick` — without the machine naming a provider knob.
+ * One entry in an {@link AiSdkModelMap}: a bare `LanguageModel`, a model
+ * paired with the {@link AiSdkCallSettings} that ref always runs with, or an
+ * AI SDK decision model. The paired form is how a host gives a ref a persona —
+ * `deep` thinks harder than `quick` — without the machine naming a provider knob.
+ *
+ * A decision model (such as `typeSafeAi.decisionModel('jev-latest')`) answers
+ * `decide` requests that carry a closed choice (`options`) through
+ * `experimental_decide`. Text requests need a language model.
  */
-type AiSdkModelEntry = LanguageModel | {
+export type AiSdkModelEntry = LanguageModel | AiSdkDecisionModel | {
   model: LanguageModel;
   settings?: AiSdkCallSettings;
 };
+type AiSdkDecisionModel = Exclude<Experimental_DecisionModel, string>;
 /**
  * Splits a portable `"provider/model-id"` model ref (the convention JSON
- * workflows and registry-less hosts use, e.g. `"openai/gpt-5.4-mini"`) into
+ * workflows and registry-less hosts use, e.g. `"openai/gpt-6-luna"`) into
  * its parts. A ref with no `/` has no provider — `modelId` is the whole ref.
  * The standard building block for a host's `resolveModel`:
  *
@@ -32,12 +37,12 @@ type AiSdkModelEntry = LanguageModel | {
  * const resolveModel = (ref: string) => openai(parseModelRef(ref).modelId);
  * ```
  */
-declare function parseModelRef(modelRef: string): {
+export declare function parseModelRef(modelRef: string): {
   provider: string | undefined;
   modelId: string;
 };
 /** AI SDK model registry: maps model refs (as used in `setupAgent({ models })`/`AgentTextRequest.model`) to AI SDK `LanguageModel` values, or to `{ model, settings }` pairs. The optional `TKey` parameter pins the ref keys; it defaults to `string`, so bare `AiSdkModelMap` stays `Record<string, AiSdkModelEntry>`. */
-type AiSdkModelMap<TKey extends string = string> = Record<TKey, AiSdkModelEntry>;
+export type AiSdkModelMap<TKey extends string = string> = Record<TKey, AiSdkModelEntry>;
 /**
  * Per-call AI SDK settings a host can apply on top of what the machine asked
  * for — reasoning effort, `providerOptions`, and anything else the SDK's call
@@ -48,11 +53,11 @@ type AiSdkModelMap<TKey extends string = string> = Record<TKey, AiSdkModelEntry>
  * generation settings every provider shares) are excluded: those belong to the
  * machine, and a host override would silently contradict it.
  */
-type AiSdkCallSettings = Omit<Parameters<typeof generateText>[0], "model" | "prompt" | "messages" | "system" | "instructions" | "tools" | "toolChoice" | "output" | "abortSignal" | "stopWhen">;
+export type AiSdkCallSettings = Omit<Parameters<typeof generateText>[0], "model" | "prompt" | "messages" | "system" | "instructions" | "tools" | "toolChoice" | "output" | "abortSignal" | "stopWhen">;
 /**
  * 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
+ * dynamically, e.g. `"openai/gpt-6-luna"` → `openai('gpt-6-luna')`), or
  * both — `resolveModel` takes precedence when both are supplied.
  *
  * `settings` carries provider knobs that are the HOST's business rather than
@@ -61,21 +66,22 @@ type AiSdkCallSettings = Omit<Parameters<typeof generateText>[0], "model" | "pro
  * registered key). Core neither declares nor reads these: a machine stays
  * portable, and a host that cannot honor a knob simply does not set it.
  */
-type CreateAiSdkExecutorsOptions<TModels extends AiSdkModelMap = AiSdkModelMap> = {
+export type CreateAiSdkExecutorsOptions<TModels extends AiSdkModelMap = AiSdkModelMap> = {
   settings?: AiSdkCallSettings | ((request: AgentTextRequest | AgentDecisionRequest) => AiSdkCallSettings | undefined);
 } & ({
   models: TModels;
-  resolveModel?: (modelRef: keyof TModels & string) => LanguageModel;
+  resolveModel?: (modelRef: keyof TModels & string) => LanguageModel | AiSdkDecisionModel;
 } | {
   models?: TModels;
-  resolveModel: (modelRef: string) => LanguageModel;
+  resolveModel: (modelRef: string) => LanguageModel | AiSdkDecisionModel;
 });
 /**
  * The `LanguageModel` inside a map entry, whichever form it takes. `AiSdkModelMap`
  * widens its return to {@link AiSdkModelMap}, so reading an entry out of the map
- * to hand to a raw AI SDK call needs this to get past the union.
+ * to hand to a raw AI SDK call needs this to get past the union. Throws for a
+ * decision model.
  */
-declare function toLanguageModel(entry: AiSdkModelEntry): LanguageModel;
+export declare function toLanguageModel(entry: AiSdkModelEntry): LanguageModel;
 /**
  * Raw result shape from {@link AiSdkExecutors.generateText} — `result` (the
  * validated structured object for structured-output requests, or the
@@ -85,7 +91,7 @@ declare function toLanguageModel(entry: AiSdkModelEntry): LanguageModel;
  * `raw as AiSdkGenerateResult` is the supported cast for token accounting and
  * tracing.
  */
-type AiSdkGenerateResult = {
+export type AiSdkGenerateResult = {
   result: unknown;
   /** The model's reasoning, present only when the request opted in via
    * `reasoning: true` and the model produced it (see
@@ -95,31 +101,42 @@ type AiSdkGenerateResult = {
    * `reasoningTokens`/`cachedInputTokens` fields are what the runtime folds into
    * the run result's aggregated `AgentUsage`; the AI SDK's own nested
    * `inputTokenDetails`/`outputTokenDetails` and `raw` ride along untouched. */
-  usage: AiSdkCallUsage; /** Why the call stopped, normalized to the portable {@link AgentFinishReason}. The SDK's own value stays on `raw`. */
+  usage: AiSdkCallUsage;
+  /** Why the call stopped, normalized to the portable {@link AgentFinishReason}. The SDK's own value stays on `raw`. */
   finishReason: AgentFinishReason;
   toolCalls: TypedToolCall<ToolSet>[];
-  toolResults: TypedToolResult<ToolSet>[]; /** AI SDK response messages, including tool calls/results from every step. */
-  messages: ModelMessage[]; /** The untouched AI SDK result. */
+  toolResults: TypedToolResult<ToolSet>[];
+  /** AI SDK response messages, including tool calls/results from every step. */
+  messages: ModelMessage[];
+  /** The untouched AI SDK result. */
   raw: unknown;
 };
 /** Raw result shape from {@link AiSdkExecutors.streamText} — `result` is the fully-accumulated text once the stream finishes (chunks are delivered separately via `onChunk`), plus the response messages and the stream's final usage/finish metadata for `onResult`. */
-type AiSdkStreamResult = {
-  result: string; /** The stream's final (awaited) usage; aggregated into the run result's `AgentUsage`. */
-  usage: AiSdkCallUsage; /** Why the stream stopped, normalized to the portable {@link AgentFinishReason}. The SDK's own value stays on `raw`. */
-  finishReason: AgentFinishReason; /** AI SDK response messages, including tool calls/results from every step. */
-  messages: ModelMessage[]; /** The untouched AI SDK result. */
+export type AiSdkStreamResult = {
+  result: string;
+  /** The stream's final (awaited) usage; aggregated into the run result's `AgentUsage`. */
+  usage: AiSdkCallUsage;
+  /** Why the stream stopped, normalized to the portable {@link AgentFinishReason}. The SDK's own value stays on `raw`. */
+  finishReason: AgentFinishReason;
+  /** AI SDK response messages, including tool calls/results from every step. */
+  messages: ModelMessage[];
+  /** The untouched AI SDK result. */
   raw: unknown;
 };
 /** 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; /** This attempt's usage; aggregated into the run result's `AgentUsage`. */
+export type AiSdkDecideResult = {
+  event: ChosenEvent;
+  /** This attempt's usage; aggregated into the run result's `AgentUsage`. */
   usage: AiSdkCallUsage;
+  /** `'stop'` for a decision model, which reports no finish reason. */
   finishReason: FinishReason;
+  /** A decision model's confidence in the chosen option, when it reports one. */
+  confidence?: number;
 };
 /** `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 {
+export interface AiSdkExecutors {
   generateText: (request: AgentTextRequest & {
     tools: AgentTools;
   }, info?: AgentRequestExecutorInfo) => Promise<AiSdkGenerateResult>;
@@ -136,12 +153,18 @@ interface AiSdkExecutors {
  * concrete provider package (e.g. `@ai-sdk/openai`) becomes a dependency here
  * either.
  *
+ * Pass the options object, or pass the machine (or its `setupAgent(...)`
+ * result) to reuse the `models` declared in `setupAgent({ models })`. Anything
+ * else throws here, at construction.
+ *
  * @example
  * ```ts
- * const executors = createAiSdkExecutors({ models: { quick: openai('gpt-5.4-mini') } });
- * const result = await runToQuiescence(createAgentRuntime(machine, { executors }), { input });
+ * const agentSetup = setupAgent({ models: { quick: openai('gpt-6-luna') }, ... });
+ * const machine = agentSetup.createMachine({ ... });
+ * const result = await runAgent(machine, { input, executors: createAiSdkExecutors(machine) });
+ * // Or explicitly: createAiSdkExecutors({ models: { quick: openai('gpt-6-luna') } })
  * ```
  */
-declare function createAiSdkExecutors<TModels extends AiSdkModelMap>(options: CreateAiSdkExecutorsOptions<TModels>): AiSdkExecutors;
-//#endregion
-export { AiSdkCallSettings, AiSdkDecideResult, AiSdkExecutors, AiSdkGenerateResult, AiSdkModelEntry, AiSdkModelMap, AiSdkStreamResult, CreateAiSdkExecutorsOptions, createAiSdkExecutors, parseModelRef, toLanguageModel };
+export declare function createAiSdkExecutors<TModels extends AiSdkModelMap>(options: CreateAiSdkExecutorsOptions<TModels>): AiSdkExecutors;
+export declare function createAiSdkExecutors(machine: AnyStateMachine): AiSdkExecutors;
+//#endregion