@statelyai/agent 2.0.0-alpha.21 → 2.0.0-alpha.23

package/dist/index.d.cts

@@ -1,49 +1,104 @@
-import { C as ToolResultPart, S as ToolMessage, T as WithAgentInputSchema, _ as NormalizedEventSchemas, a as AgentToolChoice, b as TextPart, c as AgentTools, d as ChosenEvent, f as EventUnion, g as InferOutput, h as InferInput, i as AgentTool, l as AllowedEvents, m as ImagePart, n as AgentMessage, o as AgentToolDescriptor, p as FilePart, r as AgentSnapshotStore, s as AgentToolExecute, t as AgentEventSchemaInputMap, u as AssistantMessage, v as StandardSchemaV1, w as UserMessage, x as ToolCallPart, y as SystemMessage } from "./types-DSdj2tGs.cjs";
-import { t as AgentError } from "./errors-BQRk9eiZ.cjs";
-import { A as AgentDecisionExecutor, B as AgentEventToolNameResolver, C as buildEnvelopeSchema, D as parseModelRef, E as getCallUsage, F as DecisionLogicConfig, G as parseAgentEvent, H as AgentRequestSource, I as ResolveDecisionOptions, L as renderDecisionAttempts, M as AgentDecisionInput, N as AgentDecisionRequest, O as parseOutput, P as DecisionAttempt, R as resolveDecision, S as bindRequestExecutor, T as getAgentOutputMode, U as AgentSchemas, V as AgentRequestOptions, W as getAcceptedEvents, _ as StructuredOutputEnvelope, a as AgentOutputMode, b as TextLogicExecuteArgs, c as AgentRequestExecutorResult, d as AgentTextRequest, f as AgentUsage, g as BuiltinAgentActors, h as AiSdkShapedTextResult, i as AgentModelRef, j as AgentDecisionExhaustedError, k as parseStructuredEnvelope, l as AgentRequestExecutors, m as AiSdkShapedStreamResult, n as AgentExecutorTextRequest, o as AgentRequestExecutor, p as AgentUserInput, r as AgentModelMap, s as AgentRequestExecutorInfo, t as AgentCallUsage, u as AgentRequestMode, v as TextLogic, w as createTextLogic, x as TextLogicExecutor, y as TextLogicConfig, z as AgentEventDescriptor } from "./text-logic-Mmbgb2jy.cjs";
-import { a as AgentLogVerification, c as assertAgentLogEntry, d as assertEventLogStoreConformance, i as AgentLogEntry, l as assertJsonSerializable, n as AgentEventLogConflictError, o as JsonValue, r as AgentEventLogStore, s as NonSerializableAgentEventError, t as AGENT_EVENT_SCHEMA_VERSION, u as createInMemoryEventLogStore } from "./event-log-store-Bz7HDBkE.cjs";
-import { A as AgentRequest, B as AgentReplayMachineMismatchError, C as getSnapshotNodes, D as serializeTraceEvent, E as runAgent, F as AgentEffect, G as ReplayResult, H as CreateReplayEntryOptions, I as AgentEffectDiff, J as getAgentEffects, K as createReplayEntry, L as AgentEventLogDiff, M as executeAgentRequest, N as AGENT_INIT_EVENT_TYPE, O as traceTransitions, P as AGENT_USAGE_EVENT_TYPE, R as AgentLogPatchOperation, S as generateResult, T as inspectTransitions, U as GetAgentEffectsOptions, V as AgentUsageEvent, W as ReplayOptions, X as replay, Y as initEntry, _ as PendingUserInput, a as AgentInputFrom, b as RunAgentResult, c as AgentRunMeta, d as AgentTraceEvent, f as AgentUserInputExecutor, g as JsonSerializableTraceEvent, h as InspectedActorRef, i as AgentIllegalResumeEventError, j as AgentStepRequest, k as AgentStateRequest, l as AgentSnapshotNode, m as GetSnapshotRequestsOptions, n as AgentActorSession, o as AgentMaxModelCallsExceededError, p as GenerateResult, q as diffEventLogs, r as AgentIdleError, s as AgentMessageInfo, t as AGENT_TRACE_SCHEMA_VERSION, u as AgentSnapshotVersionMismatchError, v as RunAgentErrorCause, w as getSnapshotRequests, x as createAgentActor, y as RunAgentOptions, z as AgentReplayDivergenceError } from "./run-agent-Do094mGu.cjs";
-import { AnyActorLogic, AnyMachineSnapshot, AnySetupConfig, AnyStateMachine, AsyncActorLogic, EventFromLogic, EventObject, InputFrom, MachineContext, MetaObject, NonReducibleUnknown, OutputFrom, SetupReturnFromConfig, SetupStateSchema, SnapshotFrom, StateValue } from "xstate";
+import { C as UserMessage, S as ToolResultPart, _ as StandardSchemaV1, a as AgentToolDescriptor, b as ToolCallPart, c as AllowedEvents, d as EventUnion, f as FilePart, g as NormalizedEventSchemas, h as InferOutput, i as AgentToolChoice, l as AssistantMessage, m as InferInput, n as AgentMessage, o as AgentToolExecute, p as ImagePart, r as AgentTool, s as AgentTools, t as AgentEventSchemaInputMap, u as ChosenEvent, v as SystemMessage, w as WithAgentInputSchema, x as ToolMessage, y as TextPart } from "./types-CjHk5OdH.cjs";
+import { $ as getAcceptedEvents, A as parseOutput, B as DecisionLogicConfig, C as bindRequestExecutor, D as getCallFinishReason, E as getAgentOutputMode, F as AgentDecisionRequest, G as resolveDecision, H as createDecisionLogic, I as AgentExecutorDecisionRequest, J as AgentInvalidEventPayloadError, K as AgentEventDescriptor, L as CreateDecisionRequestOptions, M as AgentDecisionExecutor, N as AgentDecisionExhaustedError, O as getCallUsage, P as AgentDecisionInput, Q as EventFromSnapshot, R as DecisionAttempt, S as TextLogicExecutor, T as createTextLogic, U as createDecisionRequest, V as ResolveDecisionOptions, W as renderDecisionAttempts, X as AgentRequestSource, Y as AgentRequestOptions, Z as AgentSchemas, _ as BuiltinAgentActors, a as AgentModelRef, b as TextLogicConfig, c as AgentRequestExecutorInfo, d as AgentRequestMode, et as parseAgentEvent, f as AgentTextRequest, g as AiSdkShapedTextResult, h as AiSdkShapedStreamResult, i as AgentModelMap, j as parseStructuredEnvelope, k as parseModelRef, l as AgentRequestExecutorResult, m as AgentUserInput, n as AgentExecutorTextRequest, nt as AgentTruncatedError, o as AgentOutputMode, p as AgentUsage, q as AgentEventToolNameResolver, r as AgentFinishReason, s as AgentRequestExecutor, t as AgentCallUsage, tt as AgentError, u as AgentRequestExecutors, v as StructuredOutputEnvelope, w as buildEnvelopeSchema, x as TextLogicExecuteArgs, y as TextLogic, z as DecisionLogic } from "./text-logic-C7bSnH_B.cjs";
+import { $ as AGENT_USAGE_EVENT_TYPE, A as AgentMachineVersionMismatchError, B as assertJsonSerializable, C as AGENT_EVENT_SCHEMA_VERSION, D as AgentLogEntry, E as AgentInitEvent, F as NonSerializableAgentEventError, G as getUsageFromEvents, H as forkEventLog, I as ReplayOptions, J as replay, K as initEntry, L as ReplayResult, M as AgentReplayDivergenceError, N as CreateReplayEntryOptions, O as AgentLogInit, P as JsonValue, Q as executeAgentRequest, R as agentCallOccurrence, S as createInMemoryEventLogStore, T as AgentEventLogError, U as getLogExecutionId, V as createReplayEntry, W as getSnapshotStateHash, X as AgentRequest, Y as validateReplayEntries, Z as AgentStepRequest, _ as runAgent, a as AgentSnapshotDivergedError, b as AgentEventLogConflictError, c as AgentUserInputExecutor, d as PendingUserInput, et as AgentUsageEvent, f as RunAgentErrorCause, g as isAgentIdle, h as inspectTransitions, i as AgentRunMeta, j as AgentPersistedSnapshot, k as AgentLogVerification, l as InspectedActorRef, m as RunAgentResult, n as AgentInputFrom, o as AgentTraceEvent, p as RunAgentOptions, q as rebindActorSession, r as AgentMaxModelCallsExceededError, s as AgentTransitionHandler, t as AGENT_TRACE_SCHEMA_VERSION, u as JsonSerializableTraceEvent, v as serializeTraceEvent, w as AGENT_INIT_EVENT_TYPE, x as AgentEventLogStore, y as traceTransitions, z as assertAgentLogEntry } from "./run-agent-DWqA8KiI.cjs";
+import { AnyActorLogic, AnyMachineSnapshot, AnySetupConfig, AnyStateMachine, AsyncActorLogic, ContextFrom, DoneActorEvent, EmittedFrom, EventFromLogic, EventObject, InputFrom, MachineContext, MetaObject, NonReducibleUnknown, OutputFrom, SetupReturnFromConfig, SetupStateSchema, SnapshotFrom, StateValue, StateValueFrom } from "xstate";
 
+//#region src/type-helpers.d.ts
+type SchemaAt<T, TKey extends PropertyKey> = T extends {
+  schemas: Record<TKey, infer TSchema extends StandardSchemaV1>;
+} ? TSchema : never;
+/** Machine context, or a setup's context-schema output. */
+type ContextOf<T> = T extends AnyStateMachine ? ContextFrom<T> : InferOutput<SchemaAt<T, "context">>;
+/** Machine input, or a setup's context-schema input. */
+type InputOf<T> = T extends AnyStateMachine ? InputFrom<T> : InferInput<SchemaAt<T, "input">>;
+/** Machine output, or a setup's output-schema output. */
+type OutputOf<T> = T extends AnyStateMachine ? OutputFrom<T> : InferOutput<SchemaAt<T, "output">>;
+/** Machine event union, or the event union declared by a setup. */
+type EventOf<T> = T extends AnyStateMachine ? EventFromLogic<T> : T extends {
+  schemas: {
+    events: infer TEvents extends Record<string, StandardSchemaV1>;
+  };
+} ? EventUnion<TEvents> : never;
+/** Typed live XState snapshot for a machine. */
+type SnapshotOf<TMachine extends AnyStateMachine> = SnapshotFrom<TMachine>;
+/** Literal state-value union accepted by a machine snapshot's `matches`. */
+type StateValueOf<TMachine extends AnyStateMachine> = StateValueFrom<TMachine>;
+/** State/transition metadata declared by a setup or carried by a machine snapshot. */
+type MetaOf<T> = T extends {
+  schemas: {
+    meta: infer TSchema extends StandardSchemaV1;
+  };
+} ? InferOutput<TSchema> : T extends AnyStateMachine ? ReturnType<SnapshotFrom<T>["getMeta"]> extends Record<string, infer TMeta> ? TMeta : never : never;
+/** Semantic request names registered on a `setupAgent(...)` result. */
+type RequestNamesOf<T> = T extends {
+  requests: infer TRequests;
+} ? keyof TRequests & string : never;
+/**
+ * XState's canonical `xstate.done.actor` event, typed with a specific actor
+ * logic's output (and optionally its id). Use it to type a wildcard
+ * `'xstate.done.actor'` handler that reduces dynamically spawned children,
+ * where the machine's own event union cannot name them.
+ *
+ * @example
+ * ```ts
+ * 'xstate.done.actor': ({ context, event }) => {
+ *   const { actorId, output } = event as DoneActorEventOf<typeof researchLogic>;
+ * }
+ * ```
+ */
+type DoneActorEventOf<TLogic extends AnyActorLogic, TId extends string = string> = DoneActorEvent<OutputFrom<TLogic>, TId>;
+//#endregion
 //#region src/messages.d.ts
+/** Ordinary machine event emitted after a request returns framework-native messages. */
+declare const AGENT_MESSAGES_EVENT_TYPE: "agent.messages";
+interface AgentMessagesEvent<TMessage = unknown> extends EventObject {
+  type: typeof AGENT_MESSAGES_EVENT_TYPE;
+  /** Semantic request identity. */
+  request: string;
+  /** Invoke occurrence identity. */
+  actorId: string;
+  /** Messages exactly as returned by the executor/framework. */
+  messages: TMessage[];
+}
+type AgentMessagesEventPayload = Omit<AgentMessagesEvent, "type">;
 /**
- * Builds a transition-function result that appends one or more
- * {@link AgentMessage}s to a context's `messages` array. `resolve` is either
- * a message (or array of messages) or a function of `{ context, event }`
- * returning them; the returned function is meant to be used directly as (or
- * composed into) a transition's result, e.g. `on: { USER_REPLIED:
- * agent.appendMessages(({ event }) => userMessage(event.text)) }`. Requires
- * `messages: AgentMessage[]` on context — see {@link messagesSchema} for a
- * ready-made schema for that field.
+ * Appends framework-native messages from `agent.messages` to machine context.
+ * Put this on a top-level transition; no hidden transcript state is created.
  *
  * @example
  * ```ts
  * on: {
- *   USER_REPLIED: appendMessages(({ event }) => userMessage(event.text)),
+ *   'agent.messages': appendMessages(),
  * }
  * ```
  */
-declare function appendMessages<TContext extends {
-  messages: AgentMessage[];
-}, TEvent extends EventObject>(resolve: AgentMessage | AgentMessage[] | ((args: {
+type AppendMessagesTransition = <TContext extends object>(args: {
   context: TContext;
-  event: TEvent;
-}) => AgentMessage | AgentMessage[])): (args: {
-  context: TContext;
-  event: TEvent;
+  event: EventObject & Partial<Omit<AgentMessagesEvent, "type">>;
 }) => {
-  context: {
-    messages: AgentMessage[];
-  };
+  context: Partial<TContext>;
 };
+declare function appendMessages<TKey extends string = "messages">(options?: {
+  key?: TKey;
+}): AppendMessagesTransition;
 /**
  * A {@link StandardSchemaV1} validating an `AgentMessage[]` context field —
  * checks that every message has a known `role` (`system`/`user`/`assistant`/
  * `tool`) and that `content` is either a string (where the role allows it) or
- * an array of parts with a known `type`. Use it directly as a context
- * schema's `messages` field when authoring with `createAgentSchemas`.
+ * an array of role-appropriate parts whose required fields and media payloads
+ * have the right runtime types (extra fields are allowed). Use it directly as
+ * a context schema's `messages` field when authoring with `createAgentSchemas`
+ * or `fromConfig`. A zod object cannot nest a Standard Schema, so in a zod
+ * context schema write `z.custom<AgentMessage[]>(isAgentMessages)`, which runs
+ * this same validator (see {@link isAgentMessages}).
  */
 declare const messagesSchema: StandardSchemaV1<AgentMessage[]>;
+/**
+ * Type guard over {@link messagesSchema}: `true` when `value` is a valid
+ * `AgentMessage[]`. The one-liner for zod context schemas:
+ * `messages: z.custom<AgentMessage[]>(isAgentMessages)`.
+ */
+declare function isAgentMessages(value: unknown): value is AgentMessage[];
 //#endregion
 //#region src/workflow-config.d.ts
 type JsonSchemaObject = {
@@ -104,7 +159,7 @@ interface AgentWorkflowConfig {
    * snapshots idle deterministically instead of using its timing heuristic.
    * Every listed tag must appear in some state's `tags` — an unused tag is a
    * build-time error. A `fromConfig(config, { isIdle })` option takes
-   * precedence; a `runAgent({ isIdle })` host override beats both.
+   * precedence over declarative `idleTags`.
    */
   idleTags?: string[];
   meta?: Record<string, unknown>;
@@ -244,16 +299,15 @@ interface FromConfigOptions {
    * the same machine-carried predicate `setupAgent({ isIdle })` declares
    * for TS-authored machines, registered here because a function cannot live
    * in the workflow config itself. Takes precedence over the config's
-   * declarative {@link AgentWorkflowConfig.idleTags}; a
-   * `runAgent({ isIdle })` host override beats both. Travels with the
-   * machine through `machine.provide(...)`.
+   * declarative {@link AgentWorkflowConfig.idleTags}. Travels with the machine
+   * through `machine.provide(...)`.
    */
   isIdle?: (snapshot: AnyMachineSnapshot) => boolean;
 }
 //#endregion
 //#region src/setup-agent.d.ts
 type Constrain<T, TConstraint> = T extends TConstraint ? T : TConstraint;
-type ContextOf<TContextSchema extends StandardSchemaV1> = Constrain<InferOutput<TContextSchema>, MachineContext>;
+type ContextOf$1<TContextSchema extends StandardSchemaV1> = Constrain<InferOutput<TContextSchema>, MachineContext>;
 type EventsOf<TEventSchemas extends AgentEventSchemaInputMap> = Constrain<EventUnion<TEventSchemas>, EventObject>;
 /**
  * The first argument a guard or delay source receives. `context` and `event`
@@ -264,7 +318,7 @@ type EventsOf<TEventSchemas extends AgentEventSchemaInputMap> = Constrain<EventU
  * real where the machine is built.
  */
 type AgentSourceArgs<TContextSchema extends StandardSchemaV1<Record<string, unknown>>, TEventSchemas extends AgentEventSchemaInputMap> = {
-  context: ContextOf<TContextSchema>;
+  context: ContextOf$1<TContextSchema>;
   event: EventsOf<TEventSchemas>;
 };
 /** Guard sources for `setupAgent({ guards })`, typed against the agent's own context and events. */
@@ -312,9 +366,12 @@ type AgentUsageEventPayload = Omit<AgentUsageEvent, "type">;
  * is typed (and autocompletes) without the machine declaring anything.
  * Idempotent: re-applying it to an already-registered map is a no-op.
  */
-type WithAgentUsageEvent<T extends AgentEventSchemaInputMap> = Omit<T, typeof AGENT_USAGE_EVENT_TYPE> & {
+type WithAgentEvents<T extends AgentEventSchemaInputMap> = Omit<T, typeof AGENT_USAGE_EVENT_TYPE | typeof AGENT_MESSAGES_EVENT_TYPE> & {
   [AGENT_USAGE_EVENT_TYPE]: StandardSchemaV1<AgentUsageEventPayload>;
+  [AGENT_MESSAGES_EVENT_TYPE]: StandardSchemaV1<AgentMessagesEventPayload>;
 };
+/** @deprecated Use {@link WithAgentEvents}. */
+type WithAgentUsageEvent<T extends AgentEventSchemaInputMap> = WithAgentEvents<T>;
 /**
  * Builds a machine's {@link AgentSchemaPack} from a partial schema
  * declaration — only `context` is required; `events`/`input`/`output`/`meta`
@@ -371,43 +428,12 @@ type AgentSetupXStateConfig<TContextSchema extends StandardSchemaV1<Record<strin
     meta: TMetaSchema;
   } & AgentSetupEventsSchema<TEventSchemas> & AgentSetupEmittedSchema<TEmittedSchemas>;
   states?: TStateSchemas;
-  actors: SetupActors<AgentSetupActors<AgentAllActors<TActors, TRequestSchemas>, Exclude<keyof TEventSchemas & string, typeof AGENT_USAGE_EVENT_TYPE>, AgentModelRef<TModels>>>;
+  actors: SetupActors<AgentSetupActors<AgentAllActors<TActors, TRequestSchemas>, Exclude<keyof TEventSchemas & string, typeof AGENT_USAGE_EVENT_TYPE | typeof AGENT_MESSAGES_EVENT_TYPE>, AgentModelRef<TModels>>>;
   actions?: NonNullable<AnySetupConfig["actions"]>;
   guards?: NonNullable<AnySetupConfig["guards"]>;
   delays?: NonNullable<AnySetupConfig["delays"]>;
 };
-/**
- * Field-level context-narrowing sugar for one `setupAgent({ states })` entry:
- * each `context` entry overrides that field's schema inside the state; every
- * other field keeps the base context schema. Sugar for the full xstate form —
- * `{ context: { draft: z.string() } }` resolves to
- * `{ schemas: { context: <base with draft: string> } }` — so only the fields
- * that change are declared, not the whole context schema.
- */
-interface AgentStateNarrowing {
-  context: Record<string, StandardSchemaV1>;
-  states?: Record<string, AgentSetupStateSchema>;
-}
-/** One `setupAgent({ states })` entry: xstate's {@link SetupStateSchema} full form, or the {@link AgentStateNarrowing} field-level sugar. */
-type AgentSetupStateSchema = SetupStateSchema | AgentStateNarrowing;
-type NarrowedContext<TContextSchema extends StandardSchemaV1, TFields extends Record<string, StandardSchemaV1>> = Omit<InferOutput<TContextSchema>, keyof TFields> & { [K in keyof TFields]: InferOutput<TFields[K]> };
-type ResolveAgentStateSchema<TContextSchema extends StandardSchemaV1, T> = T extends {
-  context: infer TFields extends Record<string, StandardSchemaV1>;
-} ? {
-  schemas: {
-    context: StandardSchemaV1<NarrowedContext<TContextSchema, TFields>>;
-  };
-} & (T extends {
-  states: infer TChildren extends Record<string, AgentSetupStateSchema>;
-} ? {
-  states: ResolveAgentStateSchemas<TContextSchema, TChildren>;
-} : {}) : T extends {
-  states: infer TChildren extends Record<string, AgentSetupStateSchema>;
-} ? Omit<T, "states"> & {
-  states: ResolveAgentStateSchemas<TContextSchema, TChildren>;
-} : T;
-type ResolveAgentStateSchemas<TContextSchema extends StandardSchemaV1, TStates extends Record<string, AgentSetupStateSchema>> = Constrain<{ [K in keyof TStates]: ResolveAgentStateSchema<TContextSchema, TStates[K]> }, Record<string, SetupStateSchema>>;
-type SetupAgentBaseConfig<TContextSchema extends StandardSchemaV1<Record<string, unknown>>, TEventSchemas extends AgentEventSchemaInputMap, TActors extends { [K in keyof TActors]: AnyActorLogic }, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TRequestSchemas extends AgentRequestSchemaMap, TModels extends AgentModelMap, TEmittedSchemas extends Record<string, StandardSchemaV1> = {}, TStateSchemas extends Record<string, AgentSetupStateSchema> = Record<string, AgentSetupStateSchema>> = ({
+type SetupAgentBaseConfig<TContextSchema extends StandardSchemaV1<Record<string, unknown>>, TEventSchemas extends AgentEventSchemaInputMap, TActors extends { [K in keyof TActors]: AnyActorLogic }, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TRequestSchemas extends AgentRequestSchemaMap, TModels extends AgentModelMap, TEmittedSchemas extends Record<string, StandardSchemaV1> = {}, TStateSchemas extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>> = ({
   schemas: AgentSchemaPack<TContextSchema, TEventSchemas, TInputSchema, TOutputSchema, TMetaSchema, TEmittedSchemas>;
 } | AgentSchemaConfig<TContextSchema, TEventSchemas, TInputSchema, TOutputSchema, TMetaSchema, TEmittedSchemas>) & {
   models?: TModels;
@@ -416,9 +442,8 @@ type SetupAgentBaseConfig<TContextSchema extends StandardSchemaV1<Record<string,
    * Per-state schemas, mirroring xstate's `setup({ states })`: narrow
    * `context` inside a state (invoke `input`, transition fns, final `output`)
    * — e.g. mark a field non-null in states only reachable after it is set.
-   * Two forms per state: the {@link AgentStateNarrowing} sugar
-   * (`{ context: { draft: z.string() } }` — only the fields that change) or
-   * xstate's full `{ schemas: { context } }` with a complete context schema.
+   * Use xstate's native `{ schemas: { context } }` form with a complete
+   * context schema.
    */
   states?: TStateSchemas;
   requests?: AgentRequestInput<TRequestSchemas, AgentModelRef<TModels>>;
@@ -430,14 +455,14 @@ type SetupAgentBaseConfig<TContextSchema extends StandardSchemaV1<Record<string,
    * human approval, an inbound webhook, …) — the machine's own declaration of
    * what "idle" means for it, so `runAgent` settles those snapshots idle
    * deterministically instead of using its timing heuristic. Travels with the
-   * machine through `machine.provide(...)`. A `runAgent({ isIdle })` host
-   * override takes precedence; with neither, `runAgent` falls back to the timing
-   * heuristic. Declare your own signal — e.g. `(s) => s.hasTag('awaiting-review')`
-   * or `(s) => getStateMeta(s).interaction !== undefined`.
+   * machine through `machine.provide(...)`. Without one, `runAgent` recognizes
+   * resting event-handling states and `meta.interaction` by structure. Use a
+   * predicate only for a more specialized machine-owned wait rule. Import and
+   * call `isAgentIdle(snapshot)` inside it when expanding the default rule.
    */
   isIdle?: (snapshot: AnyMachineSnapshot) => boolean;
 };
-type SetupAgentXStateResult<TContextSchema extends StandardSchemaV1<Record<string, unknown>>, TEventSchemas extends AgentEventSchemaInputMap, TActors extends { [K in keyof TActors]: AnyActorLogic }, TRequestSchemas extends AgentRequestSchemaMap, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TModels extends AgentModelMap, TEmittedSchemas extends Record<string, StandardSchemaV1> = {}, TStateSchemas extends Record<string, AgentSetupStateSchema> = Record<string, AgentSetupStateSchema>> = SetupReturnFromConfig<AgentSetupXStateConfig<TContextSchema, TEventSchemas, TActors, TRequestSchemas, TInputSchema, TOutputSchema, TMetaSchema, TModels, TEmittedSchemas, ResolveAgentStateSchemas<TContextSchema, TStateSchemas>>>;
+type SetupAgentXStateResult<TContextSchema extends StandardSchemaV1<Record<string, unknown>>, TEventSchemas extends AgentEventSchemaInputMap, TActors extends { [K in keyof TActors]: AnyActorLogic }, TRequestSchemas extends AgentRequestSchemaMap, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TModels extends AgentModelMap, TEmittedSchemas extends Record<string, StandardSchemaV1> = {}, TStateSchemas extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>> = SetupReturnFromConfig<AgentSetupXStateConfig<TContextSchema, TEventSchemas, TActors, TRequestSchemas, TInputSchema, TOutputSchema, TMetaSchema, TModels, TEmittedSchemas, TStateSchemas>>;
 /**
  * The object returned by {@link setupAgent}: an xstate `setup(...)` result
  * (`createMachine`, `assign`, …) extended with `schemas` (the resolved
@@ -446,7 +471,14 @@ type SetupAgentXStateResult<TContextSchema extends StandardSchemaV1<Record<strin
  * `runAgent` and the free step helpers can resolve their schemas/actors
  * without re-passing them each call.
  */
-type SetupAgentResult<TContextSchema extends StandardSchemaV1<Record<string, unknown>>, TEventSchemas extends AgentEventSchemaInputMap, TActors extends { [K in keyof TActors]: AnyActorLogic }, TRequestSchemas extends AgentRequestSchemaMap, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TModels extends AgentModelMap, TEmittedSchemas extends Record<string, StandardSchemaV1> = {}, TStateSchemas extends Record<string, AgentSetupStateSchema> = Record<string, AgentSetupStateSchema>> = Omit<SetupAgentXStateResult<TContextSchema, TEventSchemas, TActors, TRequestSchemas, TInputSchema, TOutputSchema, TMetaSchema, TModels, TEmittedSchemas, TStateSchemas>, "createMachine"> & {
+type ArrayContextKey<TContext> = { [TKey in keyof TContext & string]: TContext[TKey] extends readonly unknown[] ? TKey : never }[keyof TContext & string];
+type AgentAppendMessages<TContext> = {
+  (): AppendMessagesTransition;
+  <TKey extends ArrayContextKey<TContext>>(options: {
+    key: TKey;
+  }): AppendMessagesTransition;
+};
+type SetupAgentResult<TContextSchema extends StandardSchemaV1<Record<string, unknown>>, TEventSchemas extends AgentEventSchemaInputMap, TActors extends { [K in keyof TActors]: AnyActorLogic }, TRequestSchemas extends AgentRequestSchemaMap, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TModels extends AgentModelMap, TEmittedSchemas extends Record<string, StandardSchemaV1> = {}, TStateSchemas extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>> = Omit<SetupAgentXStateResult<TContextSchema, TEventSchemas, TActors, TRequestSchemas, TInputSchema, TOutputSchema, TMetaSchema, TModels, TEmittedSchemas, TStateSchemas>, "createMachine"> & {
   /**
    * Creates the agent machine — XState's own `createMachine`, plus: the
    * machine is registered so step helpers and {@link runAgent} can resolve
@@ -456,15 +488,8 @@ type SetupAgentResult<TContextSchema extends StandardSchemaV1<Record<string, unk
   createMachine: SetupAgentXStateResult<TContextSchema, TEventSchemas, TActors, TRequestSchemas, TInputSchema, TOutputSchema, TMetaSchema, TModels, TEmittedSchemas, TStateSchemas>["createMachine"]; /** The retained schema pack ({@link AgentSchemaPack}) for host-side validation and tooling. Its `events` include the reserved `'@agent.usage'` entry setupAgent registers by default. */
   schemas: AgentSchemaPack<TContextSchema, WithAgentUsageEvent<TEventSchemas>, TInputSchema, TOutputSchema, TMetaSchema, TEmittedSchemas>; /** The `models` registry passed to `setupAgent(...)`, if any (used to type-narrow `AgentModelRef`). */
   readonly models: TModels; /** The {@link TextLogic} actors built from `setupAgent({ requests })`, keyed the same way. */
-  readonly requests: RequestActors<TRequestSchemas>; /** {@link appendMessages}, typed against this agent's context/event schemas. */
-  appendMessages(resolve: AgentMessage | AgentMessage[] | ((args: {
-    context: ContextOf<TContextSchema> & {
-      messages: AgentMessage[];
-    };
-    event: any;
-  }) => AgentMessage | AgentMessage[])): ReturnType<typeof appendMessages<ContextOf<TContextSchema> & {
-    messages: AgentMessage[];
-  }, EventsOf<WithAgentUsageEvent<TEventSchemas>>>>;
+  readonly requests: RequestActors<TRequestSchemas>; /** {@link appendMessages}, for an explicit top-level `agent.messages` transition. */
+  appendMessages: AgentAppendMessages<InferOutput<TContextSchema>>;
 };
 /**
  * Schema-first `setup(...)` for agent machines — the standard entry point
@@ -511,7 +536,7 @@ type SetupAgentResult<TContextSchema extends StandardSchemaV1<Record<string, unk
  * });
  * ```
  */
-declare function setupAgent<TContextSchema extends StandardSchemaV1<Record<string, unknown>>, TEventSchemas extends AgentEventSchemaInputMap, TActors extends { [K in keyof TActors]: AnyActorLogic }, TRequestSchemas extends AgentRequestSchemaMap = {}, TInputSchema extends StandardSchemaV1 = StandardSchemaV1<NonReducibleUnknown>, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1<NonReducibleUnknown>, TMetaSchema extends StandardSchemaV1 = StandardSchemaV1<MetaObject>, TModels extends AgentModelMap = {}, TEmittedSchemas extends Record<string, StandardSchemaV1> = {}, const TStateSchemas extends Record<string, AgentSetupStateSchema> = Record<string, AgentSetupStateSchema>>(config: SetupAgentBaseConfig<TContextSchema, TEventSchemas, TActors, TInputSchema, TOutputSchema, TMetaSchema, TRequestSchemas, TModels, TEmittedSchemas, TStateSchemas>): SetupAgentResult<TContextSchema, TEventSchemas, TActors, TRequestSchemas, TInputSchema, TOutputSchema, TMetaSchema, TModels, TEmittedSchemas, TStateSchemas>;
+declare function setupAgent<TContextSchema extends StandardSchemaV1<Record<string, unknown>>, TEventSchemas extends AgentEventSchemaInputMap, TActors extends { [K in keyof TActors]: AnyActorLogic }, TRequestSchemas extends AgentRequestSchemaMap = {}, TInputSchema extends StandardSchemaV1 = StandardSchemaV1<NonReducibleUnknown>, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1<NonReducibleUnknown>, TMetaSchema extends StandardSchemaV1 = StandardSchemaV1<MetaObject>, TModels extends AgentModelMap = {}, TEmittedSchemas extends Record<string, StandardSchemaV1> = {}, const TStateSchemas extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>>(config: SetupAgentBaseConfig<TContextSchema, TEventSchemas, TActors, TInputSchema, TOutputSchema, TMetaSchema, TRequestSchemas, TModels, TEmittedSchemas, TStateSchemas>): SetupAgentResult<TContextSchema, TEventSchemas, TActors, TRequestSchemas, TInputSchema, TOutputSchema, TMetaSchema, TModels, TEmittedSchemas, TStateSchemas>;
 declare namespace setupAgent {
   /**
    * Builds a state machine from a serializable {@link AgentWorkflowConfig}
@@ -544,74 +569,183 @@ declare namespace setupAgent {
  * authored. Returns `undefined` for machines not built by either (a plain
  * xstate `createMachine`/`setup` machine).
  *
- * Registration is keyed on the machine object, so a machine returned by
- * `machine.provide(...)` carries no pack — read it from the machine the setup
- * returned.
+ * Registration also travels through `machine.provide(...)`: the pack is keyed
+ * on the machine's root `config`, which `.provide` shares by reference.
  */
 declare function getAgentSchemas(machine: AnyStateMachine): AgentSchemas | undefined;
 //#endregion
-//#region src/agent-run.d.ts
+//#region src/interaction.d.ts
+interface AgentInteractionEvent<TType extends string = string> {
+  type: TType;
+  label: string;
+  style?: string;
+  /** Optional fixed fields merged into the event when this choice is selected. */
+  event?: Record<string, unknown>;
+}
+interface AgentInteraction<TEvent extends EventObject = EventObject> {
+  label: string;
+  events: AgentInteractionEvent<TEvent["type"]>[];
+  /** Event type used for a free-text response. */
+  textEvent?: TEvent["type"];
+}
 /**
- * A live handle over a single {@link runAgent} call: its trace events as an
- * async stream, plus the same result promise `runAgent` returns.
- *
- * Build it with {@link createAgentRun}. Use `events` for a pull-based feed
- * (SSE, a JSONL logger, a progress UI) and `result` for the final outcome —
- * either, both, or neither; nothing about consuming one is required to consume
- * the other.
+ * One choice as authored in `meta.interaction.events`: a bare label, or a
+ * descriptor carrying a `style` and the fixed `event` fields merged in when the
+ * choice is selected.
  */
-interface AgentRun<TMachine extends AnyStateMachine = AnyStateMachine> {
-  /**
-   * Single-consumer async stream of the run's trace events, in `runAgent`'s
-   * emission order (`run.start` → request/chunk/transition/emit events →
-   * `run.end`). Completes right after `run.end` is delivered. Events are
-   * buffered unboundedly, so a slow or absent consumer never blocks the run
-   * (see {@link createAgentRun}). Single-consumer: a second `for await` over the
-   * same iterator picks up only the events not yet pulled — it is one shared
-   * cursor, not a fresh replay.
-   */
-  events: AsyncIterableIterator<AgentTraceEvent<TMachine>>;
+type AgentInteractionEventMeta = string | {
+  label?: string;
+  style?: string;
+  event?: Record<string, unknown>;
+};
+/** The `interaction` descriptor {@link getInteraction} reads off a state's meta. */
+interface AgentInteractionDescriptor {
+  /** Label text, or a function of the machine context. `{path.to.field}` interpolates. */
+  label?: string | ((args: {
+    context: any;
+  }) => string);
+  events?: Record<string, AgentInteractionEventMeta>;
+  textEvent?: string;
+}
+/**
+ * The state-meta shape the interaction protocol reads. Use it as the `meta`
+ * type when the machine's only metadata is an interaction; see
+ * {@link interactionMetaSchema} for the runtime schema.
+ */
+interface AgentInteractionMeta {
+  interaction?: AgentInteractionDescriptor;
+}
+/**
+ * A {@link StandardSchemaV1} for the state metadata {@link getInteraction}
+ * reads: an object whose optional `interaction` declares a `label` (a string
+ * with `{context.path}` interpolation, or a function of the context), an
+ * `events` map of choices, and a `textEvent` for free-text answers. Pass it
+ * straight to `createAgentSchemas({ meta: interactionMetaSchema })` instead of
+ * restating the shape per machine.
+ */
+declare const interactionMetaSchema: StandardSchemaV1<AgentInteractionMeta>;
+/** Options for {@link getInteraction}. */
+interface GetInteractionOptions {
   /**
-   * Settles exactly like {@link runAgent}'s return value: resolves with the
-   * `done | idle | error` {@link RunAgentResult}, and rejects only where
-   * `runAgent` itself rejects (bind-time programmer errors — a missing
-   * executor, an illegal resume event, a version mismatch). A run-level failure
-   * still resolves with `{ status: 'error' }`, never rejects.
+   * Keep label whitespace exactly as authored. Off by default: labels collapse
+   * runs of whitespace to single spaces and trim, so a multi-line template
+   * literal renders as one line and interpolated context cannot smuggle in
+   * layout. Turn it on when the label is deliberately multi-line (a rendered
+   * diff, a preformatted block).
    */
-  result: Promise<RunAgentResult<TMachine>>;
+  preserveWhitespace?: boolean;
 }
+/** Reads the active state's interaction metadata and filters it through the
+ * events XState currently accepts. Returns `undefined` when none is declared. */
+declare function getInteraction<TSnapshot extends AnyMachineSnapshot>(snapshot: TSnapshot, options?: GetInteractionOptions): AgentInteraction<EventFromSnapshot<TSnapshot>> | undefined;
+/** Converts a rendered interaction choice back into a schema-validated machine
+ * event. Fixed fields declared in metadata are merged before user fields. */
+declare function eventFromInteraction<TSnapshot extends AnyMachineSnapshot>(snapshot: TSnapshot, choice: ({
+  type: string;
+} & Record<string, unknown>) | {
+  text: string;
+}): EventFromSnapshot<TSnapshot>;
+//#endregion
+//#region src/event-log-store-conformance.d.ts
+/** Produces a fresh, empty store for one case. */
+type CreateStore = () => Promise<AgentEventLogStore> | AgentEventLogStore;
 /**
- * Wraps {@link runAgent} in a canonical run-stream handle: the run's trace
- * events as a pull-based {@link AgentRun.events} async iterator, alongside the
- * unchanged {@link AgentRun.result} promise.
+ * A test runner's registration functions. `expect` is accepted and unused —
+ * every case asserts by throwing, so the suite stays runner-agnostic.
+ */
+interface EventLogStoreConformanceHarness {
+  describe: (name: string, register: () => void) => void;
+  it: (name: string, run: () => Promise<void>) => void;
+  expect?: unknown;
+}
+/**
+ * Validates a store against the reference's semantics: empty read + zero length
+ * for unknown threads; single and multi-entry append; contiguity misuse guard;
+ * stale-`expectedIndex` conflict with correct fields; an interleaved concurrent
+ * append race (exactly one winner); entry-id uniqueness; `read({ from })`
+ * incremental correctness; thread isolation; metadata round-trip; deep-copy
+ * isolation on append and read; and the full fork contract.
  *
- * Semantics:
+ * Without a `harness`, every case runs in sequence and the first violation
+ * throws. With one, each case is registered as its own test:
  *
- * 1. **Starts immediately.** The underlying `runAgent` is invoked on this call,
- *    not on the first `events` iteration — work is already in flight when
- *    `createAgentRun` returns.
- * 2. **Buffer, don't stall.** Events are queued in an unbounded in-memory
- *    buffer as the run emits them; a slow or absent consumer never applies
- *    backpressure to the run. Once `run.end` is delivered, the iterator
- *    completes.
- * 3. **Composes `onTrace`.** If `options.onTrace` is passed, it still fires for
- *    every event — the wrapper adds queue delivery, it does not replace the
- *    caller's sink.
- * 4. **`result` mirrors `runAgent`.** Same resolution and rejection behavior
- *    (see {@link AgentRun.result}). A no-op rejection handler is attached
- *    internally so a caller who reads only `events` never trips an unhandled
- *    rejection on a bind-time throw; the returned promise still rejects for a
- *    caller who awaits it.
- * 5. **Resume is identical.** Options pass straight through, so starting from a
- *    persisted `snapshot` (+ resume `event`) streams that run's events from its
- *    own `run.start`, exactly as `runAgent` would run it.
- * 6. **Early termination does not cancel the run.** Breaking out of a
- *    `for await` (or calling `events.return()`) stops delivery, but the run
- *    keeps going and `result` still settles. Cancelling the run itself is
- *    future work — pass `options.signal` to abort it.
- * 7. **`events` is single-consumer.** See {@link AgentRun.events}.
+ * ```ts
+ * import { describe, it } from 'vitest';
+ * assertEventLogStoreConformance(createMyStore, { describe, it });
+ * ```
  */
-declare function createAgentRun<TMachine extends AnyStateMachine>(machine: TMachine, options: RunAgentOptions<TMachine>): AgentRun<TMachine>;
+declare function assertEventLogStoreConformance(create: CreateStore, harness?: EventLogStoreConformanceHarness): Promise<void>;
+//#endregion
+//#region src/agent-run.d.ts
+type AgentStreamEvent<TMachine extends AnyStateMachine = AnyStateMachine> = {
+  kind: "request";
+  phase: "start" | "end";
+  name: string;
+  id: string;
+  request: AgentStepRequest;
+  output?: unknown;
+  raw?: unknown;
+} | {
+  kind: "request";
+  phase: "error";
+  name: string;
+  id: string;
+  request: AgentStepRequest;
+  error: unknown;
+} | {
+  kind: "chunk";
+  name: string;
+  id: string;
+  delta: string;
+} | {
+  kind: "transition";
+  value: StateValue;
+  event: EventFromLogic<TMachine>;
+} | {
+  kind: "emit";
+  event: EmittedFrom<TMachine>;
+} | {
+  kind: "done";
+  result: Extract<RunAgentResult<TMachine>, {
+    status: "done";
+  }>;
+} | {
+  kind: "idle";
+  result: Extract<RunAgentResult<TMachine>, {
+    status: "idle";
+  }>;
+} | {
+  kind: "error";
+  result: Extract<RunAgentResult<TMachine>, {
+    status: "error";
+  }>;
+};
+/**
+ * Streams one {@link runAgent} call as agent-level events. The machine remains
+ * the single artifact; this function only projects its requests, chunks,
+ * transitions, emitted events, and terminal result into an async iterable.
+ */
+declare function runAgentStream<TMachine extends AnyStateMachine>(machine: TMachine, options: RunAgentOptions<TMachine>): AsyncGenerator<AgentStreamEvent<TMachine>, void>;
+//#endregion
+//#region src/run-loop.d.ts
+interface RunAgentLoopOptions<TMachine extends AnyStateMachine> extends Omit<RunAgentOptions<TMachine>, "snapshot" | "event"> {
+  /** Called whenever the machine pauses. Return its next event, or nothing to
+   * leave the run paused. */
+  onIdle?: (result: Extract<RunAgentResult<TMachine>, {
+    status: "idle";
+  }>) => EventFromLogic<TMachine> | null | undefined | Promise<EventFromLogic<TMachine> | null | undefined>;
+  /** Called before `onIdle`, at every pause. Framework/host persistence stays here. */
+  persist?: (snapshot: ReturnType<Extract<RunAgentResult<TMachine>, {
+    status: "idle";
+  }>["persist"]>, result: Extract<RunAgentResult<TMachine>, {
+    status: "idle";
+  }>) => void | Promise<void>;
+  maxTurns?: number;
+}
+/** Drives one machine artifact across as many idle/resume turns as the host
+ * supplies. XState snapshots remain the continuation; this helper owns no
+ * persistence, retry, tool-loop, or storage policy. */
+declare function runAgentLoop<TMachine extends AnyStateMachine>(machine: TMachine, options: RunAgentLoopOptions<TMachine>): Promise<RunAgentResult<TMachine>>;
 //#endregion
 //#region src/provide-executors.d.ts
 /** Options for {@link provideExecutors}. */
@@ -690,7 +824,7 @@ type AgentLintSeverity = "error" | "warning";
  * or config location, and `message` explains the problem and its remedy.
  */
 interface AgentLintDiagnostic {
-  code: "unreachable-state" | "decide-without-events" | "unserializable-context" | "direct-object-src" | "final-without-output" | "final-output-reads-event" | "undeclared-event" | "missing-final";
+  code: "decide-without-events" | "direct-object-src" | "invoke-without-on-error" | "unhandled-agent-messages";
   severity: AgentLintSeverity;
   /** State path (`parent.child`) or config pointer (e.g. `(root)`, `context`) the finding is about. */
   path: string;
@@ -717,8 +851,9 @@ interface LintAgentMachineOptions {
  * plus the schemas/actor sources the library already retains per machine.
  *
  * No model calls, no API keys — a coding agent that emits an agent machine can
- * call this to catch dead states, undeliverable decisions, un-rebindable
- * invoke srcs, and output-contract gaps before ever running it.
+ * call this to catch agent-specific mistakes such as undeliverable decisions,
+ * un-rebindable request sources, and an unhandled transcript event. General
+ * state-machine lint belongs to XState tooling.
  *
  * Pass `{ throw: true }` for the one-liner form used in tests and generation
  * loops: it returns silently when the machine is clean and throws
@@ -784,6 +919,14 @@ declare function assertAgentMachine(machine: AnyStateMachine, options?: AssertAg
  * - `userInput` — a flat FIFO queue of answers for `agent.userInput`, the
  *   shorthand for `invokes: { 'agent.userInput': [...] }`. Entries here are
  *   consumed before that src's `invokes` queue.
+ * - `errors` — failure values to reject a request or invoke with instead of
+ *   resolving it, keyed by the same srcs the other channels use. An entry here
+ *   is consumed BEFORE that src's output queue, so a script can fail the first
+ *   call and let the second succeed. The invoke is rejected with
+ *   {@link rejectAgentStep}, so the machine takes its `onError`; for
+ *   `agent.decide` the entry stands in for retry exhaustion. A value can be
+ *   anything — an `Error`, a string, or an object such as `{ code: 'truncated' }`
+ *   for a machine that branches on `event.error.code`.
  * - `events` — a flat FIFO queue of external (human/host-sent) events. When the
  *   machine settles idle with no pending request or invoke — a human gate — the
  *   next queued event is applied, so a simulation can cross states that a live
@@ -795,6 +938,7 @@ interface SimulationScript {
   decisions?: Record<string, ChosenEvent[]>;
   invokes?: Record<string, unknown[]>;
   userInput?: unknown[];
+  errors?: Record<string, unknown[]>;
   events?: ChosenEvent[];
 }
 /**
@@ -819,11 +963,18 @@ interface SimulationTrailEntry {
    * exhaustion error was routed through the decision invoke's `onError`.
    */
   rejectedEvents?: ChosenEvent[];
-  /** The resolved request (for a text/userInput invoke): its kind and src. */
+  /**
+   * The request this step settled (a text, decision, or scripted invoke): its
+   * kind, src, and how it settled. `outcome` is `'output'` when a scripted
+   * output resolved it and `'error'` when a `script.errors` entry rejected it,
+   * in which case `error` carries the scripted failure value.
+   */
   resolvedRequest?: {
-    kind: "text" | "userInput";
+    kind: "text" | "userInput" | "decision";
     src: string;
     id: string;
+    outcome: "output" | "error";
+    error?: unknown;
   };
 }
 /** Options for {@link simulateAgent}. */
@@ -896,16 +1047,40 @@ interface ExplorePathsOptions {
   invokes?: Record<string, unknown>;
   /** Canned output for `agent.userInput`, the shorthand for `invokes['agent.userInput']`. */
   userInput?: unknown;
+  /**
+   * A canned failure per src, keyed like `text`/`invokes`. A src listed here
+   * forks an extra branch at that invoke, where the invoke is rejected and the
+   * machine takes its `onError` — so states reachable only through a failure
+   * are explored. When the src also has an output, both branches are explored;
+   * when it has only an error, only the failing one is. Each fork counts
+   * against `maxDepth`, and the failing branch records
+   * `{ type: 'xstate.error.actor.<id>' }` in the path.
+   *
+   * A decision invoke can be keyed here too — by its src (usually
+   * `agent.decide`) or by its invoke id — standing in for retry exhaustion.
+   * Its success branch is the usual per-candidate-event fork, so the failing
+   * branch is explored in addition to, not instead of, the candidates.
+   *
+   * A rejection that reaches no `onError` errors the machine, and that path
+   * ends in an `error` terminal.
+   */
+  errors?: Record<string, unknown>;
 }
 /** A single explored path's terminal outcome. */
 interface AgentPathTerminal {
-  status: "done" | "idle" | "needs-output" | "max-depth";
+  /**
+   * `'error'` is a scripted failure the machine had no `onError` for: the
+   * snapshot is errored, exactly as a live run's unhandled invoke failure.
+   */
+  status: "done" | "idle" | "needs-output" | "max-depth" | "error";
   /** The chosen/applied events, in order, that produced this terminal. */
   path: ChosenEvent[];
   /** The final state value on this path. */
   state: unknown;
   /** For `needs-output`: the src whose canned output was missing. */
   missingSrc?: string;
+  /** For `error`: the failure value that errored the machine. */
+  error?: unknown;
 }
 /** The report returned by {@link explorePaths}. */
 interface AgentPathReport {
@@ -930,7 +1105,9 @@ interface AgentPathReport {
  * an idle wait it forks per externally-accepted event. Text requests resolve
  * from `text`, other invokes from `invokes` (or `userInput` for
  * `agent.userInput`) — all by-src canned-output maps, and a missing src halts
- * that branch with a `needs-output` terminal rather than throwing.
+ * that branch with a `needs-output` terminal rather than throwing. A src in
+ * `errors` forks an extra branch where that invoke is rejected, so states
+ * behind an `onError` are explored too.
  *
  * Combinatorics are bounded by `maxDepth` (default 8) and `maxPaths` (default
  * 200, reported via `hitPathCap`).
@@ -946,9 +1123,16 @@ declare function explorePaths(machine: AnyStateMachine, options?: ExplorePathsOp
 interface CanReachResult {
   /** True when the target state was reached within the exploration bounds. */
   reachable: boolean;
+  /** Resolved XState state-node id for a string target. */
+  target?: string;
   /** When reachable, the sequence of chosen/applied events that gets there. */
   witness?: ChosenEvent[];
 }
+/** Thrown when a string reachability target is not a state in the machine. */
+declare class AgentUnknownStateError extends AgentError {
+  readonly target: string;
+  constructor(machineId: string, target: string);
+}
 /**
  * Answers "can the machine reach this?" by exploring its branches (a thin
  * wrapper over {@link explorePaths}). The target is either a state path string
@@ -982,16 +1166,19 @@ interface TrajectoryEvent {
   type: string;
   [key: string]: unknown;
 }
+/** Any host-owned envelope around an event. */
+interface TrajectoryEventEnvelope {
+  event: TrajectoryEvent;
+}
 /**
  * One item in a trajectory, on either side of the comparison:
  *
  * - a state value — `'drafting'`, a dot path `'review.editing'`, or the nested
  *   object XState reports (`{ review: 'editing' }`),
- * - an event — an {@link AgentLogEntry} from `result.events`, a bare event
- *   object, or just the event type as a string,
+ * - an event object, or just the event type as a string,
  * - a machine snapshot, whose `value` is used.
  */
-type TrajectoryItem = StateValue | AgentLogEntry | TrajectoryEvent | {
+type TrajectoryItem = StateValue | TrajectoryEvent | TrajectoryEventEnvelope | {
   value: StateValue;
 };
 /** Options for {@link matchesTrajectory}. */
@@ -1033,8 +1220,8 @@ interface TrajectoryMatch {
 /**
  * Matches a run's trajectory against an expected one.
  *
- * Both trajectories may be state values (collected from `onTransition`) or
- * events (`result.events`, whose {@link AgentLogEntry} envelopes are unwrapped);
+ * Both trajectories may be state values or events collected from
+ * `onTransition`;
  * items are compared by shape, so `['prompting', 'drafting']` scores a state
  * path and `['PROMPT_SUBMITTED', 'SEND']` scores an event log with the same
  * call.
@@ -1054,7 +1241,7 @@ interface TrajectoryMatch {
  *
  * const path = matchesTrajectory(statePath, ['prompting', 'drafting', 'sent']);
  * expect(path.matched, JSON.stringify(path.firstMiss)).toBe(true);
- * expect(matchesTrajectory(result.events, ['PROMPT_SUBMITTED', 'SEND']).matched).toBe(true);
+ * expect(matchesTrajectory(events, ['PROMPT_SUBMITTED', 'SEND']).matched).toBe(true);
  * ```
  *
  * @example Partial credit in an eval scorer
@@ -1077,13 +1264,13 @@ type ScriptedDecisionValue = ChosenEvent | {
   usage?: AgentCallUsage;
 };
 /**
- * One entry in the `decisions` queue: a scripted answer, or a function of the
+ * One scripted `decide` answer, or a function of the
  * {@link AgentDecisionRequest} returning one (for choices that depend on the
  * prompt, the candidate `events`, or the prior failed `attempts`).
  */
 type ScriptedDecisionEntry = ScriptedDecisionValue | ((request: AgentDecisionRequest) => ScriptedDecisionValue | PromiseLike<ScriptedDecisionValue>);
 /**
- * One entry in the `text` queue: the request's output value (a string, or the
+ * One scripted text answer: the request's output value (a string, or the
  * object a structured request declares), or a function of the
  * {@link AgentTextRequest} returning one.
  *
@@ -1097,30 +1284,41 @@ type ScriptedDecisionEntry = ScriptedDecisionValue | ((request: AgentDecisionReq
  */
 type ScriptedTextEntry = ((request: AgentTextRequest, info?: AgentRequestExecutorInfo) => unknown) | string | number | boolean | null | object;
 /**
- * One entry in the `userInput` queue: the string the simulated human typed, or
- * a function of the {@link AgentUserInput} request (its `prompt`/`metadata`)
+ * A request-name keyed script. The key is the request's resolved `name` — the
+ * authored name, else the invoke `id`. `"*"` is the fallback route.
+ */
+type ScriptedByName<TEntry> = Record<string, TEntry | TEntry[]>;
+/** One scripted stream call: chunks, or a function producing chunks. */
+type ScriptedStreamEntry = string | readonly string[] | ((request: AgentTextRequest, info?: AgentRequestExecutorInfo) => string | readonly string[] | PromiseLike<string | readonly string[]>);
+/** A call observed by {@link createScriptedExecutors}. */
+interface ScriptedExecutorCall {
+  kind: "generateText" | "streamText" | "decide" | "userInput";
+  name: string;
+  input: unknown;
+  request: AgentTextRequest | AgentDecisionRequest | AgentUserInput;
+}
+/**
+ * One scripted human answer: the string the simulated human typed, or a
+ * function of the {@link AgentUserInput} request (its `prompt`/`metadata`)
  * returning one.
  */
 type ScriptedUserInputEntry = string | ((input: AgentUserInput) => string | PromiseLike<string>);
 /**
- * The script {@link createScriptedExecutors} plays back.
- *
- * The key names match `simulateAgent`'s script (`decisions`, `text`,
- * `invokes`, `userInput`), but the shapes differ by design: `simulateAgent`
- * drives the pure step path and keys each channel BY SRC
- * (`text: { summarize: [...] }`), while these executors sit behind the real
- * executor contract, where one flat FIFO queue per channel is the ergonomic
- * form — route per request inside a function entry (`request.name`) when one
- * script must serve several requests. There is no `invokes` queue here:
- * non-`userInput` invokes are plain actors, supplied via `actors`.
+ * The script {@link createScriptedExecutors} plays back. Every channel is
+ * keyed by request name and consumed in order; the last entry for a name
+ * repeats forever.
  */
 interface ScriptedExecutorsScript {
-  /** Answers for `decide` requests, consumed in order. */
-  decisions?: ScriptedDecisionEntry[];
-  /** Answers for text requests, consumed in order. `generateText` and `streamText` share this one queue. */
-  text?: ScriptedTextEntry[];
+  /** Answers for `decide` requests, keyed by request name. */
+  decisions?: ScriptedByName<ScriptedDecisionEntry>;
+  /** Answers for generate requests, keyed by request name. */
+  text?: ScriptedByName<ScriptedTextEntry>;
+  /** Stream chunks keyed by request name. */
+  stream?: Record<string, ScriptedStreamEntry>;
   /** Answers for `agent.userInput` requests, consumed in order. */
   userInput?: ScriptedUserInputEntry[];
+  /** Default usage attached when an entry does not provide its own. */
+  usage?: AgentCallUsage;
 }
 /**
  * What {@link createScriptedExecutors} returns: the full executor set, plus a
@@ -1129,24 +1327,29 @@ interface ScriptedExecutorsScript {
  */
 type ScriptedExecutors = Required<AgentRequestExecutors> & {
   userInput: (input: AgentUserInput) => Promise<string>;
+  calls: ScriptedExecutorCall[];
 };
 /**
- * Keyless executors that replay a script instead of calling a model. Every
- * slot is provided, so any machine binds; a request with no entry left throws a
- * descriptive error naming what was pending.
+ * Executors that replay a script instead of calling a model. Every slot is
+ * provided, so any machine binds.
  *
- * Queues are consumed FIFO and are copied on creation, so the caller's arrays
- * are never mutated and each call builds a fresh, independent playthrough.
- * Entries may be plain values or functions of the request, which is how one
- * script serves a machine that loops or branches: route on `request.name` (the
- * `setupAgent({ requests })` key) or on the decision's candidate `events`.
+ * Answers are keyed by the request's resolved name — its authored `name`, else
+ * the invoke `id` — and `"*"` serves anything unmatched.
+ * Entries for a name are consumed in order and the last one repeats forever, so
+ * a looping machine needs no extra option. A request the script has no route
+ * for throws an ordinary `Error` from inside the executor, which reaches the
+ * machine as an actor error.
+ *
+ * Queues are copied on creation, so the caller's arrays are never mutated and
+ * each call builds a fresh, independent playthrough. Entries may be plain
+ * values or functions of the request.
  *
  * @example
  * ```ts
  * const result = await runAgent(moderationMachine, {
  *   input: { comment: 'honestly this update is terrible', trust: 20 },
  *   executors: createScriptedExecutors({
- *     decisions: [{ type: 'FLAG', reason: 'Borderline tone.' }],
+ *     decisions: { moderate: [{ type: 'FLAG', reason: 'Borderline tone.' }] },
  *   }),
  * });
  * ```
@@ -1154,8 +1357,8 @@ type ScriptedExecutors = Required<AgentRequestExecutors> & {
  * @example Dynamic entries
  * ```ts
  * createScriptedExecutors({
- *   text: [(request) => `Draft about ${request.prompt}`],
- *   decisions: [(request) => ({ type: request.events[0]!.type })],
+ *   text: { draft: (request) => `Draft about ${request.prompt}` },
+ *   decisions: { route: (request) => ({ type: request.events[0]!.type }) },
  * });
  * ```
  *
@@ -1168,6 +1371,8 @@ type ScriptedExecutors = Required<AgentRequestExecutors> & {
 declare function createScriptedExecutors(script?: ScriptedExecutorsScript): ScriptedExecutors;
 //#endregion
 //#region src/utils.d.ts
+/** Returns the human-readable text carried by a message, ignoring non-text parts. */
+declare function getMessageText(message: AgentMessage): string;
 /**
  * A stable, dependency-free structural fingerprint of a machine — a short hex
  * `djb2` hash over its **structural** config only: state ids/nesting, transition
@@ -1225,19 +1430,28 @@ declare function getStateMeta<TSnapshot extends {
   getMeta(): Record<string, unknown>;
 } = AnyMachineSnapshot, TMeta = MetaOfSnapshot<TSnapshot>>(snapshot: TSnapshot): Partial<TMeta>;
 /**
- * Reads the run-owned message log off a snapshot settled by a `runAgent` call
- * that used `getRequests` (or `options.messages`) — the typed replacement for
- * the `(snapshot as { messages?: AgentMessage[] }).messages` cast. runAgent
- * stamps the log as a plain enumerable `messages` property (like `agentMeta`),
- * so it survives a JSON persist/resume round-trip; this accessor works on the
- * live settled snapshot and on a JSON-parsed persisted one alike. Returns `[]`
- * when no log was stamped (e.g. a default invoke-driven run).
+ * Renders a snapshot's state value as one deterministic string, so a log line,
+ * a progress field, or a test assertion reads the same on every run.
+ *
+ * - An atomic state is its own name: `'writing'`.
+ * - A nested state joins with dots: `{ review: { editing: 'draft' } }` →
+ *   `'review.editing.draft'`.
+ * - A parallel state brackets its regions, sorted by region name, so key order
+ *   never leaks into the string: `{ p: { left: 'x', right: { a: 'b' } } }` →
+ *   `'p:{left.x,right.a.b}'`.
+ *
+ * Prefer this over `String(snapshot.value)`, which renders every non-atomic
+ * value as `[object Object]`.
  *
- * The write path is `runAgent(..., { messages })`: an explicit seed that
- * overrides the resume snapshot's stamped log (fold in a user reply on
- * resume, or start a run with prior history).
+ * @example
+ * ```ts
+ * onTransition: (snapshot) => console.log(getStatePath(snapshot));
+ * ```
  */
-declare function getAgentMessages(snapshot: unknown): AgentMessage[];
+declare function getStatePath(snapshot: {
+  value: StateValue;
+  status?: string;
+} | StateValue): string;
 /**
  * Structural guard for a {@link StandardSchemaV1}: `true` when `value` carries
  * the `~standard` marker. Used to tell an already-schema'd tool `inputSchema`
@@ -1319,8 +1533,8 @@ interface SeamCall {
 interface SeamSlice {
   /** State values entered on this side of the seam, in order. */
   statePath: StateValue[];
-  /** Replayable log entries on this side of the seam, in order. */
-  events: AgentLogEntry[];
+  /** Root-machine transition events on this side of the seam, in order. */
+  events: TrajectoryEvent[];
 }
 /** Options for {@link runSeam}. */
 interface RunSeamOptions<TMachine extends AnyStateMachine> {
@@ -1349,7 +1563,7 @@ interface RunSeamOptions<TMachine extends AnyStateMachine> {
   /**
    * The executor for the seam — the real model, a candidate prompt, anything
    * request-shaped. Omit to run the seam scripted too: the whole seam run is
-   * then keyless and deterministic.
+   * then deterministic.
    */
   candidate?: AgentRequestExecutor;
   /**
@@ -1366,16 +1580,13 @@ interface RunSeamOptions<TMachine extends AnyStateMachine> {
    * Text slots are always owned by the routing.
    */
   executors?: Partial<AgentRequestExecutors>;
-  /** Passed through to `runAgent`: the deterministic idle-state predicate. */
-  isIdle?: RunAgentOptions<TMachine>["isIdle"];
   /** Passed through to `runAgent`: actor implementations merged onto the machine. */
   actors?: RunAgentOptions<TMachine>["actors"];
 }
 /** What {@link runSeam} returns: the seam's own answer, plus the run it caused. */
 interface RunSeamResult<TMachine extends AnyStateMachine> {
   /**
-   * The final `runAgent` result. Its `events` are the WHOLE run's log (every
-   * leg's entries), while `usage` accounts only for the last leg.
+   * The final `runAgent` result. `usage` accounts for the last leg.
    */
   result: RunAgentResult<TMachine>;
   /** What the seam call returned, or `undefined` when the run never reached it. */
@@ -1410,7 +1621,7 @@ interface RunSeamResult<TMachine extends AnyStateMachine> {
  * seam's own effect completion (the first `xstate.done.*`/`xstate.error.*`
  * entry appended after the call was made).
  *
- * @example Keyless: the seam is scripted too, so the whole thing runs offline.
+ * @example No API key: the seam is scripted too, so the whole thing runs offline.
  * ```ts
  * const run = await runSeam(emailDrafter, {
  *   scripts: { promptEvaluator: [vague, complete], emailDrafter: [draft] },
@@ -1429,76 +1640,4 @@ interface RunSeamResult<TMachine extends AnyStateMachine> {
  */
 declare function runSeam<TMachine extends AnyStateMachine>(machine: TMachine, options: RunSeamOptions<TMachine>): Promise<RunSeamResult<TMachine>>;
 //#endregion
-//#region src/durable.d.ts
-/** Options for {@link runDurableAgent}. */
-interface RunDurableAgentOptions<TMachine extends AnyStateMachine> extends Pick<ProvideExecutorsOptions<TMachine>, "actors" | "onChunk" | "onTrace"> {
-  /** Machine input for a FRESH run (ignored when `entries` has an init entry). */
-  input?: InputFrom<TMachine>;
-  /**
-   * The journal to resume from — the `entries` a previous
-   * {@link runDurableAgent} result returned (or any replay-compatible
-   * {@link AgentLogEntry} log with a reserved `@agent.init` first entry).
-   */
-  entries?: readonly AgentLogEntry[];
-  /** One external event to feed after the journal is folded (a user reply, a timer). */
-  event?: EventFromLogic<TMachine>;
-  /** Host executors, bound with {@link provideExecutors} semantics. */
-  executors?: AgentRequestExecutors;
-  /** Called with each entry as it is appended, for incremental persistence. */
-  onEntry?: (entry: AgentLogEntry) => void;
-  /**
-   * Settle `idle` when this returns true for the current snapshot even though
-   * children are still pending — for machines whose wait states keep a
-   * never-resolving invoke in flight (e.g. an unbound `agent.userInput`).
-   */
-  isIdle?: (snapshot: SnapshotFrom<TMachine>) => boolean;
-  /** Explicit machine version for entry stamping; defaults to the structural hash. */
-  machineVersion?: string;
-  /**
-   * Record replay-verification hashes on appended entries. Off by default:
-   * hashing replays the whole prefix per entry, which is quadratic in log
-   * length.
-   */
-  verification?: boolean;
-}
-/** The settled result of a {@link runDurableAgent} call. */
-type DurableAgentResult<TMachine extends AnyStateMachine> = {
-  /** The machine reached a final state. */status: "done";
-  output: OutputFrom<TMachine>;
-  snapshot: SnapshotFrom<TMachine>; /** The complete journal; replaying it reproduces this run. */
-  entries: AgentLogEntry[];
-} | {
-  /** The machine is waiting for an external event. Persist `entries`; resume with them plus `event`. */status: "idle";
-  snapshot: SnapshotFrom<TMachine>;
-  entries: AgentLogEntry[];
-};
-/**
- * Runs an agent machine as a durable execution: journal in, journal out.
- *
- * A fresh call starts from `input` and appends a reserved init entry; a
- * resume call folds `entries` through pure transitions first — invokes whose
- * completions are journaled are suppressed (their recorded results replay
- * instead of re-executing), while work that was in flight at the crash
- * re-executes live. After the journal, an optional `options.event` is
- * delivered. The call settles:
- *
- * - `done` when the machine reaches a final state, with `output`;
- * - `idle` when the frontier needs an external event the host has not
- *   supplied (no live work pending, or `isIdle` says the pending work is a
- *   human wait). Persist `entries` and call again with them later.
- *
- * ```ts
- * const first = await runDurableAgent(machine, { input, executors });
- * // ... persist first.entries; later, in a new process:
- * const next = await runDurableAgent(machine, {
- *   entries: first.entries,
- *   event: { type: "APPROVE" },
- *   executors,
- * });
- * ```
- *
- * @experimental Built on xstate's experimental `xstate/durable` entrypoint.
- */
-declare function runDurableAgent<TMachine extends AnyStateMachine>(machine: TMachine, options?: RunDurableAgentOptions<TMachine>): Promise<DurableAgentResult<TMachine>>;
-//#endregion
-export { AGENT_EVENT_SCHEMA_VERSION, AGENT_INIT_EVENT_TYPE, AGENT_TRACE_SCHEMA_VERSION, AGENT_USAGE_EVENT_TYPE, type AgentActorSession, type AgentCallUsage, type AgentDecisionExecutor, AgentDecisionExhaustedError, type AgentDecisionInput, type AgentDecisionRequest, type AgentEffect, type AgentEffectDiff, AgentError, type AgentEventDescriptor, AgentEventLogConflictError, type AgentEventLogDiff, type AgentEventLogStore, type AgentEventToolNameResolver, type AgentExecutorTextRequest, AgentIdleError, AgentIllegalResumeEventError, type AgentInputFrom, type AgentLintDiagnostic, AgentLintError, type AgentLintSeverity, type AgentLogEntry, type AgentLogPatchOperation, type AgentLogVerification, AgentMaxModelCallsExceededError, type AgentMessage, type AgentMessageInfo, type AgentModelRef, type AgentOutputMode, type AgentPathReport, type AgentPathTerminal, AgentReplayDivergenceError, AgentReplayMachineMismatchError, type AgentRequest, type AgentRequestExecutor, type AgentRequestExecutorInfo, type AgentRequestExecutorResult, type AgentRequestExecutors, type AgentRequestOptions, type AgentRequestSource, type AgentRun, type AgentRunMeta, type AgentSchemaPack, type AgentSchemas, type AgentSnapshotNode, type AgentSnapshotStore, AgentSnapshotVersionMismatchError, type AgentStateRequest, type AgentStepRequest, type AgentTextRequest, type AgentTool, type AgentToolChoice, type AgentToolDescriptor, type AgentToolExecute, type AgentTools, type AgentTraceEvent, type AgentUsage, type AgentUsageEvent, type AgentUsageEventPayload, type AgentUserInput, type AgentUserInputExecutor, type AgentWorkflowActionConfig, type AgentWorkflowActorConfig, type AgentWorkflowConfig, type AgentWorkflowInvokeConfig, type AgentWorkflowRequestConfig, type AgentWorkflowStateConfig, type AgentWorkflowTransitionConfig, type AiSdkShapedStreamResult, type AiSdkShapedTextResult, type AllowedEvents, type AssertAgentMachineOptions, type AssistantMessage, type CanReachResult, type ChosenEvent, type CreateReplayEntryOptions, type DecisionAttempt, type DecisionLogicConfig, type DurableAgentResult, type ExplorePathsOptions, type FilePart, type FromConfigOptions, type FromConfigResult, type GenerateResult, type GetAgentEffectsOptions, type GetSnapshotRequestsOptions, type ImagePart, type InferInput, type InferOutput, type InspectedActorRef, type JsonSerializableTraceEvent, type JsonValue, type LintAgentMachineOptions, type MatchTrajectoryOptions, NonSerializableAgentEventError, type PendingUserInput, type ProvideExecutorsOptions, type ReplayOptions, type ReplayResult, type ResolveDecisionOptions, type RunAgentErrorCause, type RunAgentOptions, type RunAgentResult, type RunDurableAgentOptions, type RunSeamOptions, type RunSeamResult, type SchemaCompiler, type ScriptedDecisionEntry, type ScriptedDecisionValue, type ScriptedExecutors, type ScriptedExecutorsScript, type ScriptedTextEntry, type ScriptedUserInputEntry, type SeamCall, type SeamRef, type SeamSlice, type SeamTurn, type SimulateAgentOptions, type SimulateAgentResult, type SimulationScript, type SimulationTrailEntry, type StandardSchemaV1, type StructuredOutputEnvelope, type SystemMessage, type TextLogic, type TextLogicConfig, type TextLogicExecuteArgs, type TextLogicExecutor, type TextPart, type ToolCallPart, type ToolMessage, type ToolResultPart, type TrajectoryEvent, type TrajectoryItem, type TrajectoryMatch, type TrajectoryMiss, type UserMessage, type WithAgentUsageEvent, appendMessages, assertAgentLogEntry, assertAgentMachine, assertEventLogStoreConformance, assertJsonSerializable, assistantMessage, bindRequestExecutor, buildEnvelopeSchema, canReach, createAgentActor, createAgentRun, createAgentSchemas, createInMemoryEventLogStore, createReplayEntry, createScriptedExecutors, createTextLogic, diffEventLogs, executeAgentRequest, explorePaths, generateResult, getAcceptedEvents, getAgentEffects, getAgentMessages, getAgentOutputMode, getAgentSchemas, getCallUsage, getJsonSchema, getJsonSchemaSync, getMachineStructuralHash, getSnapshotNodes, getSnapshotRequests, getStateMeta, initEntry, inspectTransitions, isStandardSchema, lintAgentMachine, matchesTrajectory, messagesSchema, parseAgentEvent, parseModelRef, parseOutput, parseStructuredEnvelope, provideExecutors, renderDecisionAttempts, replay, resolveDecision, runAgent, runDurableAgent, runSeam, serializeTraceEvent, setupAgent, simulateAgent, systemMessage, toolMessage, traceTransitions, userMessage };
+export { AGENT_EVENT_SCHEMA_VERSION, AGENT_INIT_EVENT_TYPE, AGENT_MESSAGES_EVENT_TYPE, AGENT_TRACE_SCHEMA_VERSION, AGENT_USAGE_EVENT_TYPE, type AgentCallUsage, type AgentDecisionExecutor, AgentDecisionExhaustedError, type AgentDecisionInput, type AgentDecisionRequest, AgentError, type AgentEventDescriptor, AgentEventLogConflictError, AgentEventLogError, type AgentEventLogStore, type AgentEventToolNameResolver, type AgentExecutorDecisionRequest, type AgentExecutorTextRequest, type AgentFinishReason, type AgentInitEvent, type AgentInputFrom, type AgentInteraction, type AgentInteractionDescriptor, type AgentInteractionEvent, type AgentInteractionEventMeta, type AgentInteractionMeta, AgentInvalidEventPayloadError, type AgentLintDiagnostic, AgentLintError, type AgentLintSeverity, type AgentLogEntry, type AgentLogInit, type AgentLogVerification, AgentMachineVersionMismatchError, AgentMaxModelCallsExceededError, type AgentMessage, type AgentMessagesEvent, type AgentMessagesEventPayload, type AgentModelRef, type AgentOutputMode, type AgentPathReport, type AgentPathTerminal, type AgentPersistedSnapshot, AgentReplayDivergenceError, type AgentRequest, type AgentRequestExecutor, type AgentRequestExecutorInfo, type AgentRequestExecutorResult, type AgentRequestExecutors, type AgentRequestOptions, type AgentRequestSource, type AgentRunMeta, type AgentSchemaPack, type AgentSchemas, AgentSnapshotDivergedError, type AgentStepRequest, type AgentStreamEvent, type AgentTextRequest, type AgentTool, type AgentToolChoice, type AgentToolDescriptor, type AgentToolExecute, type AgentTools, type AgentTraceEvent, type AgentTransitionHandler, AgentTruncatedError, AgentUnknownStateError, type AgentUsage, type AgentUsageEvent, type AgentUsageEventPayload, type AgentUserInput, type AgentUserInputExecutor, type AgentWorkflowActionConfig, type AgentWorkflowActorConfig, type AgentWorkflowConfig, type AgentWorkflowInvokeConfig, type AgentWorkflowRequestConfig, type AgentWorkflowStateConfig, type AgentWorkflowTransitionConfig, type AiSdkShapedStreamResult, type AiSdkShapedTextResult, type AllowedEvents, type AssertAgentMachineOptions, type AssistantMessage, type CanReachResult, type ChosenEvent, type ContextOf, type CreateDecisionRequestOptions, type CreateReplayEntryOptions, type DecisionAttempt, type DecisionLogic, type DecisionLogicConfig, type DoneActorEventOf, type EventLogStoreConformanceHarness, type EventOf, type ExplorePathsOptions, type FilePart, type FromConfigOptions, type FromConfigResult, type GetInteractionOptions, type ImagePart, type InferInput, type InferOutput, type InputOf, type InspectedActorRef, type JsonSerializableTraceEvent, type JsonValue, type LintAgentMachineOptions, type MatchTrajectoryOptions, type MetaOf, NonSerializableAgentEventError, type OutputOf, type PendingUserInput, type ProvideExecutorsOptions, type ReplayOptions, type ReplayResult, type RequestNamesOf, type ResolveDecisionOptions, type RunAgentErrorCause, type RunAgentLoopOptions, type RunAgentOptions, type RunAgentResult, type RunSeamOptions, type RunSeamResult, type SchemaCompiler, type ScriptedByName, type ScriptedDecisionEntry, type ScriptedDecisionValue, type ScriptedExecutors, type ScriptedExecutorsScript, type ScriptedTextEntry, type ScriptedUserInputEntry, type SeamCall, type SeamRef, type SeamSlice, type SeamTurn, type SimulateAgentOptions, type SimulateAgentResult, type SimulationScript, type SimulationTrailEntry, type SnapshotOf, type StandardSchemaV1, type StateValueOf, type StructuredOutputEnvelope, type SystemMessage, type TextLogic, type TextLogicConfig, type TextLogicExecuteArgs, type TextLogicExecutor, type TextPart, type ToolCallPart, type ToolMessage, type ToolResultPart, type TrajectoryEvent, type TrajectoryItem, type TrajectoryMatch, type TrajectoryMiss, type UserMessage, type WithAgentEvents, type WithAgentUsageEvent, agentCallOccurrence, appendMessages, assertAgentLogEntry, assertAgentMachine, assertEventLogStoreConformance, assertJsonSerializable, assistantMessage, bindRequestExecutor, buildEnvelopeSchema, canReach, createAgentSchemas, createDecisionLogic, createDecisionRequest, createInMemoryEventLogStore, createReplayEntry, createScriptedExecutors, createTextLogic, eventFromInteraction, executeAgentRequest, explorePaths, forkEventLog, getAcceptedEvents, getAgentOutputMode, getAgentSchemas, getCallFinishReason, getCallUsage, getInteraction, getJsonSchema, getJsonSchemaSync, getLogExecutionId, getMachineStructuralHash, getMessageText, getSnapshotStateHash, getStateMeta, getStatePath, getUsageFromEvents, initEntry, inspectTransitions, interactionMetaSchema, isAgentIdle, isAgentMessages, isStandardSchema, lintAgentMachine, matchesTrajectory, messagesSchema, parseAgentEvent, parseModelRef, parseOutput, parseStructuredEnvelope, provideExecutors, rebindActorSession, renderDecisionAttempts, replay, resolveDecision, runAgent, runAgentLoop, runAgentStream, runSeam, serializeTraceEvent, setupAgent, simulateAgent, systemMessage, toolMessage, traceTransitions, userMessage, validateReplayEntries };