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

package/dist/index.d.cts

@@ -1,6 +1,8 @@
-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 { 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-B1Qs2q3q.cjs";
+import { A as AgentDecisionExhaustedError, B as createDecisionRequest, C as getAgentOutputMode, D as parseProviderOutput, E as parseOutput, F as DecisionAttempt, G as AgentRequestOptions, H as resolveDecision, I as DecisionLogic, J as EventFromSnapshot, K as AgentRequestSource, L as DecisionLogicConfig, M as AgentDecisionRequest, N as AgentExecutorDecisionRequest, O as providerOutputSchema, P as CreateDecisionRequestOptions, Q as AgentTruncatedError, R as ResolveDecisionOptions, S as createTextLogic, T as getCallUsage, U as AgentEventDescriptor, V as renderDecisionAttempts, W as AgentInvalidEventPayloadError, X as parseAgentEvent, Y as getAcceptedEvents, Z as AgentError, _ as TextLogic, a as AgentModelRef, b as TextLogicExecutor, c as AgentRequestExecutorInfo, d as AgentRequestMode, f as AgentTextRequest, g as ProviderStructuredOutput, h as BuiltinAgentActors, i as AgentModelMap, j as AgentDecisionInput, k as AgentDecisionExecutor, l as AgentRequestExecutorResult, m as AgentUsage, n as AgentExecutorTextRequest, o as AgentOutputMode, p as AgentTextResult, q as AgentSchemas, r as AgentFinishReason, s as AgentRequestExecutor, t as AgentCallUsage, u as AgentRequestExecutors, v as TextLogicConfig, w as getCallFinishReason, x as bindRequestExecutor, y as TextLogicExecuteArgs, z as createDecisionLogic } from "./text-logic-BFEOxyxv.cjs";
+import { C as rejectAgentStep, D as AgentUsageEvent, E as AGENT_USAGE_EVENT_TYPE, S as initialAgentStep, T as transitionAgentStep, _ as traceTransitions, a as AgentSnapshotDivergedError, b as AgentStepRequest, c as InspectedActorRef, d as RunAgentOptions, f as RunAgentResult, g as serializeTraceEvent, h as runAgent, i as AgentRunMeta, l as JsonSerializableTraceEvent, m as isAgentIdle, n as AgentInputFrom, o as AgentTraceEvent, p as inspectTransitions, r as AgentMaxModelCallsExceededError, s as AgentTransitionHandler, t as AGENT_TRACE_SCHEMA_VERSION, u as RunAgentErrorCause, v as AgentRequest, w as resolveAgentStep, x as executeAgentRequest, y as AgentStep } from "./run-agent-BOfoJg5B.cjs";
+import { c as AgentLogEntry, d as AgentMachineVersionMismatchError, n as AgentEventLogStore, t as AgentEventLogConflictError } from "./event-log-store-DvOcs10J.cjs";
+import { a as getMachineStructuralHash, c as getStatePath, d as toolMessage, f as userMessage, i as getJsonSchemaSync, l as isStandardSchema, n as assistantMessage, o as getMessageText, r as getJsonSchema, s as getStateMeta, u as systemMessage } from "./utils-ceStNCOh.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
@@ -49,38 +51,6 @@ type RequestNamesOf<T> = T extends {
 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">;
-/**
- * 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: {
- *   'agent.messages': appendMessages(),
- * }
- * ```
- */
-type AppendMessagesTransition = <TContext extends object>(args: {
-  context: TContext;
-  event: EventObject & Partial<Omit<AgentMessagesEvent, "type">>;
-}) => {
-  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`/
@@ -100,6 +70,84 @@ declare const messagesSchema: StandardSchemaV1<AgentMessage[]>;
  */
 declare function isAgentMessages(value: unknown): value is AgentMessage[];
 //#endregion
+//#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"];
+}
+/**
+ * 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.
+ */
+type AgentInteractionEventMeta = string | {
+  label?: string;
+  style?: string;
+  event?: Record<string, unknown>;
+};
+/**
+ * The `interaction` descriptor {@link getInteraction} reads off a state's meta.
+ * `TEvent` is the machine's event-type union, so a choice or `textEvent` that
+ * names an event the machine never declared is a compile error.
+ */
+interface AgentInteractionDescriptor<TEvent extends string = string> {
+  /** Label text, or a function of the machine context. `{path.to.field}` interpolates. */
+  label?: string | ((args: {
+    context: any;
+  }) => string);
+  events?: { [K in TEvent]?: AgentInteractionEventMeta };
+  textEvent?: TEvent;
+}
+/**
+ * The state-meta shape the interaction protocol reads. `setupAgent` types
+ * every state's `meta` as this by default, with `TEvent` narrowed to the
+ * machine's declared events; see {@link interactionMetaSchema} for the runtime
+ * schema when a machine declares its own `meta` schema.
+ */
+interface AgentInteractionMeta<TEvent extends string = string> {
+  interaction?: AgentInteractionDescriptor<TEvent>;
+}
+/**
+ * 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. This is
+ * the default `meta` type `setupAgent` gives a machine; pass it to
+ * `createAgentSchemas({ meta: interactionMetaSchema })` only when building a
+ * schema pack by hand.
+ */
+declare const interactionMetaSchema: StandardSchemaV1<AgentInteractionMeta>;
+/** Options for {@link getInteraction}. */
+interface GetInteractionOptions {
+  /**
+   * 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).
+   */
+  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/workflow-config.d.ts
 type JsonSchemaObject = {
   type?: string | string[];
@@ -176,7 +224,7 @@ interface AgentWorkflowRequestConfig {
   output: JsonSchemaObject;
   tools?: AgentTools;
   toolChoice?: AgentToolChoice | unknown;
-  /** Opt into the structured-output envelope's `reasoning` field (see `AgentTextRequest.includeReasoning`). */
+  /** Opt into the provider output's `reasoning` field (see `AgentTextRequest.includeReasoning`). */
   includeReasoning?: boolean;
   temperature?: unknown;
   maxOutputTokens?: unknown;
@@ -327,6 +375,13 @@ type AgentGuardSources<TContextSchema extends StandardSchemaV1<Record<string, un
 type AgentDelaySources<TContextSchema extends StandardSchemaV1<Record<string, unknown>>, TEventSchemas extends AgentEventSchemaInputMap> = Record<string, number | ((args: AgentSourceArgs<TContextSchema, TEventSchemas>) => number)>;
 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>;
+/**
+ * The default `meta` type of an agent machine: the interaction descriptor
+ * `getInteraction` reads, keyed by the machine's own event types (the
+ * reserved `@agent.*` events excluded). A machine that declares `meta`
+ * replaces this default.
+ */
+type AgentDefaultMeta<TEventSchemas extends AgentEventSchemaInputMap> = AgentInteractionMeta<Exclude<keyof TEventSchemas & string, typeof AGENT_USAGE_EVENT_TYPE>>;
 /**
  * A machine's full schema set — context, event payloads, machine input/
  * output, and state/transition meta — as returned by {@link createAgentSchemas}
@@ -337,7 +392,7 @@ type AgentSetupActors<TActors extends { [K in keyof TActors]: AnyActorLogic }, T
  * 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>> {
+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<AgentDefaultMeta<TEventSchemas>>, TEmittedSchemas extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>> {
   context: TContextSchema;
   events: NormalizedEventSchemas<TEventSchemas>;
   input: TInputSchema;
@@ -366,9 +421,8 @@ 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 WithAgentEvents<T extends AgentEventSchemaInputMap> = Omit<T, typeof AGENT_USAGE_EVENT_TYPE | typeof AGENT_MESSAGES_EVENT_TYPE> & {
+type WithAgentEvents<T extends AgentEventSchemaInputMap> = Omit<T, typeof AGENT_USAGE_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>;
@@ -380,7 +434,7 @@ type WithAgentUsageEvent<T extends AgentEventSchemaInputMap> = WithAgentEvents<T
  * 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>;
+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<AgentDefaultMeta<TEventSchemas>>, 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;
@@ -428,7 +482,7 @@ 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 | typeof AGENT_MESSAGES_EVENT_TYPE>, AgentModelRef<TModels>>>;
+  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"]>;
@@ -466,18 +520,11 @@ type SetupAgentXStateResult<TContextSchema extends StandardSchemaV1<Record<strin
 /**
  * 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
+ * {@link AgentSchemaPack}), `models`, and `requests` (the built request
+ * actors). Machines created here are registered so
  * `runAgent` and the free step helpers can resolve their schemas/actors
  * without re-passing them each call.
  */
-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
@@ -488,8 +535,7 @@ 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}, for an explicit top-level `agent.messages` transition. */
-  appendMessages: AgentAppendMessages<InferOutput<TContextSchema>>;
+  readonly requests: RequestActors<TRequestSchemas>;
 };
 /**
  * Schema-first `setup(...)` for agent machines — the standard entry point
@@ -498,11 +544,11 @@ type SetupAgentResult<TContextSchema extends StandardSchemaV1<Record<string, unk
  * 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`/
+ * registers the `agent.generateText`/`agent.streamText`/
  * `agent.decide` 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
+ * `requests` attached. Also has a
  * `setupAgent.fromConfig(...)` namespace member for building a machine from
  * a serializable {@link AgentWorkflowConfig} instead of this TS API.
  *
@@ -536,7 +582,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, 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 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<AgentDefaultMeta<TEventSchemas>>, 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}
@@ -574,108 +620,6 @@ declare namespace setupAgent {
  */
 declare function getAgentSchemas(machine: AnyStateMachine): AgentSchemas | undefined;
 //#endregion
-//#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"];
-}
-/**
- * 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.
- */
-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 {
-  /**
-   * 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).
-   */
-  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;
-/**
- * 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.
- *
- * Without a `harness`, every case runs in sequence and the first violation
- * throws. With one, each case is registered as its own test:
- *
- * ```ts
- * import { describe, it } from 'vitest';
- * assertEventLogStoreConformance(createMyStore, { describe, it });
- * ```
- */
-declare function assertEventLogStoreConformance(create: CreateStore, harness?: EventLogStoreConformanceHarness): Promise<void>;
-//#endregion
 //#region src/agent-run.d.ts
 type AgentStreamEvent<TMachine extends AnyStateMachine = AnyStateMachine> = {
   kind: "request";
@@ -727,33 +671,13 @@ type AgentStreamEvent<TMachine extends AnyStateMachine = AnyStateMachine> = {
  */
 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}. */
 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
+   * 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.
    */
@@ -799,7 +723,7 @@ interface ProvideExecutorsOptions<TMachine extends AnyStateMachine = AnyStateMac
  * `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
+ * as-is.
  * itself, so supply a handler via `options.actors` if the machine uses it.
  * Non-agent actors are untouched.
  *
@@ -815,829 +739,4 @@ interface ProvideExecutorsOptions<TMachine extends AnyStateMachine = AnyStateMac
  */
 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";
-/**
- * One static-analysis finding from {@link lintAgentMachine}. `code` names the
- * check (stable, machine-readable), `path` points at the offending state path
- * or config location, and `message` explains the problem and its remedy.
- */
-interface AgentLintDiagnostic {
-  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;
-  message: string;
-}
-/** Options for {@link lintAgentMachine}. */
-interface LintAgentMachineOptions {
-  /** Skip these check codes entirely. */
-  disable?: AgentLintDiagnostic["code"][];
-  /**
-   * Throw {@link AgentLintError} on failing diagnostics instead of returning
-   * them. Fails on error-severity findings; add `warnings: true` to fail on
-   * warnings too.
-   */
-  throw?: boolean;
-  /** With `throw: true`, also fail on warning-severity findings. Default: errors only. */
-  warnings?: boolean;
-}
-/**
- * Runs static structural checks over a built agent machine and returns the
- * findings ({@link AgentLintDiagnostic}[], empty when clean). Works for
- * TS-authored (`setupAgent(...).createMachine(...)`) and
- * `setupAgent.fromConfig(...)`-compiled machines alike, reading `machine.config`
- * 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 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
- * {@link AgentLintError} (findings on `.diagnostics`) on error-severity
- * findings, or on warnings too with `{ throw: true, warnings: true }`.
- *
- * @example
- * ```ts
- * const errors = lintAgentMachine(machine).filter((d) => d.severity === 'error');
- * if (errors.length) throw new Error(errors.map((e) => `${e.path}: ${e.message}`).join('\n'));
- * ```
- *
- * @example Throwing form
- * ```ts
- * test('agent machine is structurally sound', () => {
- *   lintAgentMachine(machine, { throw: true });
- * });
- * ```
- */
-declare function lintAgentMachine(machine: AnyStateMachine, options?: LintAgentMachineOptions): AgentLintDiagnostic[];
-/**
- * Thrown by `lintAgentMachine(machine, { throw: true })` (and its
- * {@link assertAgentMachine} alias) when lint finds failing diagnostics.
- * `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 AgentError {
-  readonly diagnostics: AgentLintDiagnostic[];
-  constructor(machineId: string, diagnostics: AgentLintDiagnostic[]);
-}
-/** Options for {@link assertAgentMachine}. */
-interface AssertAgentMachineOptions extends LintAgentMachineOptions {
-  /** Also fail on warning-severity findings. Default: errors only. */
-  warnings?: boolean;
-}
-/**
- * Asserts a machine passes {@link lintAgentMachine}: returns silently when
- * clean, throws {@link AgentLintError} (with the findings on `.diagnostics`)
- * otherwise — sugar for `lintAgentMachine(machine, { ...options, throw: true })`.
- * Fails on error-severity findings; set `warnings: true` to fail on warnings
- * too. The one-liner for tests and generation loops:
- *
- * @example
- * ```ts
- * test('agent machine is structurally sound', () => {
- *   assertAgentMachine(machine);
- * });
- * ```
- */
-declare function assertAgentMachine(machine: AnyStateMachine, options?: AssertAgentMachineOptions): void;
-/**
- * Scripted responses for a {@link simulateAgent} playthrough. Each channel is a
- * by-`src` map of FIFO queues, consumed in the order the machine reaches the
- * requests:
- * - `text` — output values for text requests, keyed by request src (the
- *   `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`). An invoke whose src is an
- *   inline logic object has only an auto-generated src, so its queue may be
- *   keyed by the invoke's `id` instead.
- * - `invokes` — output values for scripted invokes (any actor whose output must
- *   be canned), keyed by src.
- * - `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
- *   run crosses via `actor.send(...)`. An event the current state cannot take
- *   (no handler, or guard-rejected) throws rather than silently vanishing.
- */
-interface SimulationScript {
-  text?: Record<string, unknown[]>;
-  decisions?: Record<string, ChosenEvent[]>;
-  invokes?: Record<string, unknown[]>;
-  userInput?: unknown[];
-  errors?: Record<string, unknown[]>;
-  events?: ChosenEvent[];
-}
-/**
- * One entry in a {@link SimulateAgentResult.trail}: the state after this step,
- * plus what drove the step. The first entry is always the machine's initial
- * state, with no `appliedEvent`/`resolvedRequest` — so `trail.map((e) =>
- * e.state)` is the complete state path, directly comparable with
- * `matchesTrajectory` without prepending the initial state by hand.
- */
-interface SimulationTrailEntry {
-  /** The machine state value after applying this step. */
-  state: unknown;
-  /** The chosen event applied (for a decision request), or the external event applied (when `external`). */
-  appliedEvent?: ChosenEvent;
-  /** True when `appliedEvent` came from the script's `events` queue (an external/user event), not a decision. */
-  external?: boolean;
-  /**
-   * Scripted decisions that failed validation (unknown event, invalid payload,
-   * or guard-rejected — live-run retry parity, see {@link simulateAgent})
-   * before this step settled. Present with an `appliedEvent` when a later
-   * scripted attempt succeeded, or alone when every attempt failed and the
-   * exhaustion error was routed through the decision invoke's `onError`.
-   */
-  rejectedEvents?: ChosenEvent[];
-  /**
-   * 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" | "decision";
-    src: string;
-    id: string;
-    outcome: "output" | "error";
-    error?: unknown;
-  };
-}
-/** Options for {@link simulateAgent}. */
-interface SimulateAgentOptions {
-  input?: unknown;
-  script: SimulationScript;
-  /** Max steps before returning `'exhausted'`. Default 100. */
-  maxSteps?: number;
-}
-/** The outcome of a {@link simulateAgent} playthrough. */
-interface SimulateAgentResult {
-  /** `'done'` = reached a final state; `'idle'` = paused with no pending work; `'exhausted'` = hit `maxSteps`. */
-  status: "done" | "idle" | "exhausted";
-  snapshot: AnyMachineSnapshot;
-  trail: SimulationTrailEntry[];
-}
-/**
- * Deterministically plays a machine through, resolving each request from a
- * {@link SimulationScript} instead of a model — no API keys, no model calls.
- * Runs on the pure step path ({@link initialAgentStep} etc.), so it exercises
- * the real transition logic. Returns the terminal `status`, final `snapshot`,
- * and a `trail` of every step taken.
- *
- * Decisions run through the live run's own validation/retry core,
- * {@link resolveDecision}, with the script standing in for the model: each
- * attempt consumes the next queued {@link ChosenEvent} for that src, so an
- * unknown, payload-invalid, or guard-rejected event is NOT silently swallowed
- * — the next queued decision is tried, exactly as a live run re-asks the
- * model. The decision logic's `maxRetries` caps attempts as it would live;
- * when retries continue past the end of the queue, the last queued decision
- * repeats (a scripted model that insists). The repeat applies only within one
- * decision request's retries — each new decision request must have its own
- * queued entry, or the dry-script error throws as usual. Exhausting all
- * attempts delivers
- * the resulting {@link AgentDecisionExhaustedError} to the machine as the
- * decision invoke's error (so an `onError` transition observes it, as it
- * would live); with no `onError` to catch it, it is thrown.
- *
- * Throws a descriptive error when the script runs dry mid-request, naming the
- * pending request's kind, src, and id so the missing scripted response is
- * obvious.
- *
- * @example
- * ```ts
- * const { status, snapshot } = simulateAgent(machine, {
- *   input: { topic: 'state machines' },
- *   script: {
- *     decisions: { 'agent.decide': [{ type: 'ESCALATE' }] },
- *     events: [{ type: 'APPROVE' }], // crosses the human gate
- *   },
- * });
- * ```
- */
-declare function simulateAgent(machine: AnyStateMachine, options: SimulateAgentOptions): Promise<SimulateAgentResult>;
-/** Options for {@link explorePaths}. */
-interface ExplorePathsOptions {
-  input?: unknown;
-  /** Max branch points (decisions + external-event forks) along any path. Default 8. */
-  maxDepth?: number;
-  /** Total path cap before exploration stops (reported via `hitPathCap`). Default 200. */
-  maxPaths?: number;
-  /**
-   * Canned output for each text request, keyed by src (the
-   * `setupAgent({ requests })` key, or `agent.generateText`/`agent.streamText`).
-   * One value per src, reused every time that src is reached. A missing src
-   * halts that branch with a `needs-output` terminal.
-   */
-  text?: Record<string, unknown>;
-  /** Canned output for scripted invokes, keyed by src. Same one-value-per-src rule as `text`. */
-  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 {
-  /**
-   * `'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 {
-  /** Every distinct state value (JSON) encountered across all explored paths. */
-  reachedStates: unknown[];
-  /** One entry per explored path. */
-  terminals: AgentPathTerminal[];
-  /** How many candidate events were pruned because a guard rejected them. */
-  prunedByGuard: number;
-  /** Notes about coverage the exploration could not complete (missing outputs, depth/path caps). */
-  unexplored: string[];
-  /** Total paths explored. */
-  pathsExplored: number;
-  /** True when the total-paths cap was hit (report is partial). */
-  hitPathCap: boolean;
-}
-/**
- * Enumerates a machine's decision and external-event branches to a bounded
- * depth, model-free, and reports which states are reached and how each path
- * terminates. At each decision request it forks one branch per candidate event
- * (guard-rejected candidates are counted in `prunedByGuard`, not explored); at
- * 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. 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`).
- *
- * @example
- * ```ts
- * const report = await explorePaths(refundMachine, { input: { request: 'x', amount: 5000 } });
- * // report.terminals → both 'refunded' and 'denied'; report.prunedByGuard → 1
- * ```
- */
-declare function explorePaths(machine: AnyStateMachine, options?: ExplorePathsOptions): Promise<AgentPathReport>;
-/** The result of a {@link canReach} query. */
-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
- * (`snapshot.matches(...)` semantics) or a snapshot predicate — the predicate
- * form checks any property (a context invariant, a tag, a state+context
- * combination) without reifying a sentinel state for it. Returns
- * `{ reachable: true, witness }` with the event sequence that reaches it, or
- * `{ reachable: false }`.
- *
- * @example
- * ```ts
- * const { reachable, witness } = await canReach(refundMachine, 'denied', { input: { request: 'x', amount: 5000 } });
- * // reachable → true; witness → [{ type: 'NEEDS_REVIEW' }, { type: 'DENY' }]
- * ```
- *
- * @example Predicate target — a violation property, no sentinel state needed
- * ```ts
- * const violation = await canReach(
- *   refundMachine,
- *   (snapshot) => snapshot.matches('issued') && !snapshot.context.approved,
- *   { input: { amount: 5000 } },
- * );
- * // violation.reachable → false is the safety proof
- * ```
- */
-declare function canReach(machine: AnyStateMachine, target: string | ((snapshot: AnyMachineSnapshot) => boolean), options?: ExplorePathsOptions): Promise<CanReachResult>;
-//#endregion
-//#region src/trajectory.d.ts
-/** An event-shaped trajectory item: anything with a string `type`. */
-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 object, or just the event type as a string,
- * - a machine snapshot, whose `value` is used.
- */
-type TrajectoryItem = StateValue | TrajectoryEvent | TrajectoryEventEnvelope | {
-  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. Denominator is
-   * `max(expectedCount, actual.length)` in `exact` mode, `expectedCount` otherwise.
-   */
-  score: number;
-  /** Absent when `matched`. */
-  firstMiss?: TrajectoryMiss;
-}
-/**
- * Matches a run's trajectory against an expected one.
- *
- * 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.
- *
- * 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(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;
-};
-/**
- * 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 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.
- *
- * 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;
-/**
- * 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. 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, 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
- * `userInput` handler for `runAgent`'s own `userInput` option (the builtin
- * `agent.userInput` actor is not an executor slot).
- */
-type ScriptedExecutors = Required<AgentRequestExecutors> & {
-  userInput: (input: AgentUserInput) => Promise<string>;
-  calls: ScriptedExecutorCall[];
-};
-/**
- * Executors that replay a script instead of calling a model. Every slot is
- * provided, so any machine binds.
- *
- * 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: { moderate: [{ type: 'FLAG', reason: 'Borderline tone.' }] },
- *   }),
- * });
- * ```
- *
- * @example Dynamic entries
- * ```ts
- * createScriptedExecutors({
- *   text: { draft: (request) => `Draft about ${request.prompt}` },
- *   decisions: { route: (request) => ({ type: request.events[0]!.type }) },
- * });
- * ```
- *
- * @example Scripted human input
- * ```ts
- * const scripted = createScriptedExecutors({ userInput: ['ship it'] });
- * await runAgent(machine, { executors: scripted, userInput: scripted.userInput });
- * ```
- */
-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
- * 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. Declare `createMachine({ version })` to pin an explicit version instead.
- */
-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 and returns `{}` when no active
- * state declares meta.
- *
- * Merge order is fixed and does not depend on XState's internal node order:
- * entries are sorted by structural depth (the state node's distance from the
- * root, regardless of custom `id` strings), then by state id lexicographically,
- * and merged in that order. So a deeper state's key wins over an ancestor's,
- * and between equal-depth parallel siblings the later state id alphabetically
- * wins.
- *
- * 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>;
-/**
- * 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]`.
- *
- * @example
- * ```ts
- * onTransition: (snapshot) => console.log(getStatePath(snapshot));
- * ```
- */
-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`
- * (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
-//#region src/seam.d.ts
-/**
- * Which model call is under test: the Nth call with this request `name` (the
- * `setupAgent({ requests })` key, or `createTextLogic({ name })`). Name the
- * requests you want to score — a seam is a developer-facing handle, not a
- * model binding, so there is no addressing by model key.
- */
-interface SeamRef {
-  /** The request's registered `name`. */
-  request: string;
-  /** 0-based occurrence among the calls with this name. 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`.
-   * Typed from the machine's own meta schema (`setupAgent({ meta })`).
-   */
-  meta: Partial<MetaOfSnapshot<SnapshotFrom<TMachine>>>;
-  /** 0-based index of this pause within the run. */
-  turn: number;
-  /** The `idle` result that produced the pause. */
-  result: RunAgentResult<TMachine>;
-}
-/**
- * One text call in a {@link runSeam} run's ledger, in call order — the receipt
- * that says which answers came from the script and which one came from the
- * candidate, so "everything else stayed scripted" is a plain assertion on
- * {@link RunSeamResult.calls} rather than a recording function wrapped around
- * every script entry. Text calls only: `decide` and other base executors are
- * not routed by the seam and do not appear.
- */
-interface SeamCall {
-  /** The request's `name`, when it has one. */
-  name?: string;
-  /** The request's model key. */
-  model: string;
-  /** The `scripts` queue key that routed this call. */
-  key: string;
-  /** Where the answer came from: the script, or the seam's `candidate`. */
-  source: "script" | "candidate";
-  /** True for the seam call itself — scripted or candidate. */
-  seam: boolean;
-}
-/** 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[];
-  /** Root-machine transition events on this side of the seam, in order. */
-  events: TrajectoryEvent[];
-}
-/** 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). A queue that
-   * runs dry throws; set {@link RunSeamOptions.repeatLast} to replay its last
-   * entry instead.
-   */
-  scripts?: Record<string, ScriptedTextEntry[]>;
-  /**
-   * Replay the LAST entry of a queue once it is exhausted, so a live seam that
-   * sends the run down a longer branch still finds an answer. Off by default:
-   * a dry queue throws, the same as every other scripted surface.
-   */
-  repeatLast?: boolean;
-  /** 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 deterministic.
-   */
-  candidate?: AgentRequestExecutor;
-  /**
-   * 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`: 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. `usage` accounts for the last leg.
-   */
-  result: RunAgentResult<TMachine>;
-  /** What the seam call returned, or `undefined` when the run never reached it. */
-  seamOutput: unknown;
-  /**
-   * The seam call's own reported token usage — the cost of the one live call
-   * when a `candidate` is a real model. `undefined` when the run never reached
-   * the seam or its answer reported no usage (scripted entries report usage
-   * only via the `{ output, usage }` envelope).
-   */
-  seamUsage?: AgentCallUsage;
-  /** Model calls made before the seam, or `-1` when the run never reached it. */
-  callsBeforeSeam: number;
-  /** The run's text calls in order: what was served, and by whom. */
-  calls: SeamCall[];
-  /** 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 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] },
- *   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
-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 };
+export { AGENT_TRACE_SCHEMA_VERSION, AGENT_USAGE_EVENT_TYPE, type AgentCallUsage, type AgentDecisionExecutor, AgentDecisionExhaustedError, type AgentDecisionInput, type AgentDecisionRequest, type AgentDefaultMeta, AgentError, type AgentEventDescriptor, AgentEventLogConflictError, type AgentEventLogStore, type AgentExecutorDecisionRequest, type AgentExecutorTextRequest, type AgentFinishReason, type AgentInputFrom, type AgentInteraction, type AgentInteractionDescriptor, type AgentInteractionEvent, type AgentInteractionEventMeta, type AgentInteractionMeta, AgentInvalidEventPayloadError, type AgentLogEntry, AgentMachineVersionMismatchError, AgentMaxModelCallsExceededError, type AgentMessage, type AgentModelRef, type AgentOutputMode, type AgentRequest, type AgentRequestExecutor, type AgentRequestExecutorInfo, type AgentRequestExecutorResult, type AgentRequestExecutors, type AgentRequestOptions, type AgentRequestSource, type AgentRunMeta, type AgentSchemaPack, type AgentSchemas, AgentSnapshotDivergedError, type AgentStep, type AgentStepRequest, type AgentStreamEvent, type AgentTextRequest, type AgentTextResult, type AgentTool, type AgentToolChoice, type AgentToolDescriptor, type AgentToolExecute, type AgentTools, type AgentTraceEvent, type AgentTransitionHandler, AgentTruncatedError, type AgentUsage, type AgentUsageEvent, type AgentUsageEventPayload, type AgentWorkflowActionConfig, type AgentWorkflowActorConfig, type AgentWorkflowConfig, type AgentWorkflowInvokeConfig, type AgentWorkflowRequestConfig, type AgentWorkflowStateConfig, type AgentWorkflowTransitionConfig, type AllowedEvents, type AssistantMessage, type ChosenEvent, type ContextOf, type CreateDecisionRequestOptions, type DecisionAttempt, type DecisionLogic, type DecisionLogicConfig, type DoneActorEventOf, type EventOf, type FilePart, type FromConfigOptions, type FromConfigResult, type GetInteractionOptions, type ImagePart, type InferInput, type InferOutput, type InputOf, type InspectedActorRef, type JsonSerializableTraceEvent, type MetaOf, type OutputOf, type ProvideExecutorsOptions, type ProviderStructuredOutput, type RequestNamesOf, type ResolveDecisionOptions, type RunAgentErrorCause, type RunAgentOptions, type RunAgentResult, type SchemaCompiler, type SnapshotOf, type StandardSchemaV1, type StateValueOf, type SystemMessage, type TextLogic, type TextLogicConfig, type TextLogicExecuteArgs, type TextLogicExecutor, type TextPart, type ToolCallPart, type ToolMessage, type ToolResultPart, type UserMessage, type WithAgentEvents, type WithAgentUsageEvent, assistantMessage, bindRequestExecutor, createAgentSchemas, createDecisionLogic, createDecisionRequest, createTextLogic, eventFromInteraction, executeAgentRequest, getAcceptedEvents, getAgentOutputMode, getAgentSchemas, getCallFinishReason, getCallUsage, getInteraction, getJsonSchema, getJsonSchemaSync, getMachineStructuralHash, getMessageText, getStateMeta, getStatePath, initialAgentStep, inspectTransitions, interactionMetaSchema, isAgentIdle, isAgentMessages, isStandardSchema, messagesSchema, parseAgentEvent, parseOutput, parseProviderOutput, provideExecutors, providerOutputSchema, rejectAgentStep, renderDecisionAttempts, resolveAgentStep, resolveDecision, runAgent, runAgentStream, serializeTraceEvent, setupAgent, systemMessage, toolMessage, traceTransitions, transitionAgentStep, userMessage };