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

package/dist/{decision-CmM8-HHz.cjs → decision-CIb7ddIv.cjs}

@@ -1,5 +1,4 @@
-const require_text_logic = require("./text-logic-f5F5sCdc.cjs");
-require("./validate.cjs");
+const require_event_log = require("./event-log-BZRfBRd7.cjs");
 let xstate = require("xstate");
 //#region src/internal/is-record.ts
 /** True for a plain object-like value (arrays excluded). @internal */
@@ -18,7 +17,7 @@ function isRecord(value) {
 * has no transition for, so an event the current state does not handle parses
 * fine and settles the run with `result.ignored` set.
 */
-var AgentInvalidEventPayloadError = class extends require_text_logic.AgentError {
+var AgentInvalidEventPayloadError = class extends require_event_log.AgentError {
 	eventType;
 	constructor(eventType, detail) {
 		super("invalid-event-payload", `Invalid event payload for '${eventType}': ${detail}`);
@@ -34,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;
@@ -106,13 +106,14 @@ 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 = require_text_logic.getAgentExecutionOptions(typeof source.provide === "function" ? source : source.machine)?.schemas;
+	const machine = typeof source.provide === "function" ? source : source.machine;
+	const registered = require_event_log.getAgentExecutionOptions(machine)?.schemas;
 	const inputSchema = (options.events ?? options.schemas?.events ?? registered?.events)?.[event.type];
 	if (!inputSchema) return event;
 	const { type, ...fields } = event;
 	try {
 		return {
-			...require_text_logic.validateSchemaSync(inputSchema, fields),
+			...require_event_log.validateSchemaSync(inputSchema, fields),
 			type
 		};
 	} catch (error) {
@@ -154,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 = require_event_log.canonicalEventJson(event);
+	return options.find((option) => require_event_log.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 {
@@ -169,6 +217,7 @@ function decideRequestFromInput(input) {
 			type,
 			toolName: sanitizeEventToolName(type)
 		})),
+		...input.payloads ? { options: optionsFromPayloads(allowedEventTypes, input.payloads) } : {},
 		attempts: [],
 		temperature: input.temperature,
 		maxOutputTokens: input.maxOutputTokens,
@@ -176,15 +225,16 @@ function decideRequestFromInput(input) {
 		topK: input.topK,
 		seed: input.seed,
 		stopSequences: input.stopSequences,
-		metadata: input.metadata
+		metadata: input.metadata,
+		maxRetries: input.maxRetries
 	};
 }
 function decideActorWithExecutor(execute) {
 	const logic = (0, xstate.createAsyncLogic)({ run: async ({ input, signal }) => {
-		if (!execute) throw new Error(`'${require_text_logic.DECIDE_ACTOR}' has no host execution. Provide an implementation with machine.provide({ actors: { '${require_text_logic.DECIDE_ACTOR}': ... } }) or resolve the returned agent request with resolveDecision(...).`);
+		if (!execute) throw new Error(`'${require_event_log.DECIDE_ACTOR}' has no host execution. Provide an implementation with machine.provide({ actors: { '${require_event_log.DECIDE_ACTOR}': ... } }) or resolve the returned agent request with resolveDecision(...).`);
 		const resolvedEventTypes = resolveAllowedEventTypes(input.allowedEvents, input);
-		if (resolvedEventTypes === void 0) throw new Error(`'${require_text_logic.DECIDE_ACTOR}' input has omitted \`allowedEvents\`, which means "all currently-legal events" — but that requires a snapshot-aware host (createAgentRuntime) to resolve. Under a bare createActor(...), declare \`allowedEvents\` explicitly to use this actor here.`);
-		if (resolvedEventTypes.some(isEventPattern)) throw new Error(`'${require_text_logic.DECIDE_ACTOR}' input uses wildcard \`allowedEvents\` patterns, which expand against the live snapshot — that requires a snapshot-aware host (createAgentRuntime). Under a bare createActor(...), list event types explicitly.`);
+		if (resolvedEventTypes === void 0) throw new Error(`'${require_event_log.DECIDE_ACTOR}' input has omitted \`allowedEvents\`, which means "all currently-legal events" — but that requires a snapshot-aware host (createAgentRuntime) to resolve. Under a bare createActor(...), declare \`allowedEvents\` explicitly to use this actor here.`);
+		if (resolvedEventTypes.some(isEventPattern)) throw new Error(`'${require_event_log.DECIDE_ACTOR}' input uses wildcard \`allowedEvents\` patterns, which expand against the live snapshot — that requires a snapshot-aware host (createAgentRuntime). Under a bare createActor(...), list event types explicitly.`);
 		return resolveDecision(decideRequestFromInput(input), { decide: execute }, {
 			maxRetries: input.maxRetries ?? 2,
 			signal
@@ -223,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 }) =>
@@ -236,30 +286,30 @@ function resolveAllowedEventTypes(allowedEvents, input) {
 function createDecisionLogic(config, execute) {
 	const maxRetries = config.maxRetries ?? 2;
 	const request = (input) => {
-		const parsedInput = config.schemas ? require_text_logic.validateSchemaSync(config.schemas.input, input) : input;
+		const parsedInput = config.schemas ? require_event_log.validateSchemaSync(config.schemas.input, input) : input;
 		const args = { input: parsedInput };
 		const allowedEventTypes = resolveAllowedEventTypes(config.allowedEvents, parsedInput);
 		return {
 			kind: "decision",
 			id: "",
-			name: require_text_logic.resolveTextLogicValue(config.name, args),
+			name: require_event_log.resolveTextLogicValue(config.name, args),
 			input: parsedInput,
-			model: require_text_logic.resolveTextLogicValue(config.model, args),
-			system: require_text_logic.resolveTextLogicValue(config.system, args),
-			prompt: require_text_logic.resolveTextLogicValue(config.prompt, args),
-			messages: require_text_logic.resolveTextLogicValue(config.messages, args),
+			model: require_event_log.resolveTextLogicValue(config.model, args),
+			system: require_event_log.resolveTextLogicValue(config.system, args),
+			prompt: require_event_log.resolveTextLogicValue(config.prompt, args),
+			messages: require_event_log.resolveTextLogicValue(config.messages, args),
 			events: (allowedEventTypes ?? []).map((type) => ({
 				type,
 				toolName: sanitizeEventToolName(type)
 			})),
 			attempts: [],
-			temperature: require_text_logic.resolveTextLogicValue(config.temperature, args),
-			maxOutputTokens: require_text_logic.resolveTextLogicValue(config.maxOutputTokens, args),
-			topP: require_text_logic.resolveTextLogicValue(config.topP, args),
-			topK: require_text_logic.resolveTextLogicValue(config.topK, args),
-			seed: require_text_logic.resolveTextLogicValue(config.seed, args),
-			stopSequences: require_text_logic.resolveTextLogicValue(config.stopSequences, args),
-			metadata: require_text_logic.resolveTextLogicValue(config.metadata, args)
+			temperature: require_event_log.resolveTextLogicValue(config.temperature, args),
+			maxOutputTokens: require_event_log.resolveTextLogicValue(config.maxOutputTokens, args),
+			topP: require_event_log.resolveTextLogicValue(config.topP, args),
+			topK: require_event_log.resolveTextLogicValue(config.topK, args),
+			seed: require_event_log.resolveTextLogicValue(config.seed, args),
+			stopSequences: require_event_log.resolveTextLogicValue(config.stopSequences, args),
+			metadata: require_event_log.resolveTextLogicValue(config.metadata, args)
 		};
 	};
 	const logic = (0, xstate.createAsyncLogic)({ run: async ({ input, signal }) => {
@@ -281,7 +331,7 @@ function createDecisionLogic(config, execute) {
 			return createDecisionLogic(config, nextExecute);
 		}
 	});
-	if (execute) require_text_logic.executorBoundLogics.add(decisionLogic);
+	if (execute) require_event_log.executorBoundLogics.add(decisionLogic);
 	return decisionLogic;
 }
 /** Type guard: true for any actor logic built by createDecisionLogic/createDecideActor (checks the `kind` marker). @internal */
@@ -344,7 +394,7 @@ function dedupeToolNames(candidates) {
 * diagnostics; a machine typically routes this via the decision invoke's
 * `onError`.
 */
-var AgentDecisionExhaustedError = class extends require_text_logic.AgentError {
+var AgentDecisionExhaustedError = class extends require_event_log.AgentError {
 	attempts;
 	constructor(attempts) {
 		super("decision-exhausted", `Decision exhausted after ${attempts.length} attempt${attempts.length === 1 ? "" : "s"}: ` + attempts.map((attempt) => attempt.reason).join("; "));
@@ -367,8 +417,8 @@ var AgentDecisionExhaustedError = class extends require_text_logic.AgentError {
 * ```
 */
 function renderDecisionAttempts(request) {
-	const types = request.events.map((event) => event.type).join(", ") || "(none)";
-	return request.attempts.map((attempt) => require_text_logic.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) => require_event_log.userMessage(`Your previous choice failed: ${attempt.reason}. Choose again from: ${choices}`));
 }
 /**
 * Validation + retry core for decisions. No provider mechanics — the
@@ -382,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
@@ -397,10 +449,15 @@ function renderDecisionAttempts(request) {
 */
 async function resolveDecision(request, executors, options = {}) {
 	const executor = executors?.decide;
-	if (typeof executor !== "function") throw new require_text_logic.AgentError("missing-decide-executor", "resolveDecision(request, executors, ...) takes the EXECUTOR SET (the same object executeAgentRequest takes), and this one has no 'decide' function. Build one with createAiSdkExecutors({ models }), or pass { decide }.");
+	if (typeof executor !== "function") throw new require_event_log.AgentError("missing-decide-executor", "resolveDecision(request, executors, ...) takes the EXECUTOR SET (the same object executeAgentRequest takes), and this one has no 'decide' function. Build one with createAiSdkExecutors({ models }), or pass { decide }.");
 	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({
@@ -427,7 +484,7 @@ async function resolveDecision(request, executors, options = {}) {
 			const { type, ...payload } = event;
 			try {
 				validatedEvent = {
-					...require_text_logic.validateSchemaSync(descriptor.inputSchema, payload),
+					...require_event_log.validateSchemaSync(descriptor.inputSchema, payload),
 					type
 				};
 			} catch (error) {
@@ -439,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,
@@ -464,6 +529,12 @@ Object.defineProperty(exports, "AgentInvalidEventPayloadError", {
 		return AgentInvalidEventPayloadError;
 	}
 });
+Object.defineProperty(exports, "acceptedDecisionOptions", {
+	enumerable: true,
+	get: function() {
+		return acceptedDecisionOptions;
+	}
+});
 Object.defineProperty(exports, "createDecideActor", {
 	enumerable: true,
 	get: function() {
@@ -482,6 +553,12 @@ Object.defineProperty(exports, "createDecisionRequest", {
 		return createDecisionRequest;
 	}
 });
+Object.defineProperty(exports, "decisionOptionIds", {
+	enumerable: true,
+	get: function() {
+		return decisionOptionIds;
+	}
+});
 Object.defineProperty(exports, "getAcceptedEvents", {
 	enumerable: true,
 	get: function() {
@@ -494,6 +571,12 @@ Object.defineProperty(exports, "isDecisionLogic", {
 		return isDecisionLogic;
 	}
 });
+Object.defineProperty(exports, "isEventPattern", {
+	enumerable: true,
+	get: function() {
+		return isEventPattern;
+	}
+});
 Object.defineProperty(exports, "isRecord", {
 	enumerable: true,
 	get: function() {