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

package/dist/{decision-CQdrKc8k.mjs → events-JiVPYrct.mjs}

@@ -1,4 +1,4 @@
-import { createAsyncLogic, createLogic, getNextTransitions } from "xstate";
+import { createAsyncLogic, getNextTransitions } from "xstate";
 //#region src/utils.ts
 /**
 * Deep-clones a snapshot to a plain-JSON value via a `JSON` round-trip, the
@@ -221,9 +221,6 @@ function validateSchemaSync(schema, value) {
 //#endregion
 //#region src/internal/registry.ts
 const agentExecutionOptions = /* @__PURE__ */ new WeakMap();
-function getRegisteredAgentModels(machine) {
-	return agentExecutionOptions.get(machine)?.models;
-}
 /**
 * Machine-carried wait-state predicates, keyed on the machine's root `config`
 * object. `config` is shared by reference across `machine.provide(...)` (unlike
@@ -294,7 +291,13 @@ const agentTextInputSchema = { "~standard": {
 	version: 1,
 	vendor: "statelyai-agent",
 	validate(value) {
-		return !!value && typeof value === "object" && typeof value.model === "string" ? { value } : { issues: [{ message: "Expected agent text input with a model" }] };
+		if (!value || typeof value !== "object") return { issues: [{ message: "Expected agent text input object" }] };
+		const request = value;
+		if (typeof request.model !== "string") return { issues: [{ message: "Expected agent text input with a string `model`" }] };
+		const hasPrompt = typeof request.prompt === "string" && request.prompt.length > 0;
+		const hasMessages = Array.isArray(request.messages) && request.messages.length > 0;
+		if (!hasPrompt && !hasMessages) return { issues: [{ message: `Agent text request${request.name ? ` '${request.name}'` : ""} has neither a non-empty \`prompt\` nor \`messages\` — provide at least one so the model has something to respond to.` }] };
+		return { value: request };
 	}
 } };
 const unknownOutputSchema = { "~standard": {
@@ -654,7 +657,7 @@ function invalidGeneratorResult(id) {
 }
 //#endregion
 //#region src/events.ts
-/** Default prefix for the synthetic tool name generated per candidate event (e.g. `send_event_ASK`). Override per-request with {@link AgentEventToolNameResolver}. */
+/** Default prefix for the synthetic tool name generated per candidate event (e.g. `send_event_ASK`). Override per-request with {@link AgentEventToolNameResolver}. @internal */
 const EVENT_TOOL_PREFIX = "send_event_";
 function hashString(value) {
 	let hash = 5381;
@@ -753,226 +756,4 @@ function getAcceptedEvents(snapshot, options = {}) {
 	});
 }
 //#endregion
-//#region src/decision.ts
-function decideRequestFromInput(input) {
-	const allowedEventTypes = resolveAllowedEventTypes(input.allowedEvents, input) ?? [];
-	return {
-		kind: "decision",
-		id: "",
-		model: input.model,
-		system: input.system,
-		prompt: input.prompt,
-		messages: input.messages,
-		events: allowedEventTypes.filter((type) => !isEventPattern(type)).map((type) => ({
-			type,
-			toolName: sanitizeEventToolName(type)
-		})),
-		attempts: [],
-		temperature: input.temperature,
-		maxOutputTokens: input.maxOutputTokens,
-		topP: input.topP,
-		topK: input.topK,
-		seed: input.seed,
-		stopSequences: input.stopSequences,
-		metadata: input.metadata
-	};
-}
-function decideActorWithExecutor(execute) {
-	const logic = createAsyncLogic({ run: async ({ input, signal }) => {
-		if (!execute) throw new Error(`'${DECIDE_ACTOR}' has no host execution. Provide an implementation with machine.provide({ actorSources: { '${DECIDE_ACTOR}': ... } }) or resolve the returned agent request with resolveDecision(...).`);
-		const resolvedEventTypes = resolveAllowedEventTypes(input.allowedEvents, input);
-		if (resolvedEventTypes === void 0) throw new Error(`'${DECIDE_ACTOR}' input has omitted \`allowedEvents\`, which means "all currently-legal events" — but that requires a snapshot-aware host (runAgent or the step path) to resolve. Under a bare createActor(...), declare \`allowedEvents\` explicitly to use this actor here.`);
-		if (resolvedEventTypes.some(isEventPattern)) throw new Error(`'${DECIDE_ACTOR}' input uses wildcard \`allowedEvents\` patterns, which expand against the live snapshot — that requires a snapshot-aware host (runAgent or the step path). Under a bare createActor(...), list event types explicitly.`);
-		return resolveDecision(decideRequestFromInput(input), execute, {
-			maxRetries: input.maxRetries ?? 2,
-			signal
-		});
-	} });
-	return Object.assign(logic, {
-		kind: "statelyai.decisionLogic",
-		maxRetries: 2,
-		request: decideRequestFromInput,
-		allowedEventTypes: (input) => resolveAllowedEventTypes(input.allowedEvents, input),
-		withExecutor: (nextExecute) => decideActorWithExecutor(nextExecute)
-	});
-}
-function createDecideActor() {
-	return decideActorWithExecutor();
-}
-/**
-* Reserved event type the `agent.plan` builtin adds to every step's
-* candidates as the explicit "no further action needed" move. Choosing it
-* ends the plan (`stopped: 'done'`); it is never sent to the machine, so
-* machines need no no-op sentinel event of their own.
-*/
-const PLAN_DONE_EVENT_TYPE = "agent.plan.done";
-function createPlanActor() {
-	const logic = createLogic({
-		context: ({ input }) => ({
-			applied: [],
-			stepsRemaining: input.maxSteps ?? 8,
-			stopped: null
-		}),
-		run: ({ context, event }) => event.type === "plan.applied" ? { context: {
-			...context,
-			applied: [...context.applied, event.event],
-			stepsRemaining: context.stepsRemaining - 1
-		} } : event.type === "plan.ended" ? {
-			context: {
-				...context,
-				stopped: event.stopped
-			},
-			status: "done",
-			output: {
-				steps: context.applied,
-				stopped: event.stopped
-			}
-		} : void 0
-	});
-	return Object.assign(logic, {
-		kind: "statelyai.planLogic",
-		maxRetries: 2,
-		request: decideRequestFromInput,
-		allowedEventTypes: (input) => resolveAllowedEventTypes(input.allowedEvents, input)
-	});
-}
-const PLAN_LEDGER_SCOPE = { emit: () => {} };
-/**
-* Builds a fresh plan ledger snapshot from resolved plan input — the shared
-* starting point for BOTH hosts (the step path reads the invoke child's own
-* initial snapshot; runAgent seeds a local ledger with this). @internal
-*/
-function initialPlanLedger(logic, input) {
-	return logic.getInitialSnapshot(PLAN_LEDGER_SCOPE, input);
-}
-/**
-* Advances a plan ledger by one {@link PlanLedgerEvent}, returning the next
-* snapshot (unwrapping `createLogic`'s `[snapshot, effects]` tuple). Pure — no
-* mutation of the input snapshot. @internal
-*/
-function advancePlanLedger(logic, snapshot, event) {
-	const result = logic.transition(snapshot, event, PLAN_LEDGER_SCOPE);
-	return Array.isArray(result) ? result[0] : result;
-}
-/** Type guard: true for the `agent.plan` builtin logic (checks the `kind` marker). @internal */
-function isPlanLogic(logic) {
-	return !!logic && logic.kind === "statelyai.planLogic";
-}
-function resolveAllowedEventTypes(allowedEvents, input) {
-	if (allowedEvents === void 0) return;
-	const resolved = typeof allowedEvents === "function" ? allowedEvents({ input }) : allowedEvents;
-	return typeof resolved === "string" ? [resolved] : resolved;
-}
-/** Type guard: true for any actor logic built by createDecisionLogic/createDecideActor (checks the `kind` marker). @internal */
-function isDecisionLogic(value) {
-	return !!value && typeof value === "object" && value.kind === "statelyai.decisionLogic" && typeof value.request === "function";
-}
-/**
-* Thrown by {@link resolveDecision} when every attempt (up to
-* `maxRetries + 1` of them) fails one of the three checks recorded in
-* {@link DecisionAttempt.failure}. Carries the full `attempts` list for
-* diagnostics; a machine typically routes this via the decision invoke's
-* `onError`.
-*/
-var DecisionExhaustedError = class extends Error {
-	attempts;
-	constructor(attempts) {
-		super(`Decision exhausted after ${attempts.length} attempt${attempts.length === 1 ? "" : "s"}: ` + attempts.map((attempt) => attempt.reason).join("; "));
-		this.name = "DecisionExhaustedError";
-		this.attempts = attempts;
-	}
-};
-/**
-* Renders a decision request's prior failed `attempts` into feedback messages
-* a host appends to the model call so retries converge — the transport-agnostic
-* "your last choice failed because X, choose again from Y" logic every adapter
-* and raw-SDK host repeats. Returns one `user`-role {@link AgentMessage} per
-* attempt (empty when there are none); adapters map each onto their wire
-* message shape (`attempt.content` is always a string). Core never rewrites the
-* request itself — this only turns the recorded attempts into messages.
-*
-* @example
-* ```ts
-* const messages = [...baseMessages, ...renderDecisionAttempts(request)];
-* ```
-*/
-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}`));
-}
-/**
-* Validation + retry core for decisions. No provider mechanics — the
-* `executor` is responsible for making the model choose an event; this
-* function only validates the choice and retries on failure, up to
-* `options.maxRetries` (default 2, i.e. up to 3 attempts total).
-*
-* Each attempt is checked in order and can fail one of three ways (recorded
-* as a {@link DecisionAttempt}): `'unknown-event'` (the chosen `type` is not
-* among `request.events`), `'invalid-payload'` (the payload fails that
-* 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).
-* 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
-* never rewrites the request itself. Exhausting all attempts throws
-* {@link DecisionExhaustedError} with the full attempts list.
-*
-* @example
-* ```ts
-* const event = await resolveDecision(request, decide, {
-*   canTake: (e) => snapshot.can(e),
-* });
-* ```
-*/
-async function resolveDecision(request, executor, options = {}) {
-	const maxRetries = options.maxRetries ?? 2;
-	const attempts = [];
-	const eventsByType = new Map(request.events.map((event) => [event.type, event]));
-	for (let attempt = 0; attempt <= maxRetries; attempt++) {
-		options.signal?.throwIfAborted();
-		const { event } = await executor({
-			...request,
-			attempts: [...attempts],
-			signal: options.signal
-		});
-		const descriptor = eventsByType.get(event.type);
-		if (!descriptor) {
-			attempts.push({
-				event,
-				failure: "unknown-event",
-				reason: `'${event.type}' is not among the currently allowed events: ${request.events.map((candidate) => candidate.type).join(", ") || "(none)"}.`
-			});
-			continue;
-		}
-		let validatedEvent = event;
-		if (descriptor.inputSchema) {
-			const { type, ...payload } = event;
-			try {
-				validatedEvent = {
-					...validateSchemaSync(descriptor.inputSchema, payload),
-					type
-				};
-			} catch (error) {
-				attempts.push({
-					event,
-					failure: "invalid-payload",
-					reason: `'${event.type}' payload failed validation: ${error instanceof Error ? error.message : String(error)}`
-				});
-				continue;
-			}
-		}
-		if (options.canTake?.(validatedEvent) === false) {
-			attempts.push({
-				event: validatedEvent,
-				failure: "rejected-by-guard",
-				reason: `'${validatedEvent.type}' is not currently takeable (guard rejected it).`
-			});
-			continue;
-		}
-		return validatedEvent;
-	}
-	throw new DecisionExhaustedError(attempts);
-}
-//#endregion
-export { validateSchemaSync as $, parseOutput as A, missingActor as B, createTextLogic as C, isTextLogic as D, isStructuredOutputSchema as E, getMachineSuspensionPredicate as F, getJsonSchemaSync as G, findNonSerializableContextPaths as H, getRegisteredAgentExecutionOptions as I, isStandardSchema as J, getMachineStructuralHash as K, getRegisteredAgentModels as L, userInputActor as M, agentExecutionOptions as N, normalizeGeneratorResult as O, executorBoundLogics as P, userMessage as Q, isUnboundPlaceholder as R, builtinTextActors as S, getAgentOutputMode as T, getAgentMessages as U, assistantMessage as V, getJsonSchema as W, systemMessage as X, persistSnapshot as Y, toolMessage as Z, INTERPRET_SOURCE as _, createPlanActor as a, bindRequestExecutor as b, isPlanLogic as c, EVENT_TOOL_PREFIX as d, getAcceptedEvents as f, DECIDE_ACTOR as g, sanitizeEventToolName as h, createDecideActor as i, parseStructuredEnvelope as j, parseModelRef as k, renderDecisionAttempts as l, parseAgentEvent as m, PLAN_DONE_EVENT_TYPE as n, initialPlanLedger as o, matchesEventPattern as p, getStateMeta as q, advancePlanLedger as r, isDecisionLogic as s, DecisionExhaustedError as t, resolveDecision as u, PLAN_ACTOR as v, executeAgentTextRequest as w, buildEnvelopeSchema as x, USER_INPUT_ACTOR as y, machineSuspensionPredicates as z };
+export { assistantMessage as A, toolMessage as B, agentExecutionOptions as C, isUnboundPlaceholder as D, getRegisteredAgentExecutionOptions as E, getMachineStructuralHash as F, validateSchemaSync as H, getStateMeta as I, isStandardSchema as L, getAgentMessages as M, getJsonSchema as N, machineSuspensionPredicates as O, getJsonSchemaSync as P, persistSnapshot as R, userInputActor as S, getMachineSuspensionPredicate as T, userMessage as V, isTextLogic as _, sanitizeEventToolName as a, parseOutput as b, PLAN_ACTOR as c, buildEnvelopeSchema as d, builtinTextActors as f, isStructuredOutputSchema as g, getAgentOutputMode as h, parseAgentEvent as i, findNonSerializableContextPaths as j, missingActor as k, USER_INPUT_ACTOR as l, executeAgentTextRequest as m, isEventPattern as n, DECIDE_ACTOR as o, createTextLogic as p, matchesEventPattern as r, INTERPRET_SOURCE as s, getAcceptedEvents as t, bindRequestExecutor as u, normalizeGeneratorResult as v, executorBoundLogics as w, parseStructuredEnvelope as x, parseModelRef as y, systemMessage as z };