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

package/dist/ai-sdk.mjs

@@ -1,6 +1,7 @@
-import { B as AgentTruncatedError, N as isStandardSchema, c as getAgentOutputMode, h as providerOutputSchema } from "./text-logic-CIqHAmBi.mjs";
-import { o as renderDecisionAttempts } from "./decision-RQ0iv0oZ.mjs";
-import { NoObjectGeneratedError, Output, generateText, stepCountIs, streamText, tool } from "ai";
+import { R as providerOutputSchema, ct as AgentTruncatedError, j as getAgentOutputMode, tt as isStandardSchema } from "./event-log-DJCMHek_.mjs";
+import { c as renderDecisionAttempts, m as isRecord, o as decisionOptionIds } from "./decision-BHkvuImD.mjs";
+import { t as resolveModelSource } from "./model-source-BaHwJ1wK.mjs";
+import { InvalidResponseDataError, NoObjectGeneratedError, Output, experimental_decide, generateText, jsonSchema, stepCountIs, streamText, tool } from "ai";
 //#region src/ai-sdk/mappers.ts
 /**
 * Maps an {@link AgentTools} map onto AI SDK `tool()` definitions. A tool that
@@ -23,7 +24,7 @@ function toAiSdkTools(tools) {
 			})]);
 			continue;
 		}
-		if (isStandardSchema(descriptor.inputSchema)) {
+		if (isStandardSchema(descriptor.inputSchema) || descriptor.type === "provider") {
 			entries.push([name, descriptor]);
 			continue;
 		}
@@ -173,6 +174,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 = decisionOptionIds(options);
+	const lines = options.map((option, index) => option.description ? `- ${ids[index]}: ${option.description}` : `- ${ids[index]}`);
+	return {
+		ids,
+		tools: { [OPTION_TOOL_NAME]: tool({
+			description: `Choose exactly one option:\n${lines.join("\n")}`,
+			inputSchema: 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 = 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})
@@ -196,9 +244,12 @@ function maxStepsSetting(request) {
 	const maxSteps = request.maxSteps;
 	return typeof maxSteps === "number" ? { stopWhen: stepCountIs(maxSteps) } : {};
 }
+function isDecisionModel(model) {
+	return 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`:
 *
@@ -230,12 +281,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) {
@@ -266,23 +327,10 @@ function truncated(request, info, partialOutput, cause) {
 		...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 = resolveModelSource("createAiSdkExecutors", source);
 	const generateText$1 = async (request, info) => {
-		const { model, settings: modelSettings } = resolveAiSdkModel(options, request.model);
+		const { model, settings: modelSettings } = resolveLanguageModel(options, request);
 		const common = {
 			model,
 			abortSignal: info?.signal,
@@ -331,7 +379,7 @@ function createAiSdkExecutors(options) {
 		};
 	};
 	const streamText$1 = async (request, info) => {
-		const { model, settings: modelSettings } = resolveAiSdkModel(options, request.model);
+		const { model, settings: modelSettings } = resolveLanguageModel(options, request);
 		const result = streamText({
 			model,
 			abortSignal: info?.signal,
@@ -351,7 +399,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 generateText({
 			model,
@@ -370,6 +420,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 {
@@ -387,5 +442,74 @@ 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 = 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?", ...renderDecisionAttempts(request).map((message) => message.content)].join("\n\n");
+	const ask = () => 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 (!InvalidResponseDataError.isInstance(error) || !isRecord(error.data)) return void 0;
+	const answer = error.data[DECISION_QUESTION_ID];
+	const choice = 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 isRecord(json) ? json : { value: json };
+	} catch {
+		return String(value);
+	}
+}
 //#endregion
 export { createAiSdkExecutors, parseModelRef, toLanguageModel };

package/dist/{decision-RQ0iv0oZ.mjs → decision-BHkvuImD.mjs}

@@ -1,4 +1,4 @@
-import { L as userMessage, R as validateSchemaSync, g as resolveTextLogicValue, n as DECIDE_ACTOR, v as executorBoundLogics, y as getAgentExecutionOptions, z as AgentError } from "./text-logic-CIqHAmBi.mjs";
+import { H as getAgentExecutionOptions, T as DECIDE_ACTOR, V as executorBoundLogics, at as userMessage, ot as validateSchemaSync, st as AgentError, u as canonicalEventJson, z as resolveTextLogicValue } from "./event-log-DJCMHek_.mjs";
 import { createAsyncLogic, getNextTransitions } from "xstate";
 //#region src/internal/is-record.ts
 /** True for a plain object-like value (arrays excluded). @internal */
@@ -33,7 +33,8 @@ function hashString(value) {
 	return (hash >>> 0).toString(36);
 }
 function sanitizeEventToolName(eventType) {
-	const base = `${EVENT_TOOL_PREFIX}${eventType.replace(/[^a-zA-Z0-9_-]/g, "_") || "event"}`;
+	const sanitizedType = eventType.replace(/[^a-zA-Z0-9_-]/g, "_") || "event";
+	const base = `${EVENT_TOOL_PREFIX}${sanitizedType}`;
 	if (base.length <= 64) return base;
 	const hash = hashString(eventType);
 	const prefixLength = 64 - hash.length - 1;
@@ -105,7 +106,8 @@ function parseAgentEvent(source, payload, options = {}) {
 	if (!isRecord(payload) || typeof payload.type !== "string") throw new AgentInvalidEventPayloadError("(unknown)", "expected an object with a string `type`.");
 	const event = payload;
 	if (isReservedAgentEvent(event.type)) throw new AgentInvalidEventPayloadError(event.type, "this event type is reserved for the library and cannot be sent from outside.");
-	const registered = getAgentExecutionOptions(typeof source.provide === "function" ? source : source.machine)?.schemas;
+	const machine = typeof source.provide === "function" ? source : source.machine;
+	const registered = getAgentExecutionOptions(machine)?.schemas;
 	const inputSchema = (options.events ?? options.schemas?.events ?? registered?.events)?.[event.type];
 	if (!inputSchema) return event;
 	const { type, ...fields } = event;
@@ -153,6 +155,53 @@ function getAcceptedEvents(snapshot, options = {}) {
 }
 //#endregion
 //#region src/decision.ts
+function optionsFromPayloads(eventTypes, payloads) {
+	return eventTypes.filter((type) => !isEventPattern(type)).flatMap((type) => (payloads[type] ?? [{}]).map((payload) => ({ event: {
+		...payload,
+		type
+	} })));
+}
+/**
+* The options a snapshot-aware host offers for a closed-choice request: rebuilt
+* over the request's snapshot-resolved candidate `events` when the decide input
+* carried `payloads` (so wildcard or omitted `allowedEvents` still get theirs),
+* then narrowed to the events `can` accepts. `undefined` when the request is
+* not a closed choice. Pass the result as the request's `options`;
+* {@link resolveDecision} then rejects a choice that matches none of them.
+* @internal
+*/
+function acceptedDecisionOptions(request, can) {
+	if (!request.options) return void 0;
+	const payloads = isRecord(request.input) ? request.input.payloads : void 0;
+	return (isRecord(payloads) ? optionsFromPayloads(request.events.map((event) => event.type), payloads) : request.options).filter((option) => {
+		try {
+			return can(option.event);
+		} catch {
+			return false;
+		}
+	});
+}
+/** The offered option equal to `event` (type and payload, key order ignored). @internal */
+function findDecisionOption(options, event) {
+	const key = canonicalEventJson(event);
+	return options.find((option) => canonicalEventJson(option.event) === key);
+}
+/**
+* Stable, readable ids for options, one per option in order: `type`, then each
+* payload value (`refund:40`). Duplicates get a `#n` suffix. Adapters use them
+* as the labels of a single closed choice and map the answer back by index.
+* @internal
+*/
+function decisionOptionIds(options) {
+	const taken = /* @__PURE__ */ new Set();
+	return options.map(({ event }) => {
+		const base = Object.entries(event).filter(([key]) => key !== "type").map(([, value]) => typeof value === "object" ? JSON.stringify(value) : String(value)).reduce((id, value) => `${id}:${value}`, event.type);
+		let id = base;
+		for (let n = 2; taken.has(id); n++) id = `${base}#${n}`;
+		taken.add(id);
+		return id;
+	});
+}
 function decideRequestFromInput(input) {
 	const allowedEventTypes = resolveAllowedEventTypes(input.allowedEvents, input) ?? [];
 	return {
@@ -168,6 +217,7 @@ function decideRequestFromInput(input) {
 			type,
 			toolName: sanitizeEventToolName(type)
 		})),
+		...input.payloads ? { options: optionsFromPayloads(allowedEventTypes, input.payloads) } : {},
 		attempts: [],
 		temperature: input.temperature,
 		maxOutputTokens: input.maxOutputTokens,
@@ -175,7 +225,8 @@ function decideRequestFromInput(input) {
 		topK: input.topK,
 		seed: input.seed,
 		stopSequences: input.stopSequences,
-		metadata: input.metadata
+		metadata: input.metadata,
+		maxRetries: input.maxRetries
 	};
 }
 function decideActorWithExecutor(execute) {
@@ -222,7 +273,7 @@ function resolveAllowedEventTypes(allowedEvents, input) {
 *
 * export const chooseMove = createDecisionLogic({
 *   schemas: { input: z.object({ playerHp: z.number(), enemyHp: z.number() }) },
-*   model: 'openai/gpt-5.4-mini',
+*   model: 'openai/gpt-6-luna',
 *   system: 'You are playing a turn-based game. Choose exactly one legal move.',
 *   prompt: ({ input }) => `Player HP: ${input.playerHp}\nEnemy HP: ${input.enemyHp}`,
 *   allowedEvents: ({ input }) =>
@@ -366,8 +417,8 @@ var AgentDecisionExhaustedError = class extends AgentError {
 * ```
 */
 function renderDecisionAttempts(request) {
-	const types = request.events.map((event) => event.type).join(", ") || "(none)";
-	return request.attempts.map((attempt) => userMessage(`Your previous choice failed: ${attempt.reason}. Choose again from: ${types}`));
+	const choices = (request.options ? decisionOptionIds(request.options) : request.events.map((event) => event.type)).join(", ") || "(none)";
+	return request.attempts.map((attempt) => userMessage(`Your previous choice failed: ${attempt.reason}. Choose again from: ${choices}`));
 }
 /**
 * Validation + retry core for decisions. No provider mechanics — the
@@ -381,6 +432,8 @@ function renderDecisionAttempts(request) {
 * event's schema), or `'rejected-by-guard'` (passes both checks but
 * `options.canTake` returns `false` — a type/payload-legal event the
 * machine's guard rejects right now; omit `canTake` to skip this check).
+* When the request carries `options`, a choice matching none of them (type and
+* payload, deep-equal) also fails as `'rejected-by-guard'`.
 * Every prior failed attempt for this call is fed back to the executor on
 * the next attempt via `request.attempts`, so an adapter can render "your
 * last choice failed because X — try again" into the next model call; core
@@ -400,6 +453,11 @@ async function resolveDecision(request, executors, options = {}) {
 	const maxRetries = options.maxRetries ?? 2;
 	const attempts = [];
 	const eventsByType = new Map(request.events.map((event) => [event.type, event]));
+	if (request.options !== void 0 && request.options.length === 0) {
+		const error = new AgentDecisionExhaustedError([]);
+		error.message = `Decision '${request.name ?? (request.id || "agent.decide")}' has no offered option the current snapshot accepts; no model call was made.`;
+		throw error;
+	}
 	for (let attempt = 0; attempt <= maxRetries; attempt++) {
 		options.signal?.throwIfAborted();
 		const result = await executor({
@@ -438,6 +496,14 @@ async function resolveDecision(request, executors, options = {}) {
 				continue;
 			}
 		}
+		if (request.options && !findDecisionOption(request.options, event) && !findDecisionOption(request.options, validatedEvent)) {
+			attempts.push({
+				event: validatedEvent,
+				failure: "rejected-by-guard",
+				reason: `${JSON.stringify(validatedEvent)} matched no offered option: ${decisionOptionIds(request.options).join(", ") || "(none)"}.`
+			});
+			continue;
+		}
 		if (options.canTake?.(validatedEvent) === false) {
 			attempts.push({
 				event: validatedEvent,
@@ -451,4 +517,4 @@ async function resolveDecision(request, executors, options = {}) {
 	throw new AgentDecisionExhaustedError(attempts);
 }
 //#endregion
-export { isDecisionLogic as a, AgentInvalidEventPayloadError as c, isRecord as d, createDecisionRequest as i, getAcceptedEvents as l, createDecideActor as n, renderDecisionAttempts as o, createDecisionLogic as r, resolveDecision as s, AgentDecisionExhaustedError as t, parseAgentEvent as u };
+export { createDecisionRequest as a, renderDecisionAttempts as c, getAcceptedEvents as d, isEventPattern as f, createDecisionLogic as i, resolveDecision as l, isRecord as m, acceptedDecisionOptions as n, decisionOptionIds as o, parseAgentEvent as p, createDecideActor as r, isDecisionLogic as s, AgentDecisionExhaustedError as t, AgentInvalidEventPayloadError as u };