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

package/dist/openai-compat.cjs

@@ -1,27 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_decision = require("./decision-b-lkcs4L.cjs");
-//#region src/openai-compat/index.ts
-/**
-* OpenAI-compatible Chat Completions adapter — a COMPLETE `{ generateText,
-* streamText, decide }` executor set built on raw `fetch`, with zero runtime
-* dependencies (no `openai` package, no Vercel AI SDK).
-*
-* The OpenAI Chat Completions wire format is the lingua franca of hosted and
-* local inference: Groq, Together, Fireworks, OpenRouter, vLLM, Ollama, LM
-* Studio, and OpenAI itself all speak it. Point `baseUrl` at any of them.
-*
-* Compare `createAiSdkExecutors` in `../ai-sdk/index.ts` (the AI-SDK-backed
-* adapter) — same three-function contract, different transport. The request
-* mapping is ported from `examples/openai-sdk-host/index.ts`, but wired
-* against `POST {baseUrl}/chat/completions` instead of the `openai` package.
-*/
-/**
-* Reads a Standard Schema's optional `~standard.jsonSchema.input()` extension
-* (implemented by e.g. Zod v4's `z.toJSONSchema`), awaiting it when it returns
-* a Promise. Returns `undefined` when the schema doesn't expose the extension.
-* Thin re-export of core's {@link getJsonSchema}.
-*/
-const extractJsonSchema = require_decision.getJsonSchema;
+const require_events = require("./events-CRQj3VtP.cjs");
+const require_decision = require("./decision-D8wJrM8W.cjs");
+//#region src/openai-compat/mappers.ts
 /** Maps `AgentTextRequest.messages`/`system`/`prompt` to Chat Completions messages. */
 function toOpenAiMessages(request) {
 	if (request.messages) return request.messages.flatMap((message) => {
@@ -82,7 +62,7 @@ function toOpenAiTools(tools) {
 			function: {
 				name,
 				description: typeof descriptor === "function" ? void 0 : descriptor.description,
-				parameters: (require_decision.isStandardSchema(inputSchema) ? require_decision.getJsonSchemaSync(inputSchema) : void 0) ?? {}
+				parameters: (require_events.isStandardSchema(inputSchema) ? require_events.getJsonSchemaSync(inputSchema) : void 0) ?? {}
 			}
 		}];
 	});
@@ -95,7 +75,7 @@ function toOpenAiEventTools(events) {
 		function: {
 			name: event.toolName,
 			description: `Choose the '${event.type}' move.`,
-			parameters: require_decision.getJsonSchemaSync(event.inputSchema) ?? {}
+			parameters: require_events.getJsonSchemaSync(event.inputSchema) ?? {}
 		}
 	}));
 }
@@ -113,6 +93,22 @@ function toDecisionMessages(request) {
 function pruneUndefined(record) {
 	return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0));
 }
+//#endregion
+//#region src/openai-compat/index.ts
+/**
+* OpenAI-compatible Chat Completions adapter — a COMPLETE `{ generateText,
+* streamText, decide }` executor set built on raw `fetch`, with zero runtime
+* dependencies (no `openai` package, no Vercel AI SDK).
+*
+* The OpenAI Chat Completions wire format is the lingua franca of hosted and
+* local inference: Groq, Together, Fireworks, OpenRouter, vLLM, Ollama, LM
+* Studio, and OpenAI itself all speak it. Point `baseUrl` at any of them.
+*
+* Compare `createAiSdkExecutors` in `../ai-sdk/index.ts` (the AI-SDK-backed
+* adapter) — same three-function contract, different transport. The request
+* mapping is ported from `examples/openai-sdk-host/index.ts`, but wired
+* against `POST {baseUrl}/chat/completions` instead of the `openai` package.
+*/
 /**
 * Builds a complete `{ generateText, streamText, decide }` executor set over
 * the OpenAI Chat Completions wire format via raw `fetch`.
@@ -165,9 +161,9 @@ function createOpenAiCompatExecutors(options) {
 			...tools.length > 0 ? { tools } : {},
 			...request.toolChoice ? { tool_choice: toWireToolChoice(request.toolChoice) } : {}
 		};
-		const structured = require_decision.getAgentOutputMode(request.outputSchema) === "structured";
+		const structured = require_events.getAgentOutputMode(request.outputSchema) === "structured";
 		if (structured) {
-			const jsonSchema = await require_decision.getJsonSchema(require_decision.buildEnvelopeSchema(request.outputSchema, { reasoning: request.reasoning }));
+			const jsonSchema = await require_events.getJsonSchema(require_events.buildEnvelopeSchema(request.outputSchema, { reasoning: request.reasoning }));
 			body.response_format = jsonSchema ? {
 				type: "json_schema",
 				json_schema: {
@@ -311,9 +307,3 @@ function errorMessage(error) {
 }
 //#endregion
 exports.createOpenAiCompatExecutors = createOpenAiCompatExecutors;
-exports.extractJsonSchema = extractJsonSchema;
-exports.toDecisionMessages = toDecisionMessages;
-exports.toOpenAiCallSettings = toOpenAiCallSettings;
-exports.toOpenAiEventTools = toOpenAiEventTools;
-exports.toOpenAiMessages = toOpenAiMessages;
-exports.toOpenAiTools = toOpenAiTools;

package/dist/openai-compat.d.cts

@@ -1,46 +1,6 @@
-import { u as AgentTools } from "./types-C9QiMjre.cjs";
-import { H as AgentEventDescriptor, j as AgentDecisionRequest, k as AgentDecisionExecutor, l as AgentTextRequest, s as AgentRequestExecutors } from "./text-logic-CZjyACzQ.cjs";
-import { r as getJsonSchema } from "./utils-Dri7aeEG.cjs";
+import { k as AgentDecisionExecutor, s as AgentRequestExecutors } from "./text-logic-Ckhr2kKC.cjs";
 
 //#region src/openai-compat/index.d.ts
-interface WireMessage {
-  role: "system" | "user" | "assistant" | "tool";
-  content: string;
-  tool_call_id?: string;
-}
-interface WireTool {
-  type: "function";
-  function: {
-    name: string;
-    description?: string;
-    parameters: Record<string, unknown>;
-  };
-}
-/**
- * Reads a Standard Schema's optional `~standard.jsonSchema.input()` extension
- * (implemented by e.g. Zod v4's `z.toJSONSchema`), awaiting it when it returns
- * a Promise. Returns `undefined` when the schema doesn't expose the extension.
- * Thin re-export of core's {@link getJsonSchema}.
- */
-declare const extractJsonSchema: typeof getJsonSchema;
-/** Maps `AgentTextRequest.messages`/`system`/`prompt` to Chat Completions messages. */
-declare function toOpenAiMessages(request: Pick<AgentTextRequest, "system" | "prompt" | "messages">): WireMessage[];
-/**
- * Maps sampling/stop settings. Targets `max_tokens` (not
- * `max_completion_tokens`) — it's the field every OpenAI-compatible backend
- * accepts (Ollama, vLLM, Groq, …), where `max_completion_tokens` is
- * OpenAI-only. Undefined fields are pruned so they never hit the wire.
- */
-declare function toOpenAiCallSettings(request: AgentTextRequest): Record<string, unknown>;
-/** One wire function tool per `AgentTools` entry. */
-declare function toOpenAiTools(tools: AgentTools): WireTool[];
-/** One wire function tool per candidate decision event — the
- * "tool-per-event + tool_choice: 'required'" recipe. */
-declare function toOpenAiEventTools(events: AgentEventDescriptor[]): WireTool[];
-/** Messages for a decision request, with prior failed `attempts` rendered as
- * appended user messages (via core's {@link renderDecisionAttempts}) so
- * retries converge. */
-declare function toDecisionMessages(request: Pick<AgentDecisionRequest, "messages" | "prompt" | "events" | "attempts">): WireMessage[];
 /** Minimal `fetch` shape the adapter needs — matches the global `fetch` and
  * Cloudflare Workers' `fetch`, so a custom transport is drop-in. */
 type FetchLike = (input: string, init: {
@@ -76,6 +36,7 @@ interface CreateOpenAiCompatExecutorsOptions {
 }
 /** `createOpenAiCompatExecutors` always populates all three executor slots. */
 interface OpenAiCompatExecutors extends AgentRequestExecutors {
+  generateText: NonNullable<AgentRequestExecutors["generateText"]>;
   streamText: NonNullable<AgentRequestExecutors["streamText"]>;
   decide: AgentDecisionExecutor;
 }
@@ -95,4 +56,4 @@ interface OpenAiCompatExecutors extends AgentRequestExecutors {
  */
 declare function createOpenAiCompatExecutors(options: CreateOpenAiCompatExecutorsOptions): OpenAiCompatExecutors;
 //#endregion
-export { CreateOpenAiCompatExecutorsOptions, FetchLike, OpenAiCompatExecutors, createOpenAiCompatExecutors, extractJsonSchema, toDecisionMessages, toOpenAiCallSettings, toOpenAiEventTools, toOpenAiMessages, toOpenAiTools };
+export { CreateOpenAiCompatExecutorsOptions, FetchLike, OpenAiCompatExecutors, createOpenAiCompatExecutors };

package/dist/openai-compat.d.mts

@@ -1,46 +1,6 @@
-import { u as AgentTools } from "./types-qm00QF91.mjs";
-import { H as AgentEventDescriptor, j as AgentDecisionRequest, k as AgentDecisionExecutor, l as AgentTextRequest, s as AgentRequestExecutors } from "./text-logic-C7WJpCIc.mjs";
-import { r as getJsonSchema } from "./utils-Y6GDRGGE.mjs";
+import { k as AgentDecisionExecutor, s as AgentRequestExecutors } from "./text-logic-CaKqgX4Y.mjs";
 
 //#region src/openai-compat/index.d.ts
-interface WireMessage {
-  role: "system" | "user" | "assistant" | "tool";
-  content: string;
-  tool_call_id?: string;
-}
-interface WireTool {
-  type: "function";
-  function: {
-    name: string;
-    description?: string;
-    parameters: Record<string, unknown>;
-  };
-}
-/**
- * Reads a Standard Schema's optional `~standard.jsonSchema.input()` extension
- * (implemented by e.g. Zod v4's `z.toJSONSchema`), awaiting it when it returns
- * a Promise. Returns `undefined` when the schema doesn't expose the extension.
- * Thin re-export of core's {@link getJsonSchema}.
- */
-declare const extractJsonSchema: typeof getJsonSchema;
-/** Maps `AgentTextRequest.messages`/`system`/`prompt` to Chat Completions messages. */
-declare function toOpenAiMessages(request: Pick<AgentTextRequest, "system" | "prompt" | "messages">): WireMessage[];
-/**
- * Maps sampling/stop settings. Targets `max_tokens` (not
- * `max_completion_tokens`) — it's the field every OpenAI-compatible backend
- * accepts (Ollama, vLLM, Groq, …), where `max_completion_tokens` is
- * OpenAI-only. Undefined fields are pruned so they never hit the wire.
- */
-declare function toOpenAiCallSettings(request: AgentTextRequest): Record<string, unknown>;
-/** One wire function tool per `AgentTools` entry. */
-declare function toOpenAiTools(tools: AgentTools): WireTool[];
-/** One wire function tool per candidate decision event — the
- * "tool-per-event + tool_choice: 'required'" recipe. */
-declare function toOpenAiEventTools(events: AgentEventDescriptor[]): WireTool[];
-/** Messages for a decision request, with prior failed `attempts` rendered as
- * appended user messages (via core's {@link renderDecisionAttempts}) so
- * retries converge. */
-declare function toDecisionMessages(request: Pick<AgentDecisionRequest, "messages" | "prompt" | "events" | "attempts">): WireMessage[];
 /** Minimal `fetch` shape the adapter needs — matches the global `fetch` and
  * Cloudflare Workers' `fetch`, so a custom transport is drop-in. */
 type FetchLike = (input: string, init: {
@@ -76,6 +36,7 @@ interface CreateOpenAiCompatExecutorsOptions {
 }
 /** `createOpenAiCompatExecutors` always populates all three executor slots. */
 interface OpenAiCompatExecutors extends AgentRequestExecutors {
+  generateText: NonNullable<AgentRequestExecutors["generateText"]>;
   streamText: NonNullable<AgentRequestExecutors["streamText"]>;
   decide: AgentDecisionExecutor;
 }
@@ -95,4 +56,4 @@ interface OpenAiCompatExecutors extends AgentRequestExecutors {
  */
 declare function createOpenAiCompatExecutors(options: CreateOpenAiCompatExecutorsOptions): OpenAiCompatExecutors;
 //#endregion
-export { CreateOpenAiCompatExecutorsOptions, FetchLike, OpenAiCompatExecutors, createOpenAiCompatExecutors, extractJsonSchema, toDecisionMessages, toOpenAiCallSettings, toOpenAiEventTools, toOpenAiMessages, toOpenAiTools };
+export { CreateOpenAiCompatExecutorsOptions, FetchLike, OpenAiCompatExecutors, createOpenAiCompatExecutors };

package/dist/openai-compat.mjs

@@ -1,26 +1,6 @@
-import { G as getJsonSchemaSync, J as isStandardSchema, T as getAgentOutputMode, W as getJsonSchema, l as renderDecisionAttempts, x as buildEnvelopeSchema } from "./decision-CQdrKc8k.mjs";
-//#region src/openai-compat/index.ts
-/**
-* OpenAI-compatible Chat Completions adapter — a COMPLETE `{ generateText,
-* streamText, decide }` executor set built on raw `fetch`, with zero runtime
-* dependencies (no `openai` package, no Vercel AI SDK).
-*
-* The OpenAI Chat Completions wire format is the lingua franca of hosted and
-* local inference: Groq, Together, Fireworks, OpenRouter, vLLM, Ollama, LM
-* Studio, and OpenAI itself all speak it. Point `baseUrl` at any of them.
-*
-* Compare `createAiSdkExecutors` in `../ai-sdk/index.ts` (the AI-SDK-backed
-* adapter) — same three-function contract, different transport. The request
-* mapping is ported from `examples/openai-sdk-host/index.ts`, but wired
-* against `POST {baseUrl}/chat/completions` instead of the `openai` package.
-*/
-/**
-* Reads a Standard Schema's optional `~standard.jsonSchema.input()` extension
-* (implemented by e.g. Zod v4's `z.toJSONSchema`), awaiting it when it returns
-* a Promise. Returns `undefined` when the schema doesn't expose the extension.
-* Thin re-export of core's {@link getJsonSchema}.
-*/
-const extractJsonSchema = getJsonSchema;
+import { L as isStandardSchema, N as getJsonSchema, P as getJsonSchemaSync, d as buildEnvelopeSchema, h as getAgentOutputMode } from "./events-JiVPYrct.mjs";
+import { l as renderDecisionAttempts } from "./decision-C3k4ve51.mjs";
+//#region src/openai-compat/mappers.ts
 /** Maps `AgentTextRequest.messages`/`system`/`prompt` to Chat Completions messages. */
 function toOpenAiMessages(request) {
 	if (request.messages) return request.messages.flatMap((message) => {
@@ -112,6 +92,22 @@ function toDecisionMessages(request) {
 function pruneUndefined(record) {
 	return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0));
 }
+//#endregion
+//#region src/openai-compat/index.ts
+/**
+* OpenAI-compatible Chat Completions adapter — a COMPLETE `{ generateText,
+* streamText, decide }` executor set built on raw `fetch`, with zero runtime
+* dependencies (no `openai` package, no Vercel AI SDK).
+*
+* The OpenAI Chat Completions wire format is the lingua franca of hosted and
+* local inference: Groq, Together, Fireworks, OpenRouter, vLLM, Ollama, LM
+* Studio, and OpenAI itself all speak it. Point `baseUrl` at any of them.
+*
+* Compare `createAiSdkExecutors` in `../ai-sdk/index.ts` (the AI-SDK-backed
+* adapter) — same three-function contract, different transport. The request
+* mapping is ported from `examples/openai-sdk-host/index.ts`, but wired
+* against `POST {baseUrl}/chat/completions` instead of the `openai` package.
+*/
 /**
 * Builds a complete `{ generateText, streamText, decide }` executor set over
 * the OpenAI Chat Completions wire format via raw `fetch`.
@@ -309,4 +305,4 @@ function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 //#endregion
-export { createOpenAiCompatExecutors, extractJsonSchema, toDecisionMessages, toOpenAiCallSettings, toOpenAiEventTools, toOpenAiMessages, toOpenAiTools };
+export { createOpenAiCompatExecutors };

package/dist/steps-BALp1eZo.d.mts

@@ -0,0 +1,198 @@
+import { m as ChosenEvent, u as AgentTools } from "./types-qm00QF91.mjs";
+import { G as AgentRequestOptions, K as AgentRequestSource, M as AgentPlanInput, U as AgentEventDescriptor, c as AgentRequestMode, j as AgentDecisionRequest, l as AgentTextRequest, s as AgentRequestExecutors } from "./text-logic-CaKqgX4Y.mjs";
+import { AnyActorLogic, AnyMachineSnapshot, AnyStateMachine, AsyncActorLogic, EventFromLogic, SnapshotFrom } from "xstate";
+
+//#region src/internal/registry.d.ts
+type AgentExecutionOptions = Pick<AgentRequestOptions, "schemas" | "actorSources"> & {
+  models?: object;
+};
+//#endregion
+//#region src/steps.d.ts
+/**
+ * A pending text request surfaced by step discovery ({@link getAgentRequests}
+ * / {@link AgentStep.requests}): the machine has spawned a
+ * `TextLogic`-backed invoke and is waiting on its result. Resolve it with
+ * {@link executeAgentRequest} (or by hand, then feed the output into
+ * {@link resolveAgentStep} via `xstate.done.actor.<id>`).
+ */
+interface AgentRequest<TInput extends AgentTextRequest = AgentTextRequest> {
+  kind: "text";
+  id: string;
+  src: AgentRequestSource;
+  mode?: AgentRequestMode;
+  input: TInput;
+  tools: AgentTools;
+  events: AgentEventDescriptor[];
+}
+/**
+ * A pending **plan** request re-surfaced by step discovery: the machine
+ * invoked `agent.plan`, which applies an ordered sequence of legal events
+ * (each one a decision) rather than a single one. Unlike text/decision
+ * requests — surfaced once and resolved once — a plan request **re-surfaces on
+ * every step** while the plan is in flight, its `events`/`applied`/
+ * `stepsRemaining` updated each time, until it terminates.
+ *
+ * All fields are plain serializable data. Resolve ONE decision per step from
+ * `events` (via {@link resolveDecision}, wiring `canTake` to
+ * `snapshot.can` exactly like a single decision) then apply it: a real machine
+ * event advances the plan (the next step re-surfaces this request); the
+ * reserved `agent.plan.done` move, a `stopOn` event, an exhausted budget, or no
+ * legal events completes it (its invoke resolves with `{ steps, stopped }`).
+ * {@link resolveAgentRequests} does all of this natively — one decision (or one
+ * completion) per call.
+ *
+ * The in-progress plan state (`applied` trail + remaining budget) lives in the
+ * plan invoke child's own `createLogic` snapshot `context`
+ * (`children.<id>.snapshot.context`), so it survives a full JSON
+ * `getPersistedSnapshot` → restore round-trip: a host that persists the step
+ * after every event and reloads resumes the plan identically.
+ */
+interface AgentPlanRequest {
+  kind: "plan";
+  /** Durable invoke id of the `agent.plan` invoke. */
+  id: string;
+  /** Invoke src (`'agent.plan'` or a registered plan-logic source name). */
+  src: AgentRequestSource;
+  /** The resolved plan input (`model`/`system`/`prompt`/`allowedEvents`/`stopOn`/`maxSteps`/…). */
+  input: AgentPlanInput;
+  /**
+   * The legal candidates for the NEXT plan step: the currently
+   * snapshot-legal machine events (∩ declared `allowedEvents`) plus the
+   * reserved `agent.plan.done` move.
+   */
+  events: AgentEventDescriptor[];
+  /** The events applied so far in this plan, in order (the trail). */
+  applied: ChosenEvent[];
+  /** How many more events the plan may apply (`maxSteps - applied.length`). */
+  stepsRemaining: number;
+}
+/** `AgentStep.requests` element: a text, decision, or plan request. */
+type AgentStepRequest = AgentRequest | AgentDecisionRequest | AgentPlanRequest;
+/**
+ * One durable checkpoint on the step path: the machine's current snapshot,
+ * the executable actions that produced it, the pending
+ * {@link AgentStepRequest}s (text/decision work still to resolve), and
+ * whether the machine has reached a final state. This is the
+ * per-model-call-checkpoint path for durable hosts (Workflows, Temporal,
+ * queues, …) — a peer of `runAgent`, not a lesser version of it. Produced by
+ * {@link initialAgentStep}/{@link transitionAgentStep}/{@link resolveAgentStep}.
+ */
+interface AgentStep<TSnapshot extends AnyMachineSnapshot = AnyMachineSnapshot> {
+  snapshot: TSnapshot;
+  actions: readonly {
+    type?: string;
+    params?: unknown;
+  }[];
+  requests: AgentStepRequest[];
+  done: boolean;
+}
+/**
+ * Starts a machine and returns its first {@link AgentStep} — the step-path
+ * equivalent of `initialTransition` plus request discovery. Begins the
+ * durable/per-model-call-checkpoint loop: resolve each `step.requests` entry
+ * (via {@link executeAgentRequest} for `kind: 'text'`, or
+ * {@link resolveDecision} for `kind: 'decision'`), then advance with
+ * {@link resolveAgentStep} or {@link transitionAgentStep}.
+ */
+declare function initialAgentStep<TMachine extends AnyActorLogic>(machine: TMachine, input?: unknown, options?: Partial<AgentExecutionOptions>): AgentStep<SnapshotFrom<TMachine>>;
+/**
+ * Applies an externally-sent event (e.g. a decision's chosen event, or a
+ * human's reply) and returns the next {@link AgentStep}. Accepts **either**
+ * a raw snapshot **or** a prior `AgentStep` as the second argument —
+ * `.snapshot` is unwrapped automatically, so callers can thread the whole
+ * step object through without manually plucking the snapshot out.
+ */
+declare function transitionAgentStep<TMachine extends AnyActorLogic>(machine: TMachine, snapshotOrStep: SnapshotFrom<TMachine> | AgentStep<SnapshotFrom<TMachine>>, event: EventFromLogic<TMachine>, options?: Partial<AgentExecutionOptions>): AgentStep<SnapshotFrom<TMachine>>;
+/**
+ * Applies a resolved text request's output (a `kind: 'text'`
+ * {@link AgentRequest} — not a decision) as a done event and returns the
+ * next {@link AgentStep}. For decisions, resolve with `resolveDecision`
+ * (which returns a {@link ChosenEvent}) and apply it with
+ * {@link transitionAgentStep} instead — a decision has no output value of
+ * its own to feed here.
+ */
+declare function resolveAgentStep<TMachine extends AnyActorLogic>(machine: TMachine, step: AgentStep<SnapshotFrom<TMachine>>, request: Pick<AgentRequest, "id"> | string, output: unknown, options?: Partial<AgentExecutionOptions>): AgentStep<SnapshotFrom<TMachine>>;
+/**
+ * Snapshot in, requests out: scans executable actions for spawned agent
+ * invokes and lowers each into an {@link AgentStepRequest}, pre-filled with
+ * the machine's registered `setupAgent` schemas/actorSources (so callers
+ * don't pass them by hand each call) — merged with any `options` passed here,
+ * which take precedence. The step path's public discovery primitive;
+ * `initialAgentStep`/`transitionAgentStep`/`resolveAgentStep` call it
+ * internally to populate `AgentStep.requests`.
+ */
+declare function getAgentRequests(machine: AnyActorLogic, actions: readonly {
+  type?: string;
+  params?: unknown;
+}[], snapshot?: AnyMachineSnapshot, options?: Pick<AgentRequestOptions, "eventToolName"> & Partial<AgentExecutionOptions>): AgentStepRequest[];
+/**
+ * Resolves one **text** {@link AgentRequest} against a host's
+ * {@link AgentRequestExecutors} — merges the request's tools, dispatches to
+ * `generateText`/`streamText` per `request.mode`, and validates the result
+ * against `request.input.outputSchema` if present. **Text-only**: passing a
+ * `kind: 'decision'` request throws, directing the caller to
+ * `resolveDecision(request, executors.decide, ...)` instead. By default
+ * returns the normalized output; pass `{ verbose: true }` to also get the
+ * raw executor result (tool calls, usage, finish reason — needed for
+ * observability and event-sourced replay).
+ */
+declare function executeAgentRequest(request: AgentRequest, executors: Partial<AgentRequestExecutors>): Promise<unknown>;
+declare function executeAgentRequest(request: AgentRequest, executors: Partial<AgentRequestExecutors>, options: {
+  verbose: true;
+}): Promise<{
+  output: unknown;
+  raw: unknown;
+}>;
+/**
+ * Options for {@link resolveAgentRequests}.
+ */
+interface ResolveAgentRequestsOptions extends Partial<AgentExecutionOptions> {
+  /** Retries per decision, passed to `resolveDecision`. Default `2`. */
+  maxRetries?: number;
+}
+/**
+ * Resolves the current step's pending requests and returns the next
+ * {@link AgentStep} — one iteration of the durable step loop, collapsing the
+ * manual `request.kind` dispatch a host would otherwise write by hand.
+ *
+ * For each pending request, in order: a `kind: 'text'` request is run with
+ * {@link executeAgentRequest} then fed back via {@link resolveAgentStep}; a
+ * `kind: 'decision'` request is resolved with `resolveDecision` (wiring
+ * `canTake` to `step.snapshot.can` so guard-rejected choices retry) then
+ * applied with {@link transitionAgentStep}. The **current** step is re-read
+ * after each application — the machine may advance and its `requests` change —
+ * so this always resolves against the live step, never a stale list.
+ *
+ * A `kind: 'plan'` request (`agent.plan`) is resolved natively too: one plan
+ * step per call. It resolves a single decision from `request.events` (wiring
+ * `canTake` to `step.snapshot.can`, exempting the reserved `agent.plan.done`
+ * move and `stopOn` events), then either applies the chosen machine event and
+ * lets the next step re-surface the plan, or completes the plan (feeding its
+ * `{ steps, stopped }` output back) on the done move / a `stopOn` event / an
+ * exhausted budget / no legal events. The plan's applied trail is carried in
+ * the invoke child's snapshot, so persisting the step between calls resumes the
+ * plan identically.
+ *
+ * Missing the executor a request needs throws a clear error
+ * (`generateText`/`streamText` for text, `decide` for decisions and plans).
+ *
+ * A complete durable host is two lines:
+ *
+ * ```ts
+ * let step = initialAgentStep(machine, input);
+ * while (!step.done) step = await resolveAgentRequests(machine, step, executors);
+ * ```
+ *
+ * All pending **text** requests of a step are resolved in parallel
+ * (`Promise.all`) — parallel statechart regions are genuinely concurrent, so
+ * their model calls run concurrently — then their outputs apply in
+ * **request-array order** (deterministic for durable replay regardless of which
+ * call finishes first). Decisions and plans stay **one at a time**: applying
+ * either changes the set of legal candidates for what follows, so they cannot be
+ * resolved against a stale snapshot. A host that instead wants strictly
+ * sequential text resolution loops the manual per-request helpers
+ * ({@link executeAgentRequest} + {@link resolveAgentStep}) one at a time.
+ */
+declare function resolveAgentRequests<TMachine extends AnyActorLogic>(machine: TMachine, step: AgentStep<SnapshotFrom<TMachine>>, executors: Partial<AgentRequestExecutors>, options?: ResolveAgentRequestsOptions): Promise<AgentStep<SnapshotFrom<TMachine>>>;
+//#endregion
+export { ResolveAgentRequestsOptions as a, initialAgentStep as c, transitionAgentStep as d, AgentStepRequest as i, resolveAgentRequests as l, AgentRequest as n, executeAgentRequest as o, AgentStep as r, getAgentRequests as s, AgentPlanRequest as t, resolveAgentStep as u };