@statelyai/agent 2.0.0-alpha.24 → 2.0.0-alpha.26

package/dist/{run-agent-Ck7Sa3Tb.d.mts → run-agent-BOfoJg5B.d.cts}

@@ -1,5 +1,6 @@
-import { _ as StandardSchemaV1, m as InferInput, s as AgentTools, w as WithAgentInputSchema } from "./types-DWA6X9R-.mjs";
-import { F as AgentDecisionRequest, K as AgentEventDescriptor, X as AgentRequestSource, d as AgentRequestMode, f as AgentTextRequest, m as AgentUserInput, p as AgentUsage, r as AgentFinishReason, t as AgentCallUsage, tt as AgentError, u as AgentRequestExecutors } from "./text-logic-DJBK3LbG.mjs";
+import { _ as StandardSchemaV1, m as InferInput, s as AgentTools, w as WithAgentInputSchema } from "./types-B1Qs2q3q.cjs";
+import { G as AgentRequestOptions, K as AgentRequestSource, M as AgentDecisionRequest, U as AgentEventDescriptor, Z as AgentError, d as AgentRequestMode, f as AgentTextRequest, m as AgentUsage, p as AgentTextResult, r as AgentFinishReason, t as AgentCallUsage, u as AgentRequestExecutors } from "./text-logic-BFEOxyxv.cjs";
+import { c as AgentLogEntry, n as AgentEventLogStore } from "./event-log-store-DvOcs10J.cjs";
 import { AnyActorLogic, AnyActorRef, AnyMachineSnapshot, AnyStateMachine, AsyncActorLogic, EmittedFrom, EventFromLogic, EventObject, InputFrom, InspectionEvent, OutputFrom, Snapshot, SnapshotFrom } from "xstate";
 
 //#region src/usage.d.ts
@@ -16,6 +17,11 @@ interface AgentUsageEvent extends EventObject {
   name?: string;
 }
 //#endregion
+//#region src/internal/registry.d.ts
+type AgentExecutionOptions = Pick<AgentRequestOptions, "schemas" | "actors"> & {
+  models?: object;
+};
+//#endregion
 //#region src/steps.d.ts
 /**
  * A pending text request surfaced by step discovery ({@link getAgentRequests}
@@ -36,362 +42,80 @@ interface AgentRequest<TInput extends AgentTextRequest = AgentTextRequest> {
 /** `AgentStep.requests` element: a text or decision request. */
 type AgentStepRequest = AgentRequest | AgentDecisionRequest;
 /**
- * Resolves one **text** request against a host's {@link AgentRequestExecutors}
- * — merges the request's tools, dispatches to `generateText`/`streamText` per
- * `mode`, and validates the result against the request's `outputSchema` if
- * present. Accepts either a `kind: 'text'` `AgentEffect` (the step-path shape
- * from a custom XState host) or an {@link AgentRequest} envelope.
- * **Text-only**: passing a `kind: 'decision'` request throws, directing the
- * caller to `resolveDecision(request, executors, ...)` instead. Always
- * returns both the normalized `output` and the `raw` executor result (tool
- * calls, usage, finish reason — needed for observability and event-sourced
- * replay).
- */
-/** A `kind: 'text'` `AgentEffect` (structural, to avoid an import cycle with effects.ts). */
-interface TextEffectLike {
-  kind: "text";
-  requestId: string;
-  request: AgentTextRequest;
-  mode?: AgentRequestMode;
-}
-declare function executeAgentRequest(requestOrEffect: AgentRequest | TextEffectLike, executors: Partial<AgentRequestExecutors>): Promise<{
-  output: unknown;
-  raw: unknown;
-}>;
-//#endregion
-//#region src/event-log.d.ts
-/** The durable entry envelope version. */
-declare const AGENT_EVENT_SCHEMA_VERSION: 1;
-/**
- * The reserved event type of the first entry of every log. It carries the
- * machine `input` (fresh start) or a persisted `snapshot` (continuation), so a
- * log replays with no side channel. Lives in the reserved `@agent.*` namespace
- * so it can never collide with a machine's own vocabulary; it is consumed by
- * {@link replay} and never fed to `transition`.
- */
-declare const AGENT_INIT_EVENT_TYPE: "@agent.init";
-/** Values that round-trip through JSON without adapters or silent coercion. */
-type JsonValue$1 = null | boolean | number | string | JsonValue$1[] | {
-  [key: string]: JsonValue$1;
-};
-/** A persisted (JSON-safe) machine snapshot, as `machine.getPersistedSnapshot()` returns. */
-type AgentPersistedSnapshot = Snapshot<unknown>;
-/** Recorded projection hash used by {@link replay} verification. */
-interface AgentLogVerification {
-  /** {@link getSnapshotStateHash} of the persisted snapshot after this entry is applied. */
-  stateHash: string;
-}
-/**
- * One journaled external input, JSON-safe and stored verbatim.
- */
-interface AgentLogEntry {
-  /** Version of this outer envelope, independent of the machine event type. */
-  schemaVersion: typeof AGENT_EVENT_SCHEMA_VERSION;
-  /** Stable identity within the log. Forked prefixes retain their ids. */
-  id: string;
-  /** 0-based position in the log. */
-  index: number;
-  /** RFC 3339 wall-clock time when the host accepted the entry. Metadata only. */
-  recordedAt: string;
-  /** The authored XState machine id. */
-  machineId: string;
-  /** Explicit version or structural hash of the machine that accepted the event. */
-  machineVersion: string;
-  event: EventObject;
-  /** Optional causal parent entry id, scoped to the same log. */
-  causationId?: string;
-  /** Host-owned, JSON-safe; stored verbatim, never interpreted. */
-  metadata?: Record<string, JsonValue$1>;
-  /** Recorded projection hash used by replay verification. */
-  verification?: AgentLogVerification;
-}
-/** The payload of the reserved {@link AGENT_INIT_EVENT_TYPE} first entry. */
-interface AgentInitEvent extends EventObject {
-  type: typeof AGENT_INIT_EVENT_TYPE;
-  /** Machine input for a fresh start. Mutually exclusive with `snapshot`. */
-  input?: unknown;
-  /** Persisted snapshot to continue from. Mutually exclusive with `input`. */
-  snapshot?: AgentPersistedSnapshot;
-}
-/** A malformed or internally inconsistent log. */
-declare class AgentEventLogError extends AgentError {
-  constructor(message: string);
+ * One 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. Produced by
+ * {@link initialAgentStep}, {@link transitionAgentStep},
+ * {@link resolveAgentStep}, and {@link rejectAgentStep}.
+ */
+interface AgentStep<TSnapshot extends AnyMachineSnapshot = AnyMachineSnapshot> {
+  snapshot: TSnapshot;
+  actions: readonly {
+    type?: string;
+    params?: unknown;
+  }[];
+  requests: AgentStepRequest[];
+  done: boolean;
 }
-/** A precise failure when an entry would not survive a JSON round-trip. */
-declare class NonSerializableAgentEventError extends AgentError {
-  readonly path: string;
-  readonly valueType: string;
-  constructor(path: string, valueType: string);
-}
-/** Replay reached a state that does not match the entry's recorded hash. */
-declare class AgentReplayDivergenceError extends AgentError {
-  readonly eventId: string;
-  readonly index: number;
-  readonly kind: "state" | "missing-verification";
-  readonly expected?: string | undefined;
-  readonly actual?: string | undefined;
-  constructor(eventId: string, index: number, kind: "state" | "missing-verification", expected?: string | undefined, actual?: string | undefined);
-}
-/**
- * An entry was recorded against a different machine (id) or a different
- * machine version than the one replaying it. An init-with-snapshot entry is
- * exempt: that entry IS the bridge from the old version to the new one.
- */
-declare class AgentMachineVersionMismatchError extends AgentError {
-  readonly eventId: string;
-  readonly index: number;
-  readonly expected: {
-    machineId: string;
-    machineVersion: string;
-  };
-  readonly actual: {
-    machineId: string;
-    machineVersion: string;
-  };
-  constructor(eventId: string, index: number, expected: {
-    machineId: string;
-    machineVersion: string;
-  }, actual: {
-    machineId: string;
-    machineVersion: string;
-  });
-}
-/**
- * Rejects values JSON would drop or coerce. Unlike `JSON.stringify`, this does
- * not silently erase `undefined`/functions or turn non-finite numbers into
- * `null`; durable entries contain only plain JSON values.
- */
-declare function assertJsonSerializable(value: unknown, path?: string, ancestors?: WeakSet<object>): asserts value is JsonValue$1;
-/** Validates the complete durable envelope before append/export/replay. */
-declare function assertAgentLogEntry(entry: unknown): asserts entry is AgentLogEntry;
-/**
- * The canonical hash of a PERSISTED snapshot (`machine.getPersistedSnapshot()`,
- * or {@link replay}'s `persistedSnapshot`) — the value recorded in an entry's
- * `verification.stateHash`.
- *
- * Stripped before hashing, because they are re-minted on every fold and would
- * otherwise make two identical runs hash differently: `sessionId`,
- * `_nextTimerId` and `_nextActorIds` at the snapshot root, `sessionId` on each
- * `children[*]` entry (recursively, through nested child snapshots), and
- * `undefined`-valued properties (so a snapshot hashes the same before and
- * after a JSON round-trip). Stripping is confined to those structural
- * positions: a `sessionId` inside `context`, `output`, `error` or an event
- * payload is application data and is hashed. Object keys are sorted, so key
- * order is irrelevant.
- *
- * A change detector, not a cryptographic digest.
- */
-declare function getSnapshotStateHash(snapshot: AgentPersistedSnapshot | unknown): string;
-/** Options controlling the durable envelope created by {@link createReplayEntry}. */
-interface CreateReplayEntryOptions {
-  /** Explicit machine version; defaults to the machine's resolved version. */
-  machineVersion?: string;
-  /** Stable entry id; defaults to `evt_` plus the zero-padded index. */
-  id?: string;
-  /** RFC 3339 acceptance time; defaults to the current wall clock. */
-  recordedAt?: string;
-  causationId?: string;
-  metadata?: Record<string, JsonValue$1>;
-  /** Record `verification.stateHash` (default `true`). */
-  verification?: boolean;
-  /**
-   * The snapshot this entry folds to, when the caller already has it — avoids
-   * re-folding the whole prefix just to compute the hash. Accepts a live or a
-   * persisted snapshot.
-   */
-  snapshot?: AnyMachineSnapshot | AgentPersistedSnapshot;
-}
-/**
- * Creates a JSON-safe, self-describing entry for `event` appended after
- * `entries` (which must be the complete prefix, so `index` and the recorded
- * state hash line up).
- */
-declare function createReplayEntry(machine: AnyStateMachine, entries: readonly AgentLogEntry[], event: EventObject, options?: CreateReplayEntryOptions): AgentLogEntry;
-/** How a log begins: from machine input, or from a persisted snapshot. */
-type AgentLogInit = {
-  input?: unknown;
-  snapshot?: never;
-} | {
-  snapshot: AgentPersistedSnapshot;
-  input?: never;
-};
-/**
- * The reserved first entry of a log. Pass EXACTLY one of:
- *
- * - `{ input }` — a fresh start; replay folds from `initialTransition`.
- * - `{ snapshot }` — a continuation from a persisted snapshot: a version
- *   bridge, or a legacy snapshot that predates the log. Replay restores it
- *   purely (no actors started) and folds the rest of the log onto it.
- *
- * `options.metadata.executionId` names the lineage; this library always sets
- * one, and readers must tolerate its absence in logs written elsewhere.
- */
-declare function initEntry(machine: AnyStateMachine, init?: AgentLogInit, options?: CreateReplayEntryOptions): AgentLogEntry;
 /**
- * The log's execution id: the lineage identity pinned in the init entry's
- * `metadata.executionId`.
+ * 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>>;
+/**
+ * Rejects a pending invoke — the failure counterpart of
+ * {@link resolveAgentStep}. Delivers `error` as the invoke's
+ * `xstate.error.actor` event, so the machine takes that invoke's `onError`
+ * transition and returns the next {@link AgentStep}. With no `onError` in
+ * scope the returned step's snapshot has `status: 'error'`, exactly as a live
+ * run's failed invoke does.
  *
- * Minted once per run and inherited verbatim by every resume of that log, so
- * it names one lineage rather than one process. Entry ids cannot serve this
- * role — the built-in ids are index-derived, so every log's init entry is
- * `evt_00000000`. A fork copies the init entry, so it shares its parent's
- * execution id by construction.
+ * A durable host replays a failed call with this: the log says the call
+ * failed, so the replay rejects the invoke instead of resolving it. Scripted
+ * playthroughs use it too — see `simulateAgent`'s `script.errors`.
  *
- * Returns `undefined` for a log with no init entry and for one written without
- * the field — callers must treat the id as optional.
- */
-declare function getLogExecutionId(entries: readonly AgentLogEntry[]): string | undefined;
-/**
- * Validates a log before replay or append: every envelope well-formed, indices
- * contiguous from 0, ids unique, the first entry the reserved init entry, and
- * one consistent machine identity throughout.
- *
- * With `machine`, entries are also checked against that machine's id and
- * resolved version — a mismatch throws {@link AgentMachineVersionMismatchError}.
- * An init-with-snapshot entry is exempt from the version check: that entry is
- * itself the bridge from whatever version produced the snapshot.
- */
-declare function validateReplayEntries(entries: readonly AgentLogEntry[], options?: {
-  machine?: AnyStateMachine;
-  machineVersion?: string;
-}): void;
-/**
- * The prefix `[0, upToIndex)` of a log, as a new log. `upToIndex` is exclusive
- * and must leave the init entry in place, so the fork is still self-contained.
- */
-declare function forkEventLog(entries: readonly AgentLogEntry[], upToIndex: number): AgentLogEntry[];
-/**
- * The 1-based occurrence `n` for the NEXT call at invoke site `siteId`:
- * `1 + completions`, where a completion is a journaled `xstate.done.actor` OR
- * `xstate.error.actor` for that `actorId` (an error is a semantic completion).
- * The one counting rule behind every `${siteId}#${n}` call key, so a live run
- * and a replay derive the same `n` by construction.
- */
-declare function agentCallOccurrence(history: readonly (EventObject | AgentLogEntry)[] | undefined, siteId: string): number;
-/**
- * Folds the reserved `@agent.usage` entries of a log into one cumulative usage
- * total. The log is the source of truth, so the totals are a pure projection of
- * it: replay a log, fold it, and you get the numbers the run reported with no
- * host-side accumulator in between.
- *
- * Accepts entries or bare events. Token fields are partial sums: a field stays
- * `undefined` until some entry reports it, and non-finite values are ignored.
- */
-declare function getUsageFromEvents(entries: readonly (EventObject | AgentLogEntry)[]): AgentCallUsage;
-/**
- * Rewrites a journaled `xstate.done.actor`/`xstate.error.actor` event's
- * `sessionId` to the session the CURRENT fold minted for that `actorId`.
- *
- * Session ids are re-minted on every fold, and XState drops a completion event
- * whose `sessionId` does not match the live child — silently, as a no-op
- * transition. Rebinding is what makes a journaled completion replayable at all.
- * `sessions` caches the mapping per fold, so a later event referring to the
- * recorded session of an already-stopped child still resolves.
- */
-declare function rebindActorSession(event: EventObject, snapshot: AnyMachineSnapshot, sessions: Map<string, string>): EventObject;
-/** Options for {@link replay}. */
-interface ReplayOptions {
-  /** Explicit expected machine version; defaults to the machine's resolved version. */
-  machineVersion?: string;
-  /**
-   * `true` (default) checks the entries that carry a `verification.stateHash`;
-   * `'strict'` additionally requires every entry to carry one; `false` skips
-   * verification entirely.
-   */
-  verify?: boolean | "strict";
-}
-/** The result of a {@link replay}. */
-interface ReplayResult<TMachine extends AnyStateMachine> {
-  /** The folded live snapshot (no actors started, no effects run). */
-  snapshot: SnapshotFrom<TMachine>;
-  /** Its persisted projection — what a host stores, and what hashes. */
-  persistedSnapshot: AgentPersistedSnapshot;
-}
-/**
- * Folds a log through XState's pure `initialTransition`/`transition` WITHOUT
- * executing anything: no actor is started, no action runs, no model is called.
- * A journaled `xstate.done.actor` entry carries the completed actor's output
- * inline, so the invoke it belongs to is never re-run. Crash recovery, fork
- * resume, and time travel in one call.
- *
- * The first entry is the reserved {@link initEntry}: `input` folds from
- * `initialTransition`, `snapshot` restores the persisted snapshot purely
- * (`machine.restoreSnapshot`) and folds the rest of the log onto it.
- */
-declare function replay<TMachine extends AnyStateMachine>(machine: TMachine, entries: readonly AgentLogEntry[], options?: ReplayOptions): ReplayResult<TMachine>;
-//#endregion
-//#region src/event-log-store.d.ts
-/**
- * An append-only event log: the authoritative durability artifact of a thread.
- * The journal of external inputs IS the source of truth — deterministic
- * `replay` derives every snapshot from it, and a fork is a copied log prefix.
- *
- * Userland stores (a Postgres table with a `(thread_id, index)` primary key, an
- * append-only object in blob storage, …) implement this one shape so they
- * interoperate; {@link createInMemoryEventLogStore} is the reference, and
- * `assertEventLogStoreConformance` checks an implementation against it.
- */
-interface AgentEventLogStore {
-  /**
-   * Append `entries` starting at `expectedIndex` (the current length of the
-   * thread's log; 0 for a new thread). Atomic — all entries land or none do.
-   * Rejects with {@link AgentEventLogConflictError} when the thread's length
-   * differs from `expectedIndex`: a concurrent writer appended first. Each
-   * entry's `index` must be contiguous from `expectedIndex` (a plain `Error`
-   * otherwise: that is caller misuse, not a race).
-   */
-  append(input: {
-    threadId: string;
-    expectedIndex: number;
-    entries: AgentLogEntry[];
-  }): Promise<void>;
-  /**
-   * Read a thread's entries in log order. `from` (default 0) skips entries
-   * below that index for incremental catch-up. An unknown thread reads as an
-   * empty array.
-   */
-  read(threadId: string, options?: {
-    from?: number;
-  }): Promise<AgentLogEntry[]>;
-  /** The thread's current log length (0 for an unknown thread) — the next `expectedIndex`. */
-  length(threadId: string): Promise<number>;
-  /**
-   * Copy the prefix `[0, upToIndex)` onto a fresh, empty `newThreadId`.
-   * Without `upToIndex` the full source is copied. `upToIndex` is exclusive
-   * and must be an integer in `[1, length]`, so the fork keeps the reserved
-   * init entry and stays a self-contained log. The fork then appends
-   * independently. Rejects (plain `Error`) if `newThreadId` already has
-   * entries, the source is unknown, or `upToIndex` is out of range.
-   * Implementations may copy-on-write or physically copy; observable behavior
-   * must match a full copy.
-   */
-  fork(input: {
-    threadId: string;
-    newThreadId: string; /** Exclusive index cutoff. */
-    upToIndex?: number;
-  }): Promise<void>;
-}
-/**
- * Rejection from {@link AgentEventLogStore.append} when the thread's stored
- * length is not the `expectedIndex` the writer held — a concurrent writer
- * appended first. `actualIndex` is the next index the store would accept.
- */
-declare class AgentEventLogConflictError extends AgentError {
-  readonly threadId: string;
-  readonly expectedIndex: number;
-  readonly actualIndex: number;
-  constructor(threadId: string, expectedIndex: number, actualIndex: number);
-}
-/**
- * In-memory reference store, and the baseline the conformance suite runs
- * against. Per-thread entries are held in a contiguous, index-ordered list;
- * append's check-and-push runs synchronously (no `await` between reading the
- * length and writing), so two appends racing on the same `expectedIndex`
- * resolve to exactly one winner. Every stored and returned entry is
- * `structuredClone`d, so a caller can neither mutate stored state through a
- * value it appended nor through a value it read.
- */
-declare function createInMemoryEventLogStore(): AgentEventLogStore;
+ * `error` can be any value. An `Error` instance is the usual one, but a plain
+ * object (`{ code: 'truncated' }`) reaches the `onError` transition as
+ * `event.error` untouched, so a machine that branches on a failure code is
+ * testable without constructing a provider's error class.
+ */
+declare function rejectAgentStep<TMachine extends AnyActorLogic>(machine: TMachine, step: AgentStep<SnapshotFrom<TMachine>>, request: Pick<AgentRequest, "id"> | string, error: unknown, options?: Partial<AgentExecutionOptions>): AgentStep<SnapshotFrom<TMachine>>;
+/**
+ * Resolves one **text** request ({@link AgentRequest}, from
+ * {@link AgentStep.requests}) against a host's {@link AgentRequestExecutors}
+ * — merges the request's tools, dispatches to `generateText`/`streamText`
+ * per `mode`, and validates the result against the request's
+ * `outputSchema` if present. **Text-only**: passing a `kind: 'decision'`
+ * request throws, directing the caller to `resolveDecision(request,
+ * executors, ...)` instead. Returns the invoke's output — `{ result,
+ * messages }`, ready for {@link resolveAgentStep} — plus the `raw` executor
+ * result (tool calls, usage, finish reason).
+ */
+declare function executeAgentRequest(request: AgentStepRequest, executors: Partial<AgentRequestExecutors>): Promise<AgentTextResult & {
+  raw: unknown;
+}>;
 //#endregion
 //#region src/run-agent.d.ts
 type JsonValue = string | number | boolean | null | JsonValue[] | {
@@ -425,10 +149,6 @@ interface AgentRunMeta {
   /** The log's length at the moment this snapshot was taken. */
   logIndex: number;
 }
-/** Handler for `agent.userInput` invokes passed as {@link RunAgentOptions.userInput}. Resolves to what the human typed. */
-interface AgentUserInputExecutor {
-  (input: AgentUserInput): PromiseLike<string>;
-}
 /** Typed root-machine transition observer accepted by {@link runAgent}. */
 type AgentTransitionHandler<TMachine extends AnyStateMachine> = (snapshot: SnapshotFrom<TMachine>, event: EventFromLogic<TMachine>) => void;
 /**
@@ -460,7 +180,7 @@ type AgentTraceEvent<TMachine extends AnyStateMachine = AnyStateMachine> = {
   output: unknown;
   raw: unknown;
   /** The model's reasoning, lifted off the raw executor result when the
-   * request opted into the structured-output envelope's `reasoning` field.
+   * request opted into the provider output's `reasoning` field.
    * Present only when the executor surfaced a string `reasoning`. */
   reasoning?: string;
   /** This call's token usage, lifted off the raw executor result's `usage`.
@@ -502,7 +222,6 @@ type AgentTraceEvent<TMachine extends AnyStateMachine = AnyStateMachine> = {
   type: "run.end";
   status: "idle";
   snapshot: SnapshotFrom<TMachine>;
-  pendingUserInputs?: PendingUserInput[];
 } | {
   type: "run.end";
   status: "error";
@@ -651,16 +370,6 @@ interface RunAgentOptions<TMachine extends AnyStateMachine> {
   verification?: boolean;
   /** Actor source implementations, merged onto the machine before binding — sugar for `machine.provide({ actors })` ahead of the run. */
   actors?: Record<string, AnyActorLogic>;
-  /**
-   * Optional human-input handler for `agent.userInput` invokes (CLI prompt,
-   * web form, Slack, …). With a handler, input is gathered inline without
-   * settling. Without one, an `agent.userInput` invoke becomes a *pending
-   * placeholder*: it waits indefinitely, does not block idle detection, and
-   * the run settles `{ status: 'idle', pendingUserInputs }` once no other work
-   * is in flight — persist with `result.persist()` and resume that snapshot
-   * with a `userInput` handler that answers it.
-   */
-  userInput?: AgentUserInputExecutor;
   /**
    * Sugar over {@link onTrace}'s `stream.chunk` events: fires for each streamed
    * chunk of a `mode: 'stream'` text request, alongside the {@link AgentRequest}
@@ -677,7 +386,7 @@ interface RunAgentOptions<TMachine extends AnyStateMachine> {
    * event-sourced replay logging.
    */
   onResult?: (request: AgentStepRequest, result: {
-    output: unknown;
+    result: unknown;
     raw: unknown;
   }) => void;
   /** Fires a single ordered stream of run/request/chunk/transition/emit/end events. Intended for eval traces, JSONL logs, and adapter-owned telemetry/exporters. */
@@ -744,19 +453,13 @@ interface RunAgentOptions<TMachine extends AnyStateMachine> {
  * underlying actor is stopped on every settle path — there is no live actor to
  * resume; resume is always by snapshot.
  */
-/** A pending unhandled `agent.userInput` invoke surfaced on an idle settle — `id` is the invoke's id, `input` its resolved invoke input (prompt, metadata). Answer it by resuming with a `userInput` handler. */
-interface PendingUserInput {
-  id: string;
-  input: AgentUserInput | undefined;
-}
 type RunAgentOutcome<TMachine extends AnyStateMachine> = {
   status: "done";
   output: OutputFrom<TMachine>;
   snapshot: SnapshotFrom<TMachine>;
 } | {
   status: "idle";
-  snapshot: SnapshotFrom<TMachine>; /** Present when the machine is waiting on unhandled `agent.userInput` invokes: one entry per pending invoke. */
-  pendingUserInputs?: PendingUserInput[];
+  snapshot: SnapshotFrom<TMachine>;
 } | {
   status: "error";
   cause: RunAgentErrorCause;
@@ -885,9 +588,7 @@ type AgentInputFrom<TMachine extends AnyStateMachine> = [NonNullable<InputFrom<T
  * could reach is walked and checked against the effective actor sources
  * (`options.actors` merged onto the machine), so a missing
  * `streamText`/`decide` executor or any other unbound actor source throws
- * immediately — a bind-time error, not a mid-run failure. The one exception
- * is `agent.userInput`: unhandled, it binds as a pending placeholder that
- * settles the run idle (with `pendingUserInputs`) instead of erroring.
+ * immediately — a bind-time error, not a mid-run failure.
  *
  * @example
  * ```ts
@@ -901,11 +602,9 @@ type AgentInputFrom<TMachine extends AnyStateMachine> = [NonNullable<InputFrom<T
  * console.log(r.output);
  * ```
  *
- * The `executors`' `generateText`/`streamText` accept the raw Vercel AI SDK
- * functions directly (`executors: { generateText, streamText }` with them
- * imported from `ai`) — their `{ text }`/`{ textStream }` results are unwrapped
- * natively. `decide` cannot be a raw AI SDK function: the tool-per-event mapping
- * lives in an adapter — use `createAiSdkExecutors` from '@statelyai/agent/ai-sdk'.
+ * Each executor is a plain function returning `{ result }` (plus optional `messages`/`usage`), or
+ * an adapter's set: `createAiSdkExecutors` from '@statelyai/agent/ai-sdk' or
+ * `createOpenAiExecutors` from '@statelyai/agent/openai' supply all three.
  */
 declare function runAgent<TMachine extends AnyStateMachine>(machine: TMachine, options: RunAgentOptions<TMachine>): Promise<RunAgentResult<TMachine>>;
 /**
@@ -965,4 +664,4 @@ declare function traceTransitions<TMachine extends AnyStateMachine = AnyStateMac
  */
 declare function isAgentIdle(snapshot: AnyMachineSnapshot): boolean;
 //#endregion
-export { AGENT_USAGE_EVENT_TYPE as $, AgentMachineVersionMismatchError as A, assertJsonSerializable as B, AGENT_EVENT_SCHEMA_VERSION as C, AgentLogEntry as D, AgentInitEvent as E, NonSerializableAgentEventError as F, getUsageFromEvents as G, forkEventLog as H, ReplayOptions as I, replay as J, initEntry as K, ReplayResult as L, AgentReplayDivergenceError as M, CreateReplayEntryOptions as N, AgentLogInit as O, JsonValue$1 as P, executeAgentRequest as Q, agentCallOccurrence as R, createInMemoryEventLogStore as S, AgentEventLogError as T, getLogExecutionId as U, createReplayEntry as V, getSnapshotStateHash as W, AgentRequest as X, validateReplayEntries as Y, AgentStepRequest as Z, runAgent as _, AgentSnapshotDivergedError as a, AgentEventLogConflictError as b, AgentUserInputExecutor as c, PendingUserInput as d, AgentUsageEvent as et, RunAgentErrorCause as f, isAgentIdle as g, inspectTransitions as h, AgentRunMeta as i, AgentPersistedSnapshot as j, AgentLogVerification as k, InspectedActorRef as l, RunAgentResult as m, AgentInputFrom as n, AgentTraceEvent as o, RunAgentOptions as p, rebindActorSession as q, AgentMaxModelCallsExceededError as r, AgentTransitionHandler as s, AGENT_TRACE_SCHEMA_VERSION as t, JsonSerializableTraceEvent as u, serializeTraceEvent as v, AGENT_INIT_EVENT_TYPE as w, AgentEventLogStore as x, traceTransitions as y, assertAgentLogEntry as z };
+export { rejectAgentStep as C, AgentUsageEvent as D, AGENT_USAGE_EVENT_TYPE as E, initialAgentStep as S, transitionAgentStep as T, traceTransitions as _, AgentSnapshotDivergedError as a, AgentStepRequest as b, InspectedActorRef as c, RunAgentOptions as d, RunAgentResult as f, serializeTraceEvent as g, runAgent as h, AgentRunMeta as i, JsonSerializableTraceEvent as l, isAgentIdle as m, AgentInputFrom as n, AgentTraceEvent as o, inspectTransitions as p, AgentMaxModelCallsExceededError as r, AgentTransitionHandler as s, AGENT_TRACE_SCHEMA_VERSION as t, RunAgentErrorCause as u, AgentRequest as v, resolveAgentStep as w, executeAgentRequest as x, AgentStep as y };