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

package/dist/index.d.mts

@@ -1,9 +1,618 @@
-import { A as UserMessage, C as StandardSchemaV1, D as ToolMessage, E as ToolCallPart, O as ToolResultOutput, S as ProviderOptions, T as TextPart, _ as EventUnion, a as AgentTool, b as InferOutput, c as AgentToolExecute, d as AllowedEventPattern, f as AllowedEvents, g as EventPayload, h as DataContent, i as AgentSnapshotStore, k as ToolResultPart, l as AgentToolSchema, m as ChosenEvent, n as AgentEventSchemaInputMap, o as AgentToolChoice, p as AssistantMessage, r as AgentMessage, s as AgentToolDescriptor, t as AgentEventSchemaInput, u as AgentTools, v as FilePart, w as SystemMessage, x as NormalizedEventSchemas, y as ImagePart } from "./types-qm00QF91.mjs";
-import { A as AgentDecisionInput, B as renderDecisionAttempts, C as createTextLogic, D as parseOutput, E as parseModelRef, F as DecisionExhaustedError, G as AgentRequestSource, H as AgentEventDescriptor, I as DecisionLogic, J as matchesEventPattern, K as EVENT_TOOL_PREFIX, L as DecisionLogicConfig, M as AgentPlanInput, N as AgentPlanOutput, O as parseStructuredEnvelope, P as DecisionAttempt, R as PLAN_DONE_EVENT_TYPE, S as buildEnvelopeSchema, T as isStructuredOutputSchema, U as AgentEventToolNameResolver, V as resolveDecision, W as AgentRequestOptions, Y as parseAgentEvent, _ as TextLogicExecuteArgs, a as AgentRequestExecutorInfo, b as TextLogicOutput, c as AgentRequestMode, d as AiSdkShapedStreamResult, f as AiSdkShapedTextResult, g as TextLogicConfig, h as TextLogic, i as AgentRequestExecutor, j as AgentDecisionRequest, k as AgentDecisionExecutor, l as AgentTextRequest, m as StructuredOutputEnvelope, n as AgentModelRef, o as AgentRequestExecutorResult, q as getAcceptedEvents, r as AgentOutputMode, s as AgentRequestExecutors, t as AgentModelMap, u as AgentUserInput, v as TextLogicExecutor, w as getAgentOutputMode, x as bindRequestExecutor, y as TextLogicInput, z as ResolveDecisionOptions } from "./text-logic-C7WJpCIc.mjs";
-import { A as AgentSchemaPack, B as AgentWorkflowStateConfig, C as initialAgentStep, D as AgentMachine, E as transitionAgentStep, F as AgentWorkflowActionConfig, G as messagesSchema, H as FromConfigOptions, I as AgentWorkflowActorConfig, L as AgentWorkflowConfig, M as AgentStateNarrowing, N as createAgentSchemas, O as AgentMachineConfig, P as setupAgent, R as AgentWorkflowInvokeConfig, S as getAgentRequests, T as resolveAgentStep, U as SchemaCompiler, V as AgentWorkflowTransitionConfig, W as appendMessages, _ as AgentRequest, a as AgentUserInputExecutor, b as ResolveAgentRequestsOptions, c as PendingUserInput, d as SnapshotVersionMismatchError, f as inspectTransitions, g as AgentPlanRequest, h as AgentStateRequest, i as AgentTraceEvent, j as AgentSetupStateSchema, k as AgentRequestConfig, l as RunAgentOptions, m as runAgentToCompletion, n as AgentMessageInfo, o as IllegalResumeEventError, p as runAgent, r as AgentRunMeta, s as InspectedActorRef, t as AgentIdleError, u as RunAgentResult, v as AgentStep, w as resolveAgentRequests, x as executeAgentRequest, y as AgentStepRequest, z as AgentWorkflowRequestConfig } from "./run-agent-DzYJb3CK.mjs";
-import { a as getMachineStructuralHash, c as persistSnapshot, d as userMessage, f as validateSchemaSync, i as getJsonSchemaSync, l as systemMessage, n as getAgentMessages, o as getStateMeta, r as getJsonSchema, s as isStandardSchema, t as assistantMessage, u as toolMessage } from "./utils-Y6GDRGGE.mjs";
-import { AnyMachineSnapshot, AnyStateMachine } from "xstate";
+import { C as UserMessage, S as ToolResultPart, _ as StandardSchemaV1, a as AgentToolChoice, b as ToolCallPart, c as AgentTools, d as ChosenEvent, f as EventUnion, g as NormalizedEventSchemas, h as InferOutput, 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 SystemMessage, x as ToolMessage, y as TextPart } from "./types-_FXoFBGO.mjs";
+import { t as AgentError } from "./errors-C9rxnWbX.mjs";
+import { A as AgentDecisionInput, B as resolveDecision, C as createTextLogic, D as parseStructuredEnvelope, E as parseOutput, F as DecisionLogicConfig, G as getAcceptedEvents, H as AgentEventToolNameResolver, I as PLAN_DONE_EVENT_TYPE, K as parseAgentEvent, L as PlanLogic, M as AgentPlanInput, N as AgentPlanOutput, O as AgentDecisionExecutor, P as DecisionAttempt, R as ResolveDecisionOptions, S as buildEnvelopeSchema, T as parseModelRef, U as AgentRequestOptions, V as AgentEventDescriptor, W as AgentRequestSource, _ as TextLogic, a as AgentRequestExecutor, b as TextLogicExecutor, c as AgentRequestExecutors, d as AgentUsage, f as AgentUserInput, g as StructuredOutputEnvelope, h as BuiltinAgentActors, i as AgentOutputMode, j as AgentDecisionRequest, k as AgentDecisionExhaustedError, l as AgentRequestMode, m as AiSdkShapedTextResult, n as AgentModelMap, o as AgentRequestExecutorInfo, p as AiSdkShapedStreamResult, r as AgentModelRef, s as AgentRequestExecutorResult, t as AgentCallUsage, u as AgentTextRequest, v as TextLogicConfig, w as getAgentOutputMode, x as bindRequestExecutor, y as TextLogicExecuteArgs, z as renderDecisionAttempts } from "./text-logic-DjR5PUVz.mjs";
+import { A as AgentReplayDivergenceError, B as getCallUsage, C as AgentStateRequest, D as AgentEffectDiff, E as AgentEffect, F as ReplayOptions, G as AgentRequest, H as replay, I as ReplayResult, K as AgentStepRequest, L as createReplayEntry, M as AgentUsageEvent, N as CreateReplayEntryOptions, O as AgentEventLogDiff, P as GetAgentEffectsOptions, R as diffEventLogs, S as traceTransitions, T as AGENT_USAGE_EVENT_TYPE, U as verifyReplay, V as initEntry, W as AgentPlanRequest, _ as createAgentActor, a as AgentMessageInfo, b as runAgent, c as AgentTraceEvent, d as InspectedActorRef, f as JsonSerializableTraceEvent, g as RunAgentResult, h as RunAgentOptions, i as AgentIllegalResumeEventError, j as AgentReplayMachineMismatchError, k as AgentLogPatchOperation, l as AgentUserInputExecutor, m as RunAgentErrorCause, n as AgentActorSession, o as AgentRunMeta, p as PendingUserInput, q as executeAgentRequest, r as AgentIdleError, s as AgentSnapshotVersionMismatchError, t as AGENT_TRACE_SCHEMA_VERSION, u as GenerateResult, v as generateResult, w as AGENT_INIT_EVENT_TYPE, x as serializeTraceEvent, y as inspectTransitions, z as getAgentEffects } from "./run-agent-B1nBa7aV.mjs";
+import { a as AgentLogVerification, c as assertAgentLogEntry, d as createInMemoryEventLogStore, i as AgentLogEntry, l as assertEventLogStoreConformance, n as AgentEventLogConflictError, o as JsonValue, r as AgentEventLogStore, s as NonSerializableAgentEventError, t as AGENT_EVENT_SCHEMA_VERSION, u as assertJsonSerializable } from "./event-log-store-CriMgX1D.mjs";
+import { AnyActorLogic, AnyMachineSnapshot, AnySetupConfig, AnyStateMachine, AsyncActorLogic, EventFromLogic, EventObject, InputFrom, MachineContext, MetaObject, NonReducibleUnknown, SetupReturnFromConfig, SetupStateSchema, SnapshotFrom, StateValue } from "xstate";
 
+//#region src/messages.d.ts
+/**
+ * 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.
+ *
+ * @example
+ * ```ts
+ * on: {
+ *   USER_REPLIED: appendMessages(({ event }) => userMessage(event.text)),
+ * }
+ * ```
+ */
+declare function appendMessages<TContext extends {
+  messages: AgentMessage[];
+}, TEvent extends EventObject>(resolve: AgentMessage | AgentMessage[] | ((args: {
+  context: TContext;
+  event: TEvent;
+}) => AgentMessage | AgentMessage[])): (args: {
+  context: TContext;
+  event: TEvent;
+}) => {
+  context: {
+    messages: AgentMessage[];
+  };
+};
+/**
+ * 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`.
+ */
+declare const messagesSchema: StandardSchemaV1<AgentMessage[]>;
+//#endregion
+//#region src/workflow-config.d.ts
+type JsonSchemaObject = {
+  type?: string | string[];
+  properties?: Record<string, JsonSchemaObject>;
+  required?: string[];
+  items?: JsonSchemaObject;
+  enum?: unknown[];
+  const?: unknown;
+  additionalProperties?: unknown;
+  [key: string]: unknown;
+};
+/**
+ * Compiles a JSON Schema object (from an `AgentWorkflowConfig`) into a
+ * runtime `StandardSchemaV1` validator. `setupAgent.fromConfig(...)` calls
+ * this once per schema in the config (context/events/input/output/meta,
+ * request input/output) — bring your own engine (Ajv, @cfworker/json-schema,
+ * a compiled-Zod-from-JSON-Schema pipeline, ...). Core intentionally ships no
+ * JSON Schema engine.
+ */
+type SchemaCompiler = (jsonSchema: Record<string, unknown>, name: string) => StandardSchemaV1;
+/**
+ * Serializable JSON/YAML machine definition — the config a database, visual
+ * editor, or LLM could produce and hand to `setupAgent.fromConfig(config, {
+ * compileSchema })` to get back the same kind of `AnyStateMachine`
+ * TypeScript `setupAgent(...)` authoring would build. JS/TS authoring should
+ * use `setupAgent(...)` directly instead of this JSON form. Any `unknown`-
+ * typed field here (`model`, `guard`, action `params`, …) accepts either a
+ * literal JSON value or a `"{{ path.to.value }}"` template-expression string
+ * resolved against `{ context, event, input, output }` at machine-build/
+ * transition time — see the sibling `evaluateWorkflowConfigValue` lowering.
+ */
+interface AgentWorkflowConfig {
+  /** JSON Schema reference (`"$schema"`) editors attach to a config file. Ignored by the lowering. */
+  $schema?: string;
+  key?: string;
+  id?: string;
+  version?: string;
+  description?: string;
+  schemas?: {
+    input?: JsonSchemaObject;
+    context?: JsonSchemaObject;
+    events?: Record<string, JsonSchemaObject>;
+    emitted?: Record<string, JsonSchemaObject>;
+    output?: JsonSchemaObject;
+    meta?: JsonSchemaObject;
+  };
+  context?: Record<string, unknown>;
+  requests?: Record<string, AgentWorkflowRequestConfig>;
+  actors?: Record<string, AgentWorkflowActorConfig>;
+  initial: string;
+  states: Record<string, AgentWorkflowStateConfig>;
+  meta?: Record<string, unknown>;
+}
+/** A `requests` entry in {@link AgentWorkflowConfig} — the JSON equivalent of a `setupAgent({ requests })` `TextLogicConfig`. Fields beyond `input`/`output`/`tools`/`mode`/`description` are `unknown` because they accept template-expression strings (see {@link AgentWorkflowConfig}). */
+interface AgentWorkflowRequestConfig {
+  mode?: AgentRequestMode;
+  description?: string;
+  model: unknown;
+  system?: unknown;
+  prompt?: unknown;
+  messages?: unknown;
+  input: JsonSchemaObject;
+  output: JsonSchemaObject;
+  tools?: AgentTools;
+  toolChoice?: AgentToolChoice | unknown;
+  /** Opt into the structured-output envelope's `reasoning` field (see `AgentTextRequest.reasoning`). */
+  reasoning?: boolean;
+  temperature?: unknown;
+  maxOutputTokens?: unknown;
+  topP?: unknown;
+  topK?: unknown;
+  seed?: unknown;
+  stopSequences?: unknown;
+  metadata?: unknown;
+}
+/** An `actors` entry in {@link AgentWorkflowConfig} — declares a placeholder actor source (by key) with no host execution wired from JSON; provide it via `machine.provide({ actors })` after `setupAgent.fromConfig(...)`. */
+interface AgentWorkflowActorConfig {
+  input?: JsonSchemaObject;
+  output?: JsonSchemaObject;
+  description?: string;
+}
+/** A `states` entry in {@link AgentWorkflowConfig} — the JSON equivalent of an XState state node config. */
+interface AgentWorkflowStateConfig {
+  description?: string;
+  type?: "parallel" | "history" | "final" | "choice";
+  initial?: string;
+  states?: Record<string, AgentWorkflowStateConfig>;
+  choice?: AgentWorkflowTransitionConfig | AgentWorkflowTransitionConfig[];
+  invoke?: AgentWorkflowInvokeConfig | AgentWorkflowInvokeConfig[];
+  on?: Record<string, AgentWorkflowTransitionConfig | AgentWorkflowTransitionConfig[]>;
+  always?: AgentWorkflowTransitionConfig | AgentWorkflowTransitionConfig[];
+  onDone?: AgentWorkflowTransitionConfig | AgentWorkflowTransitionConfig[];
+  after?: Record<string, AgentWorkflowTransitionConfig | AgentWorkflowTransitionConfig[]>;
+  entry?: AgentWorkflowActionConfig | AgentWorkflowActionConfig[];
+  exit?: AgentWorkflowActionConfig | AgentWorkflowActionConfig[];
+  tags?: string[];
+  output?: unknown;
+  meta?: Record<string, unknown>;
+}
+/**
+ * An `invoke` entry in {@link AgentWorkflowStateConfig}. For `src:
+ * 'agent.decide'`, the chosen event is delivered automatically and handled by
+ * the state's `on` transitions — a decision has no output of its own, so an
+ * `onDone` there is always a config error and is rejected at
+ * `setupAgent.fromConfig(...)` time. `onError` handles retries-exhausted.
+ */
+interface AgentWorkflowInvokeConfig {
+  id?: string;
+  src: string;
+  input?: unknown;
+  onDone?: AgentWorkflowTransitionConfig | AgentWorkflowTransitionConfig[];
+  onError?: AgentWorkflowTransitionConfig | AgentWorkflowTransitionConfig[];
+  meta?: Record<string, unknown>;
+}
+/**
+ * A transition target in {@link AgentWorkflowConfig}
+ * (`on`/`always`/`onDone`/`after`/invoke `onDone`/`onError`) — the JSON
+ * equivalent of an XState transition config. A string `guard` containing
+ * `{{ ... }}` is a template expression evaluated as truthy/falsy; any other
+ * string is a named guard reference resolved against the `guards` passed to
+ * `setupAgent.fromConfig(config, { guards })` (unresolvable references throw
+ * at build time).
+ */
+interface AgentWorkflowTransitionConfig {
+  target?: string | string[];
+  guard?: unknown;
+  assign?: Record<string, unknown>;
+  actions?: AgentWorkflowActionConfig | AgentWorkflowActionConfig[];
+  description?: string;
+  reenter?: boolean;
+  meta?: Record<string, unknown>;
+}
+/** An `entry`/`exit`/transition `actions` entry in {@link AgentWorkflowConfig} — a bare context `assign`, an `emit`, or a named action `type` (with template-expression `params`) resolved against the `actions` passed to `setupAgent.fromConfig(config, { actions })`. */
+interface AgentWorkflowActionConfig {
+  type?: string;
+  params?: unknown;
+  assign?: Record<string, unknown>;
+  emit?: unknown;
+  [key: string]: unknown;
+}
+/**
+ * What `setupAgent.fromConfig(...)` returns: the built machine plus the
+ * schema pack compiled from the config's `schemas` (with `compileSchema`).
+ * The pack is what hosts need for the runtime work the machine's types can't
+ * do for a JSON-authored agent — e.g. validating an inbound raw event:
+ *
+ * @example
+ * ```ts
+ * const { machine, schemas } = setupAgent.fromConfig(config, { compileSchema });
+ * const event = parseAgentEvent(snapshot, raw, { events: schemas.events });
+ * ```
+ */
+interface FromConfigResult {
+  machine: AnyStateMachine;
+  /** Compiled `context`/`events`/`input`/`output`/`meta`/`emitted` schemas — the same pack `runAgent` executes this machine with. */
+  schemas: AgentSchemaPack<StandardSchemaV1<Record<string, unknown>>, Record<string, StandardSchemaV1>, StandardSchemaV1, StandardSchemaV1, StandardSchemaV1<MetaObject>>;
+}
+/** Options for `setupAgent.fromConfig(...)`. */
+interface FromConfigOptions {
+  /**
+   * Compile a JSON Schema from the config into a runtime validator. Bring
+   * your own engine (Ajv, @cfworker/json-schema, a compiled-Zod-from-JSON-Schema
+   * pipeline, ...). Core intentionally ships no JSON Schema engine.
+   */
+  compileSchema: SchemaCompiler;
+  /**
+   * Host guard implementations for named guard references in the config
+   * (`guard: "isFromHuman"`). Each is called with `{ context, event }` and
+   * returns a boolean. A named guard reference with no implementation here is
+   * a build-time error — a guard is never silently dropped.
+   */
+  guards?: Record<string, (args: {
+    context: any;
+    event: any;
+  }) => boolean>;
+  /**
+   * Host action implementations for named action types in the config
+   * (`{ type: "notify", params: ... }`). Each is called with the
+   * template-resolved `params` as its only argument — pull context/event data
+   * into `params` via `{{ ... }}` templates. A named action type with no
+   * implementation here is a build-time error.
+   */
+  actions?: Record<string, (params: any) => unknown>;
+}
+//#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 EventsOf<TEventSchemas extends AgentEventSchemaInputMap> = Constrain<EventUnion<TEventSchemas>, EventObject>;
+type SetupActors<TActors extends { [K in keyof TActors]: AnyActorLogic }> = { [K in keyof TActors]: TActors[K] extends AsyncActorLogic<infer TOutput, infer TInput> ? AsyncActorLogic<TOutput, TInput> : TActors[K] };
+type AgentSetupActors<TActors extends { [K in keyof TActors]: AnyActorLogic }, TEvent extends string = string, TModel extends string = string> = TActors & BuiltinAgentActors<TEvent, TModel>;
+/**
+ * A machine's full schema set — context, event payloads, machine input/
+ * output, and state/transition meta — as returned by {@link createAgentSchemas}
+ * and retained on `setupAgent(...)`'s `result.schemas` for runtime
+ * validation (e.g. by the step path to validate `initialAgentStep` input, or
+ * by `getAcceptedEvents` to attach event payload schemas). Unlike
+ * `AgentSchemaConfig` (the input to `createAgentSchemas`), every field here
+ * is required — `events`/`input`/`output`/`meta` default to empty/unknown
+ * schemas when not supplied.
+ */
+interface AgentSchemaPack<TContextSchema extends StandardSchemaV1<Record<string, unknown>> = StandardSchemaV1<Record<string, unknown>>, TEventSchemas extends AgentEventSchemaInputMap = AgentEventSchemaInputMap, TInputSchema extends StandardSchemaV1 = StandardSchemaV1<NonReducibleUnknown>, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1<NonReducibleUnknown>, TMetaSchema extends StandardSchemaV1 = StandardSchemaV1<MetaObject>, TEmittedSchemas extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>> {
+  context: TContextSchema;
+  events: NormalizedEventSchemas<TEventSchemas>;
+  input: TInputSchema;
+  output: TOutputSchema;
+  meta: TMetaSchema;
+  /** Schemas for events the machine emits (`enq.emit(...)`), keyed by event type — they type `enq.emit` in the machine and the `on` handlers of {@link runAgent}. Optional: omitted means emitted events stay untyped. */
+  emitted?: TEmittedSchemas;
+}
+type AgentSchemaConfig<TContextSchema extends StandardSchemaV1<Record<string, unknown>>, TEventSchemas extends AgentEventSchemaInputMap, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TEmittedSchemas extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>> = {
+  context: TContextSchema;
+  events?: TEventSchemas;
+  input?: TInputSchema;
+  output?: TOutputSchema;
+  meta?: TMetaSchema;
+  emitted?: TEmittedSchemas;
+};
+/**
+ * The payload of the reserved `'@agent.usage'` event — {@link AgentUsageEvent}
+ * without its `type`. It is what a machine's `'@agent.usage'` handler receives
+ * alongside `type`, since event schemas describe payloads only.
+ */
+type AgentUsageEventPayload = Omit<AgentUsageEvent, "type">;
+/**
+ * An authored event schema map with the reserved `'@agent.usage'` entry added —
+ * every agent machine's event union includes it, so `on: { '@agent.usage': … }`
+ * 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> & {
+  [AGENT_USAGE_EVENT_TYPE]: StandardSchemaV1<AgentUsageEventPayload>;
+};
+/**
+ * Builds a machine's {@link AgentSchemaPack} from a partial schema
+ * declaration — only `context` is required; `events`/`input`/`output`/`meta`
+ * default to empty/unknown schemas when omitted. Pass the result as
+ * `setupAgent({ schemas })`'s `schemas` (or spread the individual fields
+ * directly into `setupAgent({ context, events, ... })` — both forms are
+ * accepted).
+ */
+declare function createAgentSchemas<TContextSchema extends StandardSchemaV1<Record<string, unknown>>, TEventSchemas extends AgentEventSchemaInputMap = {}, TInputSchema extends StandardSchemaV1 = StandardSchemaV1<NonReducibleUnknown>, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1<NonReducibleUnknown>, TMetaSchema extends StandardSchemaV1 = StandardSchemaV1<MetaObject>, TEmittedSchemas extends Record<string, StandardSchemaV1> = {}>(schemas: AgentSchemaConfig<TContextSchema, TEventSchemas, TInputSchema, TOutputSchema, TMetaSchema, TEmittedSchemas>): AgentSchemaPack<TContextSchema, WithAgentUsageEvent<TEventSchemas>, TInputSchema, TOutputSchema, TMetaSchema, TEmittedSchemas>;
+type AgentRequestSchemaMap = Record<string, {
+  input?: StandardSchemaV1;
+  output?: StandardSchemaV1;
+}>;
+type ResolvedRequestSchema<TSchema, TFallback> = [NonNullable<TSchema>] extends [never] ? TFallback : [NonNullable<TSchema>] extends [StandardSchemaV1] ? NonNullable<TSchema> : TFallback;
+type RequestInputSchema<TSchemas extends {
+  input?: StandardSchemaV1;
+}> = ResolvedRequestSchema<TSchemas["input"], StandardSchemaV1<undefined>>;
+type RequestOutputSchema<TSchemas extends {
+  output?: StandardSchemaV1;
+}> = ResolvedRequestSchema<TSchemas["output"], StandardSchemaV1<string>>;
+type AgentRequestInput<TRequestSchemas extends AgentRequestSchemaMap, TModel extends string = string> = { [K in keyof TRequestSchemas]: Omit<TextLogicConfig<RequestInputSchema<TRequestSchemas[K]>, RequestOutputSchema<TRequestSchemas[K]>, Record<string, unknown>, TModel>, "schemas"> & {
+  schemas: TRequestSchemas[K];
+} };
+type RequestActors<TRequestSchemas extends AgentRequestSchemaMap> = { [K in keyof TRequestSchemas]: TextLogic<RequestInputSchema<TRequestSchemas[K]>, RequestOutputSchema<TRequestSchemas[K]>> };
+type AgentAllActors<TActors extends { [K in keyof TActors]: AnyActorLogic }, TRequestSchemas extends AgentRequestSchemaMap> = TActors & RequestActors<TRequestSchemas>;
+type AgentSetupEventsSchema<TEventSchemas extends AgentEventSchemaInputMap> = {
+  events: NormalizedEventSchemas<WithAgentUsageEvent<TEventSchemas>>;
+};
+type AgentSetupEmittedSchema<TEmittedSchemas extends Record<string, StandardSchemaV1>> = [keyof TEmittedSchemas] extends [never] ? {} : {
+  emitted: TEmittedSchemas;
+};
+type AgentSetupXStateConfig<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>> = {
+  schemas: {
+    context: TContextSchema;
+    input: TInputSchema;
+    output: TOutputSchema;
+    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>>>;
+  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>> = ({
+  schemas: AgentSchemaPack<TContextSchema, TEventSchemas, TInputSchema, TOutputSchema, TMetaSchema, TEmittedSchemas>;
+} | AgentSchemaConfig<TContextSchema, TEventSchemas, TInputSchema, TOutputSchema, TMetaSchema, TEmittedSchemas>) & {
+  models?: TModels;
+  actors?: TActors;
+  /**
+   * 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.
+   */
+  states?: TStateSchemas;
+  requests?: AgentRequestInput<TRequestSchemas, AgentModelRef<TModels>>;
+  actions?: NonNullable<AnySetupConfig["actions"]>;
+  guards?: NonNullable<AnySetupConfig["guards"]>;
+  delays?: NonNullable<AnySetupConfig["delays"]>;
+  /**
+   * Detects a snapshot that is an INTENTIONAL wait for an external event (a
+   * human approval, an inbound webhook, …) — the machine's own declaration of
+   * what "suspended" 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({ isSuspended })` 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`.
+   */
+  isSuspended?: (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>>>;
+/**
+ * The object returned by {@link setupAgent}: an xstate `setup(...)` result
+ * (`createMachine`, `assign`, …) extended with `schemas` (the resolved
+ * {@link AgentSchemaPack}), `models`, `requests` (the built request actors),
+ * and {@link appendMessages}. Machines created here are registered so
+ * `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"> & {
+  /**
+   * Creates the agent machine — XState's own `createMachine`, plus: the
+   * machine is registered so step helpers and {@link runAgent} can resolve
+   * its schemas/actors without re-passing them, and a single final state's
+   * `output` is copied to the machine root when the root declares none.
+   */
+  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>>>>;
+};
+/**
+ * Schema-first `setup(...)` for agent machines — the standard entry point
+ * for authoring a machine (the blueprint) that this library then runs (via
+ * {@link runAgent} or the step helpers) against host-supplied model/decision
+ * executors. Context, events, machine input, machine output, and
+ * state/transition meta are all standard schemas — no `{} as Type` casts —
+ * and are retained on `result.schemas` for runtime validation. Also
+ * registers the `agent.generateText`/`agent.streamText`/`agent.userInput`/
+ * `agent.decide`/`agent.plan` builtin actors and lowers `requests`/`actors` into the
+ * machine's actor sources. The result is the xstate `setup(...)` object with
+ * a wrapped `result.createMachine(...)` plus `result.schemas`/`models`/
+ * `requests`/`appendMessages` attached. Also has a
+ * `setupAgent.fromConfig(...)` namespace member for building a machine from
+ * a serializable {@link AgentWorkflowConfig} instead of this TS API.
+ *
+ * @example
+ * ```ts
+ * const schemas = createAgentSchemas({
+ *   context: z.object({ topic: z.string(), joke: z.string().nullable() }),
+ *   input: z.object({ topic: z.string() }),
+ *   output: z.object({ joke: z.string() }),
+ * });
+ *
+ * const agent = setupAgent({
+ *   schemas,
+ *   actors: { tellJoke },
+ * });
+ *
+ * const jokeMachine = agent.createMachine({
+ *   context: ({ input }) => ({ topic: input.topic, joke: null }),
+ *   initial: 'telling',
+ *   states: {
+ *     telling: {
+ *       invoke: {
+ *         id: 'joke',
+ *         src: 'tellJoke',
+ *         input: ({ context }) => ({ topic: context.topic }),
+ *         onDone: ({ output }) => ({ target: 'done', context: { joke: output } }),
+ *       },
+ *     },
+ *     done: { type: 'final', output: ({ context }) => ({ joke: context.joke ?? '' }) },
+ *   },
+ * });
+ * ```
+ */
+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 namespace setupAgent {
+  /**
+   * Builds a state machine from a serializable {@link AgentWorkflowConfig}
+   * (JSON/YAML) instead of the TypeScript `setupAgent(...)` API — the same
+   * kind of machine a database, visual editor, or LLM could produce and hand
+   * back. Requires a `compileSchema` (see {@link FromConfigOptions}) since
+   * the library bundles no JSON Schema engine itself; bring Ajv,
+   * @cfworker/json-schema, or another compiler that returns Standard Schema.
+   *
+   * Returns the built `machine` plus the compiled `schemas` pack (context,
+   * events, input, output, meta, emitted) — a JSON-authored agent has no
+   * TypeScript types, so hosts need the runtime schemas for things like
+   * validating an inbound raw event with `parseAgentEvent`.
+   *
+   * @example
+   * ```ts
+   * const { machine, schemas } = setupAgent.fromConfig(workflowConfig, {
+   *   compileSchema,
+   * });
+   * const result = await runAgent(machine, { input: { ticket }, executors: { generateText, decide } });
+   * const event = parseAgentEvent(result.snapshot, raw, { events: schemas.events });
+   * ```
+   */
+  function fromConfig(config: AgentWorkflowConfig, options: FromConfigOptions): FromConfigResult;
+}
+//#endregion
+//#region src/agent-run.d.ts
+/**
+ * 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.
+ */
+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>>;
+  /**
+   * 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.
+   */
+  result: Promise<RunAgentResult<TMachine>>;
+}
+/**
+ * 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.
+ *
+ * Semantics:
+ *
+ * 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}.
+ */
+declare function createAgentRun<TMachine extends AnyStateMachine>(machine: TMachine, options: RunAgentOptions<TMachine>): AgentRun<TMachine>;
+//#endregion
+//#region src/provide-executors.d.ts
+/** Options for {@link provideExecutors}. */
+interface ProvideExecutorsOptions<TMachine extends AnyStateMachine = AnyStateMachine> {
+  /**
+   * Extra actor-source overrides merged onto the machine BEFORE binding — the
+   * same shape as `machine.provide({ actors })`. Use it to supply the
+   * `agent.userInput` handler, a custom non-agent actor, or to shadow an agent
+   * source with your own executor-bound logic. Merged first, so an override
+   * that already carries its own executor is left untouched by the binding pass.
+   */
+  actors?: Record<string, AnyActorLogic>;
+  /** Chunk sink threaded to every bound `mode: 'stream'` text source. */
+  onChunk?: (chunk: string) => void;
+  /**
+   * A single ordered stream of request-level trace events
+   * (`request.start`/`request.end`/`request.error`/`stream.chunk`) with the
+   * SAME versioned envelope {@link runAgent} emits. Because one bound machine can
+   * back many concurrent root actors, envelope state (`runId`, monotonic `seq`)
+   * is minted per ROOT actor at runtime — two concurrent actors get distinct
+   * `runId`s and independent `seq`. Pair with {@link traceTransitions} on the
+   * actor's `inspect` to fold `machine.transition` events into the same stream.
+   * Unlike `runAgent` there are NO `run.start`/`run.end` events (no run
+   * boundary).
+   */
+  onTrace?: (event: AgentTraceEvent<TMachine>) => void;
+}
+/**
+ * Binds a machine's agent actor sources to a set of host `executors` in one
+ * call, returning a `machine.provide(...)`-ed copy ready for a plain
+ * `createActor(...)` — the uncontrolled-mode counterpart to {@link runAgent}.
+ * No run loop, no idle settling: the returned machine drives itself, so
+ *
+ * ```ts
+ * const actor = createActor(provideExecutors(machine, { generateText, decide }), { input });
+ * actor.start();
+ * ```
+ *
+ * behaves like a normal XState actor whose agent invokes now reach real models.
+ *
+ * Binding pass over `machine.sources.actors` (after merging
+ * `options.actors`):
+ * - `mode: 'generate'` text source → `executors.generateText`
+ * - `mode: 'stream'` text source → `executors.streamText`
+ * - decision / `agent.decide` source → `executors.decide` (snapshot-driven
+ *   candidate events, guard `canTake`, and auto-delivery of the chosen event,
+ *   mirroring `runAgent` but without its model-call counting)
+ * - `agent.plan` source → `executors.decide` (iterated, same semantics)
+ *
+ * Pass `options.onTrace` to observe request-level trace events (identical in
+ * shape to `runAgent`'s); pair it with {@link traceTransitions} on the actor's
+ * `inspect` to also capture `machine.transition` events in the same stream.
+ *
+ * A source that already carries its own executor (`.withExecutor(...)`) is left
+ * as-is. `agent.userInput` is left UNBOUND — an uncontrolled host handles idle
+ * itself, so supply a handler via `options.actors` if the machine uses it.
+ * Non-agent actors are untouched.
+ *
+ * Throws at bind time if a source needs an executor kind that `executors` does
+ * not provide.
+ *
+ * v1 does NOT descend into invoked child state machines: a string-keyed child
+ * machine source is left untouched, so a child with its own agent invokes needs
+ * its own `provideExecutors(...)` (or `runAgent`, which does rebind children).
+ */
+declare function provideExecutors<TMachine extends AnyStateMachine>(machine: TMachine, executors: AgentRequestExecutors, options?: ProvideExecutorsOptions<TMachine>): TMachine;
+//#endregion
 //#region src/verify.d.ts
 /** Severity of an {@link AgentLintDiagnostic}. `error` findings fail CI/the CLI; `warning`s are advisory. */
 type AgentLintSeverity = "error" | "warning";
@@ -13,7 +622,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" | "missing-final";
+  code: "unreachable-state" | "decide-without-events" | "unserializable-context" | "direct-object-src" | "final-without-output" | "final-output-reads-event" | "undeclared-event" | "missing-final";
   severity: AgentLintSeverity;
   /** State path (`parent.child`) or config pointer (e.g. `(root)`, `context`) the finding is about. */
   path: string;
@@ -52,8 +661,8 @@ interface AssertAgentMachineOptions extends LintAgentMachineOptions {
  * `diagnostics` holds the findings; the message lists them one per finding,
  * so a test runner's failure output reads like the CLI's lint report.
  */
-declare class AgentLintError extends Error {
-  diagnostics: AgentLintDiagnostic[];
+declare class AgentLintError extends AgentError {
+  readonly diagnostics: AgentLintDiagnostic[];
   constructor(machineId: string, diagnostics: AgentLintDiagnostic[]);
 }
 /**
@@ -78,13 +687,13 @@ declare function assertAgentMachine(machine: AnyStateMachine, options?: AssertAg
  *   `setupAgent({ requests })` key, or `agent.generateText`/`agent.streamText`).
  * - `decisions` — the {@link ChosenEvent} to apply for a decision request,
  *   keyed by decision src (usually `agent.decide`).
- * - `userInput` — output values for `agent.userInput` invokes, keyed by src
- *   (usually `agent.userInput`).
+ * - `invokes` — output values for scripted invokes (notably `agent.userInput`,
+ *   and any other actor whose output must be canned), keyed by src.
  */
 interface SimulationScript {
   text?: Record<string, unknown[]>;
   decisions?: Record<string, ChosenEvent[]>;
-  userInput?: Record<string, unknown[]>;
+  invokes?: Record<string, unknown[]>;
 }
 /** One entry in a {@link SimulateAgentResult.trail}: the state after this step, plus what drove the step. */
 interface SimulationTrailEntry {
@@ -209,4 +818,388 @@ interface CanReachResult {
  */
 declare function canReach(machine: AnyStateMachine, statePath: string, options?: ExplorePathsOptions): Promise<CanReachResult>;
 //#endregion
-export { type AgentDecisionExecutor, type AgentDecisionInput, type AgentDecisionRequest, type AgentEventDescriptor, type AgentEventSchemaInput, type AgentEventSchemaInputMap, type AgentEventToolNameResolver, AgentIdleError, type AgentLintDiagnostic, AgentLintError, type AgentLintSeverity, type AgentMachine, type AgentMachineConfig, type AgentMessage, type AgentMessageInfo, type AgentModelMap, type AgentModelRef, type AgentOutputMode, type AgentPathReport, type AgentPathTerminal, type AgentPlanInput, type AgentPlanOutput, type AgentPlanRequest, type AgentRequest, type AgentRequestConfig, type AgentRequestExecutor, type AgentRequestExecutorInfo, type AgentRequestExecutorResult, type AgentRequestExecutors, type AgentRequestMode, type AgentRequestOptions, type AgentRequestSource, type AgentRunMeta, type AgentSchemaPack, type AgentSetupStateSchema, type AgentSnapshotStore, type AgentStateNarrowing, type AgentStateRequest, type AgentStep, type AgentStepRequest, type AgentTextRequest, type AgentTool, type AgentToolChoice, type AgentToolDescriptor, type AgentToolExecute, type AgentToolSchema, type AgentTools, type AgentTraceEvent, type AgentUserInput, type AgentUserInputExecutor, type AgentWorkflowActionConfig, type AgentWorkflowActorConfig, type AgentWorkflowConfig, type AgentWorkflowInvokeConfig, type AgentWorkflowRequestConfig, type AgentWorkflowStateConfig, type AgentWorkflowTransitionConfig, type AiSdkShapedStreamResult, type AiSdkShapedTextResult, type AllowedEventPattern, type AllowedEvents, type AssertAgentMachineOptions, type AssistantMessage, type CanReachResult, type ChosenEvent, type DataContent, type DecisionAttempt, DecisionExhaustedError, type DecisionLogic, type DecisionLogicConfig, EVENT_TOOL_PREFIX, type EventPayload, type EventUnion, type ExplorePathsOptions, type FilePart, type FromConfigOptions, IllegalResumeEventError, type ImagePart, type InferOutput, type InspectedActorRef, type LintAgentMachineOptions, type NormalizedEventSchemas, PLAN_DONE_EVENT_TYPE, type PendingUserInput, type ProviderOptions, type ResolveAgentRequestsOptions, type ResolveDecisionOptions, type RunAgentOptions, type RunAgentResult, type SchemaCompiler, type SimulateAgentOptions, type SimulateAgentResult, type SimulationScript, type SimulationTrailEntry, SnapshotVersionMismatchError, type StandardSchemaV1, type StructuredOutputEnvelope, type SystemMessage, type TextLogic, type TextLogicConfig, type TextLogicExecuteArgs, type TextLogicExecutor, type TextLogicInput, type TextLogicOutput, type TextPart, type ToolCallPart, type ToolMessage, type ToolResultOutput, type ToolResultPart, type UserMessage, appendMessages, assertAgentMachine, assistantMessage, bindRequestExecutor, buildEnvelopeSchema, canReach, createAgentSchemas, createTextLogic, executeAgentRequest, explorePaths, getAcceptedEvents, getAgentMessages, getAgentOutputMode, getAgentRequests, getJsonSchema, getJsonSchemaSync, getMachineStructuralHash, getStateMeta, initialAgentStep, inspectTransitions, isStandardSchema, isStructuredOutputSchema, lintAgentMachine, matchesEventPattern, messagesSchema, parseAgentEvent, parseModelRef, parseOutput, parseStructuredEnvelope, persistSnapshot, renderDecisionAttempts, resolveAgentRequests, resolveAgentStep, resolveDecision, runAgent, runAgentToCompletion, setupAgent, simulateAgent, systemMessage, toolMessage, transitionAgentStep, userMessage, validateSchemaSync };
+//#region src/trajectory.d.ts
+/** An event-shaped trajectory item: anything with a string `type`. */
+interface TrajectoryEvent {
+  type: string;
+  [key: string]: unknown;
+}
+/**
+ * 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,
+ * - a machine snapshot, whose `value` is used.
+ */
+type TrajectoryItem = StateValue | AgentLogEntry | TrajectoryEvent | {
+  value: StateValue;
+};
+/** Options for {@link matchesTrajectory}. */
+interface MatchTrajectoryOptions {
+  /**
+   * Require the trajectories to be equal: same length, item for item. Default
+   * `false` — expected items must appear in `actual` in order, gaps allowed.
+   */
+  exact?: boolean;
+}
+/** The first expected item that could not be found. */
+interface TrajectoryMiss {
+  /** Its position in `expected`. */
+  index: number;
+  /** The expected item itself. */
+  expected: TrajectoryItem;
+  /** Where the search for it started in `actual` (everything before was already consumed). */
+  searchedFrom: number;
+}
+/**
+ * The result of {@link matchesTrajectory}: a boolean for tests, plus enough
+ * detail for a scorer's partial credit and a failure message's diagnosis.
+ */
+interface TrajectoryMatch {
+  /** Every expected item was found, in order (and, in `exact` mode, nothing else). */
+  matched: boolean;
+  /** How many expected items were matched before the first miss. */
+  matchedCount: number;
+  /** `expected.length`, so a scorer can compute its own ratio. */
+  expectedCount: number;
+  /** Partial credit, 0..1. `1` for an empty expectation. */
+  score: number;
+  /** Absent when `matched`. */
+  firstMiss?: TrajectoryMiss;
+}
+/**
+ * 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);
+ * items are compared by shape, so `['prompting', 'drafting']` scores a state
+ * path and `['PROMPT_SUBMITTED', 'SEND']` scores an event log with the same
+ * call.
+ *
+ * Semantics are an ordered subsequence: every expected item must appear in
+ * `actual`, in order, with gaps allowed. Pass `{ exact: true }` to require
+ * equality instead.
+ *
+ * @example Trajectory assertions in a test
+ * ```ts
+ * const statePath: unknown[] = [];
+ * const result = await runAgent(machine, {
+ *   input,
+ *   executors,
+ *   onTransition: (snapshot) => statePath.push(snapshot.value),
+ * });
+ *
+ * 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);
+ * ```
+ *
+ * @example Partial credit in an eval scorer
+ * ```ts
+ * const match = matchesTrajectory(output.statePath, expected.statePath);
+ * return { name: 'state_path', score: match.score, metadata: { ...match.firstMiss } };
+ * ```
+ */
+declare function matchesTrajectory(actual: readonly unknown[], expected: readonly TrajectoryItem[], options?: MatchTrajectoryOptions): TrajectoryMatch;
+//#endregion
+//#region src/scripted-executors.d.ts
+/**
+ * A scripted `decide` answer: either the {@link ChosenEvent} itself (an object
+ * with a string `type`), or the executor envelope `{ event, reason?, usage? }`
+ * when the entry also reports a `reason` or token `usage`.
+ */
+type ScriptedDecisionValue = ChosenEvent | {
+  event: ChosenEvent;
+  reason?: string;
+  usage?: AgentCallUsage;
+  [key: string]: unknown;
+};
+/**
+ * One entry in the `decisions` queue: a scripted 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
+ * object a structured request declares), or a function of the
+ * {@link AgentTextRequest} returning one.
+ *
+ * An entry is taken as the raw executor envelope (instead of the value itself)
+ * only when its OWN keys are an `output` plus, optionally, `usage`/`raw` —
+ * that is how an entry reports token `usage`. Anything else, including an
+ * object that merely happens to have an `output` key alongside its own data
+ * (`{ output: 'draft', confidence: 0.9 }`), is the output value. For a
+ * structured request whose declared output is exactly `{ output }` (or
+ * `{ output, usage }`), wrap it once more: `{ output: { output: '…' } }`.
+ */
+type ScriptedTextEntry = ((request: AgentTextRequest, info?: AgentRequestExecutorInfo) => unknown) | string | number | boolean | null | object;
+/** The script {@link createScriptedExecutors} plays back. */
+interface ScriptedExecutorsScript {
+  /** Answers for `decide` (and `agent.plan`) requests, consumed in order. */
+  decisions?: ScriptedDecisionEntry[];
+  /** Answers for text requests, consumed in order. `generateText` and `streamText` share this one queue. */
+  text?: ScriptedTextEntry[];
+}
+/**
+ * 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.
+ *
+ * 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`.
+ *
+ * @example
+ * ```ts
+ * const result = await runAgent(moderationMachine, {
+ *   input: { comment: 'honestly this update is terrible', trust: 20 },
+ *   executors: createScriptedExecutors({
+ *     decisions: [{ type: 'FLAG', reason: 'Borderline tone.' }],
+ *   }),
+ * });
+ * ```
+ *
+ * @example Dynamic entries
+ * ```ts
+ * createScriptedExecutors({
+ *   text: [(request) => `Draft about ${request.prompt}`],
+ *   decisions: [(request) => ({ type: request.events[0]!.type })],
+ * });
+ * ```
+ */
+declare function createScriptedExecutors(script?: ScriptedExecutorsScript): Required<AgentRequestExecutors>;
+//#endregion
+//#region src/seam.d.ts
+/**
+ * Which model call is under test: the Nth call addressed either by request
+ * `name` (the `setupAgent({ requests })` key or `createTextLogic({ name })`,
+ * the better developer handle) or by `model` key (the `defineModels` key) for
+ * requests that carry no name.
+ */
+type SeamRef = {
+  /** The request's registered `name`. */request: string;
+  model?: undefined; /** 0-based occurrence among the calls matching this key. Default `0`. */
+  occurrence?: number;
+} | {
+  /** The `defineModels` key the request names. */model: string;
+  request?: undefined; /** 0-based occurrence among the calls matching this key. Default `0`. */
+  occurrence?: number;
+};
+/**
+ * One idle pause, handed to {@link RunSeamOptions.respond} so the simulated
+ * user answers off the machine's own state rather than a fixed transcript — a
+ * live seam may branch differently, and a reactive policy scores that run
+ * instead of crashing on it.
+ */
+interface SeamTurn<TMachine extends AnyStateMachine> {
+  /** The idle snapshot to answer. */
+  snapshot: SnapshotFrom<TMachine>;
+  /** Its state value, for a `switch` on flat machines. */
+  state: StateValue;
+  /** The merged `meta` of the active state(s) — e.g. a declared `interaction`. */
+  meta: Record<string, unknown>;
+  /** 0-based index of this pause within the run. */
+  turn: number;
+  /** The `idle` result that produced the pause. */
+  result: RunAgentResult<TMachine>;
+}
+/** One side of the seam: a trajectory pair ready for `matchesTrajectory`. */
+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[];
+}
+/** Options for {@link runSeam}. */
+interface RunSeamOptions<TMachine extends AnyStateMachine> {
+  /** Machine input, passed straight through to `runAgent`. */
+  input?: InputFrom<TMachine>;
+  /**
+   * The call plan: scripted answers per key, consumed in order. A key is a
+   * request `name` when one is scripted under it, else a `model` key, so a
+   * machine whose requests are named routes by name and an unnamed one routes
+   * by model.
+   *
+   * Entries follow {@link ScriptedTextEntry} conventions (a value, an
+   * `{ output, usage? }` envelope, or a function of the request). The LAST
+   * entry of a queue repeats, so a live seam that sends the run down a longer
+   * branch still finds an answer instead of running dry.
+   */
+  scripts?: Record<string, ScriptedTextEntry[]>;
+  /** The call under test. */
+  seam: SeamRef;
+  /**
+   * 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.
+   */
+  candidate?: AgentRequestExecutors["generateText"];
+  /**
+   * The simulated user. Called at every idle pause; return the event to send,
+   * or `null`/`undefined` to stop the run there. Omitted, the run stops at the
+   * first idle pause.
+   */
+  respond?: (turn: SeamTurn<TMachine>) => EventFromLogic<TMachine> | null | undefined;
+  /** Maximum idle pauses to answer before stopping. Default `12`. */
+  maxTurns?: number;
+  /**
+   * Base executors merged UNDER the seam routing — supply `decide` (e.g. from
+   * `createScriptedExecutors({ decisions })`) for a machine that also decides.
+   * Text slots are always owned by the routing.
+   */
+  executors?: Partial<AgentRequestExecutors>;
+  /** Passed through to `runAgent`: the deterministic idle-state predicate. */
+  isSuspended?: RunAgentOptions<TMachine>["isSuspended"];
+  /** 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.
+   */
+  result: RunAgentResult<TMachine>;
+  /** What the seam call returned, or `undefined` when the run never reached it. */
+  seamOutput: unknown;
+  /** Model calls made before the seam, or `-1` when the run never reached it. */
+  callsBeforeSeam: number;
+  /** Everything up to the seam's own effect completion. */
+  before: SeamSlice;
+  /**
+   * Everything from the seam's own effect completion onward — the branch the
+   * seam caused, and the score. Empty when the run never reached the seam.
+   */
+  after: SeamSlice;
+}
+/**
+ * Runs a machine end to end with one model call under test, and slices the run
+ * at that call.
+ *
+ * The `before`/`after` slices are the point: `after.statePath` is the branch
+ * the seam chose and `after.events` is the same question against the durable
+ * log, both ready for `matchesTrajectory`. The state slice splits where the
+ * state path stood when the seam answered; the event slice splits at the
+ * 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.
+ * ```ts
+ * const run = await runSeam(emailDrafter, {
+ *   scripts: { promptEvaluator: [vague, complete], emailDrafter: [draft] },
+ *   seam: { request: 'evaluatePrompt' },
+ *   respond: ({ state }) => (state === 'prompting' ? { type: 'PROMPT_SUBMITTED', prompt } : null),
+ * });
+ *
+ * matchesTrajectory(run.after.statePath, ['needsMoreInfo', 'drafting']);
+ * ```
+ *
+ * @example A candidate prompt at the seam, scored against the same rows.
+ * ```ts
+ * const { generateText } = createAiSdkExecutors({ models });
+ * const run = await runSeam(emailDrafter, { ...row, candidate: generateText });
+ * ```
+ */
+declare function runSeam<TMachine extends AnyStateMachine>(machine: TMachine, options: RunSeamOptions<TMachine>): Promise<RunSeamResult<TMachine>>;
+//#endregion
+//#region src/utils.d.ts
+/**
+ * Deep-clones a snapshot to a plain-JSON value via a `JSON` round-trip, the
+ * shape you persist and later feed back to `runAgent({ snapshot })`. Asserts
+ * JSON-serializability: functions, `undefined`, and other non-JSON values are
+ * dropped or throw exactly as `JSON.stringify`/`JSON.parse` would. Returns a
+ * plain-JSON deep clone, not a live snapshot.
+ */
+declare function persistSnapshot<TSnapshot>(snapshot: TSnapshot): TSnapshot;
+/**
+ * A stable, dependency-free structural fingerprint of a machine — a short hex
+ * `djb2` hash over its **structural** config only: state ids/nesting, transition
+ * event types and targets, invoke `src`s, `initial`, and any other serializable
+ * config fields. Function values (context/output builders, prompts, inline
+ * guards/actions) are excluded entirely, so two machines that differ only in
+ * their prompts or executors hash identically; adding/removing/retargeting a
+ * state or transition changes the hash.
+ *
+ * Used by {@link runAgent} to stamp settled snapshots with a `version` and to
+ * detect a structurally-edited machine on resume. It is a change detector, not
+ * a cryptographic digest — collisions are possible but unlikely for real
+ * configs. Pass an explicit `machineVersion` to `runAgent` to override it.
+ */
+declare function getMachineStructuralHash(machine: AnyStateMachine): string;
+/** Builds a {@link UserMessage} from a string or multimodal content parts. */
+declare function userMessage(content: string | Array<TextPart | ImagePart | FilePart>): UserMessage;
+/** Builds an {@link AssistantMessage} from a string or content parts (text, files, tool calls/results). */
+declare function assistantMessage(content: string | Array<TextPart | FilePart | ToolCallPart | ToolResultPart>): AssistantMessage;
+/** Builds a {@link SystemMessage}. */
+declare function systemMessage(content: string): SystemMessage;
+/** Builds a {@link ToolMessage} from one or more tool-result parts. */
+declare function toolMessage(content: Array<ToolResultPart>): ToolMessage;
+type MetaOfSnapshot<TSnapshot extends {
+  getMeta(): Record<string, unknown>;
+}> = NonNullable<ReturnType<TSnapshot["getMeta"]>[keyof ReturnType<TSnapshot["getMeta"]>]>;
+/**
+ * Returns the merged `meta` of a snapshot's active state(s) — the typed
+ * replacement for the `Object.values(snapshot.getMeta())[0]` dance.
+ *
+ * `snapshot.getMeta()` is keyed by state id; a leaf machine has one active
+ * state, but parallel/nested machines can have several. This shallow-merges
+ * every active state's meta into one object (later/deeper entries win) and
+ * returns `{}` when no active state declares meta.
+ *
+ * The return type is recovered from the snapshot's own `getMeta()` type, so a
+ * schema-typed machine (`setupAgent({ meta })`) yields the meta schema's
+ * output type. Pass an explicit `TMeta` to override when the snapshot is
+ * untyped (e.g. `AnyMachineSnapshot`).
+ *
+ * @example HITL: read the current state's interaction protocol off an idle
+ * snapshot to render for a human.
+ * ```ts
+ * const { interaction } = getStateMeta(result.snapshot);
+ * ```
+ */
+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).
+ *
+ * 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).
+ */
+declare function getAgentMessages(snapshot: unknown): AgentMessage[];
+/**
+ * Structural guard for a {@link StandardSchemaV1}: `true` when `value` carries
+ * the `~standard` marker. Used to tell an already-schema'd tool `inputSchema`
+ * (a Zod/Valibot/… schema) apart from an SDK-specific schema wrapper that core
+ * can't read directly — see the `ai-sdk` tool pass-through.
+ */
+declare function isStandardSchema(value: unknown): value is StandardSchemaV1;
+/**
+ * Pulls the JSON Schema off a {@link StandardSchemaV1} via its optional
+ * `~standard.jsonSchema.input()` extension (implemented by e.g. Zod v4's
+ * `z.toJSONSchema`), awaiting it when the producer is async. Returns
+ * `undefined` when the schema doesn't expose the extension. Use this to build
+ * a provider request's `response_format`/tool `parameters` from a schema.
+ */
+declare function getJsonSchema(schema?: StandardSchemaV1): Promise<Record<string, unknown> | undefined>;
+/**
+ * Synchronous variant of {@link getJsonSchema}, for call sites that can't
+ * await (building tool/event descriptors inline). An async JSON Schema
+ * producer is treated as absent (returns `undefined`) — in practice Zod's
+ * `z.toJSONSchema` resolves synchronously.
+ */
+declare function getJsonSchemaSync(schema?: StandardSchemaV1): Record<string, unknown> | undefined;
+//#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, AgentIdleError, AgentIllegalResumeEventError, type AgentLintDiagnostic, AgentLintError, type AgentLintSeverity, type AgentLogEntry, type AgentLogPatchOperation, type AgentLogVerification, type AgentMessage, type AgentMessageInfo, type AgentModelRef, type AgentOutputMode, type AgentPathReport, type AgentPathTerminal, type AgentPlanInput, type AgentPlanOutput, type AgentPlanRequest, AgentReplayDivergenceError, AgentReplayMachineMismatchError, type AgentRequest, type AgentRequestExecutor, type AgentRequestExecutorInfo, type AgentRequestExecutorResult, type AgentRequestExecutors, type AgentRequestOptions, type AgentRequestSource, type AgentRun, type AgentRunMeta, type AgentSchemaPack, 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 ExplorePathsOptions, type FilePart, type FromConfigOptions, type FromConfigResult, type GenerateResult, type GetAgentEffectsOptions, type ImagePart, type InferOutput, type InspectedActorRef, type JsonSerializableTraceEvent, type JsonValue, type LintAgentMachineOptions, type MatchTrajectoryOptions, NonSerializableAgentEventError, PLAN_DONE_EVENT_TYPE, type PendingUserInput, type PlanLogic, type ProvideExecutorsOptions, type ReplayOptions, type ReplayResult, type ResolveDecisionOptions, type RunAgentErrorCause, type RunAgentOptions, type RunAgentResult, type RunSeamOptions, type RunSeamResult, type SchemaCompiler, type ScriptedDecisionEntry, type ScriptedDecisionValue, type ScriptedExecutorsScript, type ScriptedTextEntry, 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, getCallUsage, getJsonSchema, getJsonSchemaSync, getMachineStructuralHash, getStateMeta, initEntry, inspectTransitions, isStandardSchema, lintAgentMachine, matchesTrajectory, messagesSchema, parseAgentEvent, parseModelRef, parseOutput, parseStructuredEnvelope, persistSnapshot, provideExecutors, renderDecisionAttempts, replay, resolveDecision, runAgent, runSeam, serializeTraceEvent, setupAgent, simulateAgent, systemMessage, toolMessage, traceTransitions, userMessage, verifyReplay };