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

package/dist/run-agent-Ck7Sa3Tb.d.mts

@@ -0,0 +1,968 @@
+import { _ as StandardSchemaV1, m as InferInput, s as AgentTools, w as WithAgentInputSchema } from "./types-DWA6X9R-.mjs";
+import { F as AgentDecisionRequest, K as AgentEventDescriptor, X as AgentRequestSource, d as AgentRequestMode, f as AgentTextRequest, m as AgentUserInput, p as AgentUsage, r as AgentFinishReason, t as AgentCallUsage, tt as AgentError, u as AgentRequestExecutors } from "./text-logic-DJBK3LbG.mjs";
+import { AnyActorLogic, AnyActorRef, AnyMachineSnapshot, AnyStateMachine, AsyncActorLogic, EmittedFrom, EventFromLogic, EventObject, InputFrom, InspectionEvent, OutputFrom, Snapshot, SnapshotFrom } from "xstate";
+
+//#region src/usage.d.ts
+/** Reserved event delivered after a model call reports token usage. */
+declare const AGENT_USAGE_EVENT_TYPE: "@agent.usage";
+/** Machine-owned usage signal. Handle it with an ordinary XState transition. */
+interface AgentUsageEvent extends EventObject {
+  type: typeof AGENT_USAGE_EVENT_TYPE;
+  usage: AgentCallUsage;
+  kind?: "text" | "decision";
+  id?: string;
+  src?: string;
+  model?: string;
+  name?: string;
+}
+//#endregion
+//#region src/steps.d.ts
+/**
+ * A pending text request surfaced by step discovery ({@link getAgentRequests}
+ * / {@link AgentStep.requests}): the machine has spawned a
+ * `TextLogic`-backed invoke and is waiting on its result. Resolve it with
+ * {@link executeAgentRequest} (or by hand, then feed the output into
+ * {@link resolveAgentStep} via `xstate.done.actor` + `actorId`).
+ */
+interface AgentRequest<TInput extends AgentTextRequest = AgentTextRequest> {
+  kind: "text";
+  id: string;
+  src: AgentRequestSource;
+  mode?: AgentRequestMode;
+  input: TInput;
+  tools: AgentTools;
+  events: AgentEventDescriptor[];
+}
+/** `AgentStep.requests` element: a text or decision request. */
+type AgentStepRequest = AgentRequest | AgentDecisionRequest;
+/**
+ * Resolves one **text** request against a host's {@link AgentRequestExecutors}
+ * — merges the request's tools, dispatches to `generateText`/`streamText` per
+ * `mode`, and validates the result against the request's `outputSchema` if
+ * present. Accepts either a `kind: 'text'` `AgentEffect` (the step-path shape
+ * from a custom XState host) or an {@link AgentRequest} envelope.
+ * **Text-only**: passing a `kind: 'decision'` request throws, directing the
+ * caller to `resolveDecision(request, executors, ...)` instead. Always
+ * returns both the normalized `output` and the `raw` executor result (tool
+ * calls, usage, finish reason — needed for observability and event-sourced
+ * replay).
+ */
+/** A `kind: 'text'` `AgentEffect` (structural, to avoid an import cycle with effects.ts). */
+interface TextEffectLike {
+  kind: "text";
+  requestId: string;
+  request: AgentTextRequest;
+  mode?: AgentRequestMode;
+}
+declare function executeAgentRequest(requestOrEffect: AgentRequest | TextEffectLike, executors: Partial<AgentRequestExecutors>): Promise<{
+  output: unknown;
+  raw: unknown;
+}>;
+//#endregion
+//#region src/event-log.d.ts
+/** The durable entry envelope version. */
+declare const AGENT_EVENT_SCHEMA_VERSION: 1;
+/**
+ * The reserved event type of the first entry of every log. It carries the
+ * machine `input` (fresh start) or a persisted `snapshot` (continuation), so a
+ * log replays with no side channel. Lives in the reserved `@agent.*` namespace
+ * so it can never collide with a machine's own vocabulary; it is consumed by
+ * {@link replay} and never fed to `transition`.
+ */
+declare const AGENT_INIT_EVENT_TYPE: "@agent.init";
+/** Values that round-trip through JSON without adapters or silent coercion. */
+type JsonValue$1 = null | boolean | number | string | JsonValue$1[] | {
+  [key: string]: JsonValue$1;
+};
+/** A persisted (JSON-safe) machine snapshot, as `machine.getPersistedSnapshot()` returns. */
+type AgentPersistedSnapshot = Snapshot<unknown>;
+/** Recorded projection hash used by {@link replay} verification. */
+interface AgentLogVerification {
+  /** {@link getSnapshotStateHash} of the persisted snapshot after this entry is applied. */
+  stateHash: string;
+}
+/**
+ * One journaled external input, JSON-safe and stored verbatim.
+ */
+interface AgentLogEntry {
+  /** Version of this outer envelope, independent of the machine event type. */
+  schemaVersion: typeof AGENT_EVENT_SCHEMA_VERSION;
+  /** Stable identity within the log. Forked prefixes retain their ids. */
+  id: string;
+  /** 0-based position in the log. */
+  index: number;
+  /** RFC 3339 wall-clock time when the host accepted the entry. Metadata only. */
+  recordedAt: string;
+  /** The authored XState machine id. */
+  machineId: string;
+  /** Explicit version or structural hash of the machine that accepted the event. */
+  machineVersion: string;
+  event: EventObject;
+  /** Optional causal parent entry id, scoped to the same log. */
+  causationId?: string;
+  /** Host-owned, JSON-safe; stored verbatim, never interpreted. */
+  metadata?: Record<string, JsonValue$1>;
+  /** Recorded projection hash used by replay verification. */
+  verification?: AgentLogVerification;
+}
+/** The payload of the reserved {@link AGENT_INIT_EVENT_TYPE} first entry. */
+interface AgentInitEvent extends EventObject {
+  type: typeof AGENT_INIT_EVENT_TYPE;
+  /** Machine input for a fresh start. Mutually exclusive with `snapshot`. */
+  input?: unknown;
+  /** Persisted snapshot to continue from. Mutually exclusive with `input`. */
+  snapshot?: AgentPersistedSnapshot;
+}
+/** A malformed or internally inconsistent log. */
+declare class AgentEventLogError extends AgentError {
+  constructor(message: string);
+}
+/** A precise failure when an entry would not survive a JSON round-trip. */
+declare class NonSerializableAgentEventError extends AgentError {
+  readonly path: string;
+  readonly valueType: string;
+  constructor(path: string, valueType: string);
+}
+/** Replay reached a state that does not match the entry's recorded hash. */
+declare class AgentReplayDivergenceError extends AgentError {
+  readonly eventId: string;
+  readonly index: number;
+  readonly kind: "state" | "missing-verification";
+  readonly expected?: string | undefined;
+  readonly actual?: string | undefined;
+  constructor(eventId: string, index: number, kind: "state" | "missing-verification", expected?: string | undefined, actual?: string | undefined);
+}
+/**
+ * An entry was recorded against a different machine (id) or a different
+ * machine version than the one replaying it. An init-with-snapshot entry is
+ * exempt: that entry IS the bridge from the old version to the new one.
+ */
+declare class AgentMachineVersionMismatchError extends AgentError {
+  readonly eventId: string;
+  readonly index: number;
+  readonly expected: {
+    machineId: string;
+    machineVersion: string;
+  };
+  readonly actual: {
+    machineId: string;
+    machineVersion: string;
+  };
+  constructor(eventId: string, index: number, expected: {
+    machineId: string;
+    machineVersion: string;
+  }, actual: {
+    machineId: string;
+    machineVersion: string;
+  });
+}
+/**
+ * Rejects values JSON would drop or coerce. Unlike `JSON.stringify`, this does
+ * not silently erase `undefined`/functions or turn non-finite numbers into
+ * `null`; durable entries contain only plain JSON values.
+ */
+declare function assertJsonSerializable(value: unknown, path?: string, ancestors?: WeakSet<object>): asserts value is JsonValue$1;
+/** Validates the complete durable envelope before append/export/replay. */
+declare function assertAgentLogEntry(entry: unknown): asserts entry is AgentLogEntry;
+/**
+ * The canonical hash of a PERSISTED snapshot (`machine.getPersistedSnapshot()`,
+ * or {@link replay}'s `persistedSnapshot`) — the value recorded in an entry's
+ * `verification.stateHash`.
+ *
+ * Stripped before hashing, because they are re-minted on every fold and would
+ * otherwise make two identical runs hash differently: `sessionId`,
+ * `_nextTimerId` and `_nextActorIds` at the snapshot root, `sessionId` on each
+ * `children[*]` entry (recursively, through nested child snapshots), and
+ * `undefined`-valued properties (so a snapshot hashes the same before and
+ * after a JSON round-trip). Stripping is confined to those structural
+ * positions: a `sessionId` inside `context`, `output`, `error` or an event
+ * payload is application data and is hashed. Object keys are sorted, so key
+ * order is irrelevant.
+ *
+ * A change detector, not a cryptographic digest.
+ */
+declare function getSnapshotStateHash(snapshot: AgentPersistedSnapshot | unknown): string;
+/** Options controlling the durable envelope created by {@link createReplayEntry}. */
+interface CreateReplayEntryOptions {
+  /** Explicit machine version; defaults to the machine's resolved version. */
+  machineVersion?: string;
+  /** Stable entry id; defaults to `evt_` plus the zero-padded index. */
+  id?: string;
+  /** RFC 3339 acceptance time; defaults to the current wall clock. */
+  recordedAt?: string;
+  causationId?: string;
+  metadata?: Record<string, JsonValue$1>;
+  /** Record `verification.stateHash` (default `true`). */
+  verification?: boolean;
+  /**
+   * The snapshot this entry folds to, when the caller already has it — avoids
+   * re-folding the whole prefix just to compute the hash. Accepts a live or a
+   * persisted snapshot.
+   */
+  snapshot?: AnyMachineSnapshot | AgentPersistedSnapshot;
+}
+/**
+ * Creates a JSON-safe, self-describing entry for `event` appended after
+ * `entries` (which must be the complete prefix, so `index` and the recorded
+ * state hash line up).
+ */
+declare function createReplayEntry(machine: AnyStateMachine, entries: readonly AgentLogEntry[], event: EventObject, options?: CreateReplayEntryOptions): AgentLogEntry;
+/** How a log begins: from machine input, or from a persisted snapshot. */
+type AgentLogInit = {
+  input?: unknown;
+  snapshot?: never;
+} | {
+  snapshot: AgentPersistedSnapshot;
+  input?: never;
+};
+/**
+ * The reserved first entry of a log. Pass EXACTLY one of:
+ *
+ * - `{ input }` — a fresh start; replay folds from `initialTransition`.
+ * - `{ snapshot }` — a continuation from a persisted snapshot: a version
+ *   bridge, or a legacy snapshot that predates the log. Replay restores it
+ *   purely (no actors started) and folds the rest of the log onto it.
+ *
+ * `options.metadata.executionId` names the lineage; this library always sets
+ * one, and readers must tolerate its absence in logs written elsewhere.
+ */
+declare function initEntry(machine: AnyStateMachine, init?: AgentLogInit, options?: CreateReplayEntryOptions): AgentLogEntry;
+/**
+ * The log's execution id: the lineage identity pinned in the init entry's
+ * `metadata.executionId`.
+ *
+ * Minted once per run and inherited verbatim by every resume of that log, so
+ * it names one lineage rather than one process. Entry ids cannot serve this
+ * role — the built-in ids are index-derived, so every log's init entry is
+ * `evt_00000000`. A fork copies the init entry, so it shares its parent's
+ * execution id by construction.
+ *
+ * Returns `undefined` for a log with no init entry and for one written without
+ * the field — callers must treat the id as optional.
+ */
+declare function getLogExecutionId(entries: readonly AgentLogEntry[]): string | undefined;
+/**
+ * Validates a log before replay or append: every envelope well-formed, indices
+ * contiguous from 0, ids unique, the first entry the reserved init entry, and
+ * one consistent machine identity throughout.
+ *
+ * With `machine`, entries are also checked against that machine's id and
+ * resolved version — a mismatch throws {@link AgentMachineVersionMismatchError}.
+ * An init-with-snapshot entry is exempt from the version check: that entry is
+ * itself the bridge from whatever version produced the snapshot.
+ */
+declare function validateReplayEntries(entries: readonly AgentLogEntry[], options?: {
+  machine?: AnyStateMachine;
+  machineVersion?: string;
+}): void;
+/**
+ * The prefix `[0, upToIndex)` of a log, as a new log. `upToIndex` is exclusive
+ * and must leave the init entry in place, so the fork is still self-contained.
+ */
+declare function forkEventLog(entries: readonly AgentLogEntry[], upToIndex: number): AgentLogEntry[];
+/**
+ * The 1-based occurrence `n` for the NEXT call at invoke site `siteId`:
+ * `1 + completions`, where a completion is a journaled `xstate.done.actor` OR
+ * `xstate.error.actor` for that `actorId` (an error is a semantic completion).
+ * The one counting rule behind every `${siteId}#${n}` call key, so a live run
+ * and a replay derive the same `n` by construction.
+ */
+declare function agentCallOccurrence(history: readonly (EventObject | AgentLogEntry)[] | undefined, siteId: string): number;
+/**
+ * Folds the reserved `@agent.usage` entries of a log into one cumulative usage
+ * total. The log is the source of truth, so the totals are a pure projection of
+ * it: replay a log, fold it, and you get the numbers the run reported with no
+ * host-side accumulator in between.
+ *
+ * Accepts entries or bare events. Token fields are partial sums: a field stays
+ * `undefined` until some entry reports it, and non-finite values are ignored.
+ */
+declare function getUsageFromEvents(entries: readonly (EventObject | AgentLogEntry)[]): AgentCallUsage;
+/**
+ * Rewrites a journaled `xstate.done.actor`/`xstate.error.actor` event's
+ * `sessionId` to the session the CURRENT fold minted for that `actorId`.
+ *
+ * Session ids are re-minted on every fold, and XState drops a completion event
+ * whose `sessionId` does not match the live child — silently, as a no-op
+ * transition. Rebinding is what makes a journaled completion replayable at all.
+ * `sessions` caches the mapping per fold, so a later event referring to the
+ * recorded session of an already-stopped child still resolves.
+ */
+declare function rebindActorSession(event: EventObject, snapshot: AnyMachineSnapshot, sessions: Map<string, string>): EventObject;
+/** Options for {@link replay}. */
+interface ReplayOptions {
+  /** Explicit expected machine version; defaults to the machine's resolved version. */
+  machineVersion?: string;
+  /**
+   * `true` (default) checks the entries that carry a `verification.stateHash`;
+   * `'strict'` additionally requires every entry to carry one; `false` skips
+   * verification entirely.
+   */
+  verify?: boolean | "strict";
+}
+/** The result of a {@link replay}. */
+interface ReplayResult<TMachine extends AnyStateMachine> {
+  /** The folded live snapshot (no actors started, no effects run). */
+  snapshot: SnapshotFrom<TMachine>;
+  /** Its persisted projection — what a host stores, and what hashes. */
+  persistedSnapshot: AgentPersistedSnapshot;
+}
+/**
+ * Folds a log through XState's pure `initialTransition`/`transition` WITHOUT
+ * executing anything: no actor is started, no action runs, no model is called.
+ * A journaled `xstate.done.actor` entry carries the completed actor's output
+ * inline, so the invoke it belongs to is never re-run. Crash recovery, fork
+ * resume, and time travel in one call.
+ *
+ * The first entry is the reserved {@link initEntry}: `input` folds from
+ * `initialTransition`, `snapshot` restores the persisted snapshot purely
+ * (`machine.restoreSnapshot`) and folds the rest of the log onto it.
+ */
+declare function replay<TMachine extends AnyStateMachine>(machine: TMachine, entries: readonly AgentLogEntry[], options?: ReplayOptions): ReplayResult<TMachine>;
+//#endregion
+//#region src/event-log-store.d.ts
+/**
+ * An append-only event log: the authoritative durability artifact of a thread.
+ * The journal of external inputs IS the source of truth — deterministic
+ * `replay` derives every snapshot from it, and a fork is a copied log prefix.
+ *
+ * Userland stores (a Postgres table with a `(thread_id, index)` primary key, an
+ * append-only object in blob storage, …) implement this one shape so they
+ * interoperate; {@link createInMemoryEventLogStore} is the reference, and
+ * `assertEventLogStoreConformance` checks an implementation against it.
+ */
+interface AgentEventLogStore {
+  /**
+   * Append `entries` starting at `expectedIndex` (the current length of the
+   * thread's log; 0 for a new thread). Atomic — all entries land or none do.
+   * Rejects with {@link AgentEventLogConflictError} when the thread's length
+   * differs from `expectedIndex`: a concurrent writer appended first. Each
+   * entry's `index` must be contiguous from `expectedIndex` (a plain `Error`
+   * otherwise: that is caller misuse, not a race).
+   */
+  append(input: {
+    threadId: string;
+    expectedIndex: number;
+    entries: AgentLogEntry[];
+  }): Promise<void>;
+  /**
+   * Read a thread's entries in log order. `from` (default 0) skips entries
+   * below that index for incremental catch-up. An unknown thread reads as an
+   * empty array.
+   */
+  read(threadId: string, options?: {
+    from?: number;
+  }): Promise<AgentLogEntry[]>;
+  /** The thread's current log length (0 for an unknown thread) — the next `expectedIndex`. */
+  length(threadId: string): Promise<number>;
+  /**
+   * Copy the prefix `[0, upToIndex)` onto a fresh, empty `newThreadId`.
+   * Without `upToIndex` the full source is copied. `upToIndex` is exclusive
+   * and must be an integer in `[1, length]`, so the fork keeps the reserved
+   * init entry and stays a self-contained log. The fork then appends
+   * independently. Rejects (plain `Error`) if `newThreadId` already has
+   * entries, the source is unknown, or `upToIndex` is out of range.
+   * Implementations may copy-on-write or physically copy; observable behavior
+   * must match a full copy.
+   */
+  fork(input: {
+    threadId: string;
+    newThreadId: string; /** Exclusive index cutoff. */
+    upToIndex?: number;
+  }): Promise<void>;
+}
+/**
+ * Rejection from {@link AgentEventLogStore.append} when the thread's stored
+ * length is not the `expectedIndex` the writer held — a concurrent writer
+ * appended first. `actualIndex` is the next index the store would accept.
+ */
+declare class AgentEventLogConflictError extends AgentError {
+  readonly threadId: string;
+  readonly expectedIndex: number;
+  readonly actualIndex: number;
+  constructor(threadId: string, expectedIndex: number, actualIndex: number);
+}
+/**
+ * In-memory reference store, and the baseline the conformance suite runs
+ * against. Per-thread entries are held in a contiguous, index-ordered list;
+ * append's check-and-push runs synchronously (no `await` between reading the
+ * length and writing), so two appends racing on the same `expectedIndex`
+ * resolve to exactly one winner. Every stored and returned entry is
+ * `structuredClone`d, so a caller can neither mutate stored state through a
+ * value it appended nor through a value it read.
+ */
+declare function createInMemoryEventLogStore(): AgentEventLogStore;
+//#endregion
+//#region src/run-agent.d.ts
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+/**
+ * Thrown by {@link runAgent} when a resume is given BOTH an `events` log and a
+ * `snapshot` that claims a position in that log (`agentMeta.logIndex`), and the
+ * two disagree about the state at that position. The log is the source of
+ * truth, so this is a host bug (a snapshot cached from a different lineage, or
+ * a snapshot mutated out of band), not a recoverable resume: pass the log
+ * alone, or the matching snapshot.
+ */
+declare class AgentSnapshotDivergedError extends AgentError {
+  readonly expected: string;
+  readonly actual: string;
+  readonly logIndex: number;
+  constructor(expected: string, actual: string, logIndex: number);
+}
+/**
+ * The stamp {@link RunAgentResult.persist} writes onto the persisted snapshot:
+ * the machine identity that produced it plus the position in the event log it
+ * caches. Read back by the next resume to decide whether the snapshot can be
+ * trusted without replaying the log (see {@link RunAgentOptions.events}).
+ */
+interface AgentRunMeta {
+  machineId: string;
+  version: string;
+  /** The log's `executionId` lineage, when the log carries one. */
+  logId?: string;
+  /** The log's length at the moment this snapshot was taken. */
+  logIndex: number;
+}
+/** Handler for `agent.userInput` invokes passed as {@link RunAgentOptions.userInput}. Resolves to what the human typed. */
+interface AgentUserInputExecutor {
+  (input: AgentUserInput): PromiseLike<string>;
+}
+/** Typed root-machine transition observer accepted by {@link runAgent}. */
+type AgentTransitionHandler<TMachine extends AnyStateMachine> = (snapshot: SnapshotFrom<TMachine>, event: EventFromLogic<TMachine>) => void;
+/**
+ * The version of the {@link AgentTraceEvent} envelope every trace event carries
+ * as `schemaVersion`. Bumped only on a breaking change to the envelope or any
+ * payload shape, so a consumer can gate on it. Emitted identically by
+ * {@link runAgent}, {@link provideExecutors}' `onTrace`, and
+ * {@link traceTransitions}.
+ */
+declare const AGENT_TRACE_SCHEMA_VERSION = 1;
+type AgentTraceEvent<TMachine extends AnyStateMachine = AnyStateMachine> = {
+  /** The {@link AGENT_TRACE_SCHEMA_VERSION} the event was produced with. */schemaVersion: typeof AGENT_TRACE_SCHEMA_VERSION;
+  runId: string;
+  seq: number;
+  timestamp: string;
+  machineId: string; /** The machine's own `version`, else its structural hash. */
+  machineVersion: string;
+} & ({
+  type: "run.start";
+  input?: InputFrom<TMachine>;
+  snapshot?: Snapshot<unknown>;
+  event?: EventFromLogic<TMachine>;
+} | {
+  type: "request.start";
+  request: AgentStepRequest;
+} | {
+  type: "request.end";
+  request: AgentStepRequest;
+  output: unknown;
+  raw: unknown;
+  /** The model's reasoning, lifted off the raw executor result when the
+   * request opted into the structured-output envelope's `reasoning` field.
+   * Present only when the executor surfaced a string `reasoning`. */
+  reasoning?: string;
+  /** This call's token usage, lifted off the raw executor result's `usage`.
+   * Present only when the executor reported it. The run-level total is
+   * {@link RunAgentResult.usage}. */
+  usage?: AgentCallUsage;
+  /** Why the call stopped, lifted off the raw executor result's
+   * `finishReason` and normalized. Present only when the executor reported
+   * one the {@link AgentFinishReason} union names. */
+  finishReason?: AgentFinishReason;
+} | {
+  type: "request.error";
+  request: AgentStepRequest;
+  error: unknown;
+} | {
+  type: "stream.chunk";
+  request: AgentRequest;
+  chunk: string;
+} | {
+  type: "machine.transition";
+  snapshot: SnapshotFrom<TMachine>;
+  event: EventFromLogic<TMachine>;
+} | {
+  type: "emit";
+  event: EmittedFrom<TMachine>;
+} | {
+  /** A reserved `@agent.usage` event the run declined to deliver. The
+   * tokens still fold into {@link RunAgentResult.usage}; only the machine
+   * event is dropped. */
+  type: "usage.dropped";
+  event: AgentUsageEvent; /** `'settled'`: the call settled after the run's cycle had resolved. */
+  reason: "settled";
+} | ({
+  type: "run.end";
+  status: "done";
+  output: OutputFrom<TMachine>;
+  snapshot: SnapshotFrom<TMachine>;
+} | {
+  type: "run.end";
+  status: "idle";
+  snapshot: SnapshotFrom<TMachine>;
+  pendingUserInputs?: PendingUserInput[];
+} | {
+  type: "run.end";
+  status: "error";
+  cause: RunAgentErrorCause;
+  error: unknown;
+  snapshot: SnapshotFrom<TMachine>;
+}));
+/**
+ * Fields a JSON projection keeps VERBATIM: {@link TRACE_ENVELOPE_KEYS} (the
+ * envelope, the `type`/`status`/`cause` discriminants, and the payload fields
+ * that are already plain strings) plus `usage.dropped`'s `reason`, which is a
+ * string literal — sanitizing it is the identity, so it keeps its literal type.
+ * Every other payload field narrows to {@link JsonValue}. @internal
+ */
+type TraceVerbatimKey = (typeof TRACE_ENVELOPE_KEYS)[number] | "reason";
+/** One trace variant's JSON projection. Homomorphic, so `?` modifiers survive. @internal */
+type JsonProjectedTraceVariant<TEvent> = { [K in keyof TEvent]: K extends TraceVerbatimKey ? TEvent[K] : JsonValue };
+/**
+ * `raw` is written only when `includeRaw` was set, so it is optional on the
+ * JSON side even though the live trace always carries it. @internal
+ */
+type WithOptionalRaw<T> = "raw" extends keyof T ? Omit<T, "raw"> & {
+  raw?: JsonValue;
+} : T;
+/**
+ * The JSON-safe projection of an {@link AgentTraceEvent} produced by
+ * {@link serializeTraceEvent}: the envelope fields are unchanged, and every
+ * payload field that can hold a live object (snapshots, machine events, request
+ * objects, raw SDK results, errors) is narrowed to a {@link JsonValue}. Safe to
+ * hand straight to `JSON.stringify` for a JSONL trace file.
+ *
+ * DERIVED from {@link AgentTraceEvent}, so a new trace variant cannot silently
+ * miss the JSON side. `src/serialize-trace-event.test.ts` pins the result to
+ * the shape this type had when it was hand-maintained.
+ */
+type JsonSerializableTraceEvent = AgentTraceEvent extends infer TEvent ? TEvent extends unknown ? WithOptionalRaw<JsonProjectedTraceVariant<TEvent>> : never : never;
+declare const TRACE_ENVELOPE_KEYS: readonly ["schemaVersion", "runId", "seq", "timestamp", "machineId", "machineVersion", "type", "status", "cause", "reasoning", "finishReason", "chunk"];
+/**
+ * Projects an {@link AgentTraceEvent} into a guaranteed JSON-safe envelope —
+ * the form the trace stream is actually sold for (one `JSON.stringify` per line
+ * in a JSONL file). Live values are sanitized rather than trusted:
+ *
+ * - Snapshots (`run.start`, `machine.transition`, `run.end`) go through the
+ *   same JSON round-trip as `machine.getPersistedSnapshot(...)`, so what lands on disk is
+ *   what a resume would see.
+ * - `request.end`'s `raw` (a provider SDK object, frequently cyclic) is DROPPED
+ *   unless `includeRaw` is set, in which case it is sanitized like everything
+ *   else.
+ * - Non-serializable values anywhere (functions, symbols, `undefined`, cyclic
+ *   back-references) are dropped; `Error`s become `{ name, message, stack?,
+ *   code? }` instead of `{}`. Nothing throws.
+ *
+ * @example
+ * ```ts
+ * await appendFile('trace.jsonl', JSON.stringify(serializeTraceEvent(event)) + '\n');
+ * ```
+ */
+declare function serializeTraceEvent(event: AgentTraceEvent, options?: {
+  includeRaw?: boolean;
+}): JsonSerializableTraceEvent;
+/**
+ * Options for {@link runAgent}.
+ *
+ * Host executors are passed as a single {@link AgentRequestExecutors}-shaped
+ * set under `executors` (the same shape the step path takes). Each executor
+ * kind is required only if the machine actually reaches a request of that kind
+ * — checked at bind time, before any actor runs. The whole `executors` field is
+ * optional: a machine whose agent sources all carry their own executor
+ * (`.withExecutor(...)`) needs none.
+ */
+interface RunAgentOptions<TMachine extends AnyStateMachine> {
+  /**
+   * The host executor set backing the machine's agent actors — build it with
+   * `createAiSdkExecutors({ models })` from '@statelyai/agent/ai-sdk', or supply
+   * `{ generateText?, streamText?, decide? }` by hand. Every slot is optional
+   * here (unlike the step path's {@link AgentRequestExecutors}): each kind is
+   * bind-time-checked only when the machine actually reaches a request of that
+   * kind, so e.g. a stream-only machine may pass `{ streamText }` alone.
+   */
+  executors?: Partial<AgentRequestExecutors>;
+  /**
+   * Machine input. Validated against the machine's declared input schema —
+   * defaults filled, transforms applied — before it reaches
+   * `createActor(machine, { input })`; invalid
+   * input throws an {@link AgentError} with code `invalid-machine-input`.
+   * Typed as {@link AgentInputFrom}, so fields the schema defaults are optional
+   * here. Omit when resuming via `snapshot`.
+   */
+  input?: AgentInputFrom<TMachine>;
+  /** A previously-settled run's `result.persist()`, to resume from instead of starting fresh. Pair with `event` to deliver the event that unblocks the resumed idle state. */
+  snapshot?: Snapshot<unknown>;
+  /**
+   * An event to send immediately after starting/resuming the actor (e.g. the
+   * human's answer to an idle-state prompt), typed as the machine's event
+   * union. If the resumed state has no transition for it, the machine ignores
+   * it — the run settles normally and the result carries
+   * {@link RunAgentResult.ignored}. For a payload off the wire, parse it first
+   * with `parseAgentEvent(machine, payload)`.
+   */
+  event?: EventFromLogic<TMachine>;
+  /**
+   * A prior run's `result.events` — the replayable log to resume from and keep
+   * appending to. THE LOG IS THE SOURCE OF TRUTH: journaled model/tool results
+   * are folded back in rather than re-executed, so a crashed run resumes from
+   * its log alone.
+   *
+   * A `snapshot` passed alongside is a CACHE of that log: it is trusted only
+   * when it is stamped (see {@link AgentRunMeta}) at the log's current tail and
+   * hashes to what the tail entry recorded; otherwise the log is replayed and
+   * the cache is verified against the position it claims (a genuine
+   * disagreement throws {@link AgentSnapshotDivergedError}).
+   *
+   * When the log was written by a DIFFERENT machine version, a `snapshot` is
+   * required (XState's own `migrate` applies on restore) and the run starts a
+   * NEW log segment whose init entry records where it bridged from; without one
+   * it throws `AgentMachineVersionMismatchError`.
+   */
+  events?: readonly AgentLogEntry[];
+  /**
+   * Durable log storage, write-ahead. With a `store` the run reads the thread's
+   * log to resume from (unless `events` is given, which wins) and writes every
+   * appended entry back through {@link AgentEventLogStore.append}, in log
+   * order. Writes are awaited before every model call, so a paid call is never
+   * made against an unpersisted log; pure transitions never wait. A rejected
+   * write (an {@link AgentEventLogConflictError} from a concurrent writer, or
+   * any other failure) stops the run: `{ status: 'error', cause: 'journal' }`.
+   *
+   * Requires {@link RunAgentOptions.threadId}.
+   */
+  store?: AgentEventLogStore;
+  /** The {@link RunAgentOptions.store} thread this run reads and appends to. Required whenever `store` is given. */
+  threadId?: string;
+  /**
+   * Called synchronously as each log entry is appended, init entry first. An
+   * observer, never awaited: persisting here is at-least-once and the run does
+   * not wait for it. Use {@link RunAgentOptions.store} for write-ahead
+   * durability.
+   */
+  onEvent?: (entry: AgentLogEntry) => void;
+  /**
+   * Record a `verification.stateHash` on every appended entry (default `true`).
+   * The hash is taken O(1) from the live actor's persisted snapshot right after
+   * that entry's transition, so `replay(machine, events)` can prove it lands on
+   * the same state. Set `false` for a smaller, unverifiable log.
+   */
+  verification?: boolean;
+  /** Actor source implementations, merged onto the machine before binding — sugar for `machine.provide({ actors })` ahead of the run. */
+  actors?: Record<string, AnyActorLogic>;
+  /**
+   * Optional human-input handler for `agent.userInput` invokes (CLI prompt,
+   * web form, Slack, …). With a handler, input is gathered inline without
+   * settling. Without one, an `agent.userInput` invoke becomes a *pending
+   * placeholder*: it waits indefinitely, does not block idle detection, and
+   * the run settles `{ status: 'idle', pendingUserInputs }` once no other work
+   * is in flight — persist with `result.persist()` and resume that snapshot
+   * with a `userInput` handler that answers it.
+   */
+  userInput?: AgentUserInputExecutor;
+  /**
+   * Sugar over {@link onTrace}'s `stream.chunk` events: fires for each streamed
+   * chunk of a `mode: 'stream'` text request, alongside the {@link AgentRequest}
+   * that produced it (parallel states can interleave multiple streams). Purely
+   * observational.
+   */
+  onChunk?: (chunk: string, info: {
+    request: AgentRequest;
+  }) => void;
+  /**
+   * Sugar over {@link onTrace}'s `request.end` events: fires once per resolved
+   * text/decision request with its normalized output and the raw executor
+   * result (tool calls, usage, …) — the seam for tracing/observability and
+   * event-sourced replay logging.
+   */
+  onResult?: (request: AgentStepRequest, result: {
+    output: unknown;
+    raw: unknown;
+  }) => void;
+  /** Fires a single ordered stream of run/request/chunk/transition/emit/end events. Intended for eval traces, JSONL logs, and adapter-owned telemetry/exporters. */
+  onTrace?: (event: AgentTraceEvent<TMachine>) => void;
+  /**
+   * Sugar over {@link onTrace}'s `machine.transition` events: fires on every
+   * root-machine transition (snapshot + causing event). Pure observation —
+   * progress UIs, logging, tracing. Cannot send events.
+   */
+  onTransition?: AgentTransitionHandler<TMachine>;
+  /**
+   * Handlers for events the machine emits (`enq.emit(...)`), keyed by emitted
+   * event type — `'*'` catches all. Typed from the machine's `emitted`
+   * schemas (`setupAgent({ emitted: { ... } })`). Purely observational, like
+   * {@link onTransition}: the machine narrates progress on its own vocabulary
+   * (not xstate internals) and the host renders it — a progress UI, an SSE
+   * stream, a log line.
+   */
+  on?: { [TType in EmittedFrom<TMachine>["type"] | "*"]?: (emitted: EmittedFrom<TMachine> & (TType extends "*" ? unknown : {
+    type: TType;
+  })) => void };
+  /**
+   * Raw xstate inspection passthrough: fires for every inspection event in
+   * the whole actor system — root machine, invoked child machines, spawned
+   * actors — each carrying its `actorRef` (`event.actorRef.id`/`.src`). This
+   * is the system-wide seam {@link onTransition} (root transitions only)
+   * cannot give you: filter `event.type === '@xstate.transition'` and read
+   * `event.actorRef` to attribute a child machine's states to the child.
+   * Purely observational, like the other callbacks. Unlike them it also
+   * fires during the final settle (a child's last transition and stop events
+   * arrive while the run is tearing down).
+   *
+   * Accepts a function or an observer (`{ next }`), matching `createActor`'s
+   * `inspect` option, so `@statelyai/sdk`'s `inspector.inspect` plugs in
+   * directly.
+   */
+  inspect?: ((inspectionEvent: InspectionEvent) => void) | {
+    next?: (inspectionEvent: InspectionEvent) => void;
+  };
+  /**
+   * Caps the number of model/decision calls this run may make (each retry of a
+   * decision counts separately). Default 100. The overrun is thrown into the
+   * invoke that would have made the call, as an
+   * {@link AgentMaxModelCallsExceededError} with `code: 'max-model-calls'` — so
+   * an `onError` can branch on it and route to a degraded state. Unhandled, it
+   * settles `{ status: 'error', cause: 'max-model-calls' }`.
+   */
+  maxModelCalls?: number;
+  /** Aborts the run; settles `{ status: 'error', cause: 'aborted' }` with `signal.reason` as the error. */
+  signal?: AbortSignal;
+}
+/**
+ * The outcome of a {@link runAgent} call — always exactly one of three
+ * variants, never a throw for a waiting or failed machine (programmer
+ * errors like a missing executor still throw, at bind time before any actor
+ * runs). `done`: a final state was reached (`output` is the machine's
+ * `OutputFrom`). `idle`: the run settled with no in-flight work — resume by
+ * calling `runAgent` again with `{ snapshot, event }`. `error`: a run-level
+ * failure, discriminated by `cause` (`'aborted'`, `'max-model-calls'`,
+ * `'decision-exhausted'`, `'machine'` for any other machine error state, or
+ * `'stopped'` for an external stop — see {@link RunAgentErrorCause}). Every
+ * variant carries the final `snapshot` and a native XState persistence
+ * function. The
+ * underlying actor is stopped on every settle path — there is no live actor to
+ * resume; resume is always by snapshot.
+ */
+/** A pending unhandled `agent.userInput` invoke surfaced on an idle settle — `id` is the invoke's id, `input` its resolved invoke input (prompt, metadata). Answer it by resuming with a `userInput` handler. */
+interface PendingUserInput {
+  id: string;
+  input: AgentUserInput | undefined;
+}
+type RunAgentOutcome<TMachine extends AnyStateMachine> = {
+  status: "done";
+  output: OutputFrom<TMachine>;
+  snapshot: SnapshotFrom<TMachine>;
+} | {
+  status: "idle";
+  snapshot: SnapshotFrom<TMachine>; /** Present when the machine is waiting on unhandled `agent.userInput` invokes: one entry per pending invoke. */
+  pendingUserInputs?: PendingUserInput[];
+} | {
+  status: "error";
+  cause: RunAgentErrorCause;
+  error: unknown;
+  snapshot: SnapshotFrom<TMachine>;
+};
+type RunAgentResult<TMachine extends AnyStateMachine> = RunAgentOutcome<TMachine> & {
+  /**
+   * The complete, self-contained replayable log for this run — the resumed
+   * prefix (if any) plus every entry this run appended, starting with the
+   * reserved `@agent.init` entry. Pass it back as
+   * {@link RunAgentOptions.events} to resume; fold it with
+   * `getUsageFromEvents` for cumulative spend; hand it to `replay` for
+   * crash recovery or time travel.
+   */
+  events: AgentLogEntry[];
+  /**
+   * Returns XState's persisted snapshot while the run-owned actor is still
+   * available, including active child state. Store this value and pass it back
+   * as `snapshot` to resume. Persistence, migration, and retries remain XState
+   * and host responsibilities.
+   *
+   * The returned object carries an {@link AgentRunMeta} stamp under
+   * `agentMeta`, naming the log position it caches — that is what lets a resume
+   * skip replaying the log. Only the persisted object is stamped; the live
+   * `snapshot` on the result is untouched.
+   */
+  persist(): Snapshot<unknown>;
+  /**
+   * Resolves once every {@link RunAgentOptions.store} write issued so far has
+   * landed — including a straggler `@agent.usage` entry appended by a call
+   * that settled after the run returned, which the result itself does not wait
+   * for. Await it before terminating the process if those entries matter.
+   * Resolves immediately when the run has no store, and never rejects: a
+   * failed write settles the run with `cause: 'journal'` instead.
+   */
+  drain(): Promise<void>;
+  /**
+   * Aggregated model-call usage for THIS run — `modelCalls` plus the token
+   * fields every executor reported (see {@link AgentUsage} for the
+   * partial-sum rule). Present on all three variants: an `idle` or `error`
+   * result accounts for the calls made before the run settled.
+   *
+   * A resumed run counts only its own calls, not the history behind
+   * `snapshot`.
+   */
+  usage: AgentUsage;
+  /**
+   * The {@link RunAgentOptions.event} the machine did not handle: present only
+   * when the resumed state had no transition for it, so sending it was a
+   * no-op (no state change, no actions). The run settles normally — usually
+   * back to `idle` at the same state — and the event is still journaled, so a
+   * replay ignores it again.
+   *
+   * A host that wants to tell the client nothing happened checks this instead
+   * of an error:
+   *
+   * ```ts
+   * if (result.ignored) {
+   *   return Response.json({ error: `'${result.ignored.type}' does not apply here` }, { status: 409 });
+   * }
+   * ```
+   */
+  ignored?: EventObject;
+};
+/**
+ * Discriminates a {@link RunAgentResult} `error`:
+ * - `'aborted'` — the run's `signal` fired.
+ * - `'max-model-calls'` — the `maxModelCalls` budget was exceeded.
+ * - `'decision-exhausted'` — the machine reached an error state whose error is
+ *   (or wraps) a {@link AgentDecisionExhaustedError} that no `onError` handled.
+ * - `'machine'` — any other machine error state.
+ * - `'stopped'` — the actor was stopped externally (`status === 'stopped'`).
+ * - `'journal'` — a {@link RunAgentOptions.store} write rejected (a concurrent
+ *   writer's {@link AgentEventLogConflictError}, or any other storage failure).
+ */
+type RunAgentErrorCause = "aborted" | "max-model-calls" | "decision-exhausted" | "machine" | "stopped" | "journal";
+/**
+ * Thrown into the invoke that would have made the call once
+ * {@link RunAgentOptions.maxModelCalls} is spent. It reaches the machine
+ * through the normal error channel, so an invoke's `onError` can branch on it
+ * (`error.code === 'max-model-calls'`, the same string the settled result's
+ * `cause` uses) and route to a degraded/finish state instead of failing the
+ * run. Unhandled, it settles `{ status: 'error', cause: 'max-model-calls' }`.
+ *
+ * ```ts
+ * onError: [
+ *   { guard: ({ event }) => event.error?.code === 'max-model-calls', target: 'budgetSpent' },
+ *   { target: 'failed' },
+ * ]
+ * ```
+ */
+declare class AgentMaxModelCallsExceededError extends AgentError {
+  /** The budget that was exceeded (`options.maxModelCalls`). */
+  readonly maxModelCalls: number;
+  constructor(maxModelCalls: number);
+}
+/**
+ * The machine input a run accepts, which is the schema's *pre*-validation side.
+ *
+ * XState's `schemas` are types only — it never validates, and it resolves
+ * `schemas.input` to one type shared by `createActor`'s `input` option and the
+ * `context: ({ input })` factory. A schema field declared with a default
+ * therefore reads as required at the call site even though the caller is meant
+ * to omit it. `setupAgent` brands the machine's input type with its own schema
+ * ({@link WithAgentInputSchema}), so this recovers the looser caller-facing
+ * side while the factory keeps seeing the validated one. Machines with no
+ * declared input schema — and machines reached through `.provide(...)`, which
+ * drops the brand — fall back to xstate's `InputFrom`.
+ */
+type AgentInputFrom<TMachine extends AnyStateMachine> = [NonNullable<InputFrom<TMachine>>] extends [WithAgentInputSchema<infer TInputSchema>] ? [TInputSchema] extends [StandardSchemaV1] ? InferInput<TInputSchema> : InputFrom<TMachine> : InputFrom<TMachine>;
+/**
+ * Runs an agent machine to completion or idle: a `createActor` host that
+ * binds `options`' host executors onto the machine's `agent.*`/`TextLogic`/
+ * `DecisionLogic` actor sources, starts (or resumes) the actor, and drives
+ * it until it settles — {@link RunAgentResult} `done | idle | error`. Unlike
+ * the step helpers ({@link initialAgentStep} etc — a pure
+ * transition-at-a-time path for durable hosts), `runAgent` owns a live actor
+ * internally; there is no continuation callback, so **idle always settles**
+ * and the caller resumes explicitly by passing the settled `{ snapshot,
+ * event }` back in. The actor is stopped on every settle path (`done`,
+ * `idle`, and `error` alike) — resume is always by snapshot, never by
+ * holding a reference to a live actor.
+ *
+ * Binding happens **before** the actor starts: every invoke the machine
+ * could reach is walked and checked against the effective actor sources
+ * (`options.actors` merged onto the machine), so a missing
+ * `streamText`/`decide` executor or any other unbound actor source throws
+ * immediately — a bind-time error, not a mid-run failure. The one exception
+ * is `agent.userInput`: unhandled, it binds as a pending placeholder that
+ * settles the run idle (with `pendingUserInputs`) instead of erroring.
+ *
+ * @example
+ * ```ts
+ * const executors = createAiSdkExecutors({ models });
+ * let r = await runAgent(machine, { input, executors });
+ * while (r.status === 'idle') {
+ *   const event = await promptUser(getAcceptedEvents(r.snapshot));
+ *   r = await runAgent(machine, { snapshot: r.snapshot, event, executors });
+ * }
+ * if (r.status !== 'done') throw new Error(`Run did not complete: ${r.status}`);
+ * console.log(r.output);
+ * ```
+ *
+ * The `executors`' `generateText`/`streamText` accept the raw Vercel AI SDK
+ * functions directly (`executors: { generateText, streamText }` with them
+ * imported from `ai`) — their `{ text }`/`{ textStream }` results are unwrapped
+ * natively. `decide` cannot be a raw AI SDK function: the tool-per-event mapping
+ * lives in an adapter — use `createAiSdkExecutors` from '@statelyai/agent/ai-sdk'.
+ */
+declare function runAgent<TMachine extends AnyStateMachine>(machine: TMachine, options: RunAgentOptions<TMachine>): Promise<RunAgentResult<TMachine>>;
+/**
+ * The actor handed to an {@link inspectTransitions} handler: an
+ * {@link AnyActorRef} widened with the runtime `id`/`src` used to attribute a
+ * transition to the root machine or a specific invoked child (xstate's static
+ * `ActorRef` type omits them, but they are always present at runtime).
+ */
+type InspectedActorRef = AnyActorRef & {
+  id: string;
+  src?: string | AnyActorLogic;
+};
+/**
+ * Wraps a `(snapshot, actorRef) => void` handler into a function usable as
+ * {@link RunAgentOptions.inspect}: it filters the raw inspection stream to
+ * `@xstate.transition` events and hands the handler the typed
+ * {@link AnyMachineSnapshot} and the {@link InspectedActorRef} that
+ * transitioned. Attribute a child actor via `actorRef.id`/`actorRef.src`. Saves
+ * the manual `event.type === '@xstate.transition'` filtering and the snapshot/
+ * actorRef casts.
+ */
+declare function inspectTransitions(handler: (snapshot: AnyMachineSnapshot, actorRef: InspectedActorRef) => void): (inspectionEvent: InspectionEvent) => void;
+/**
+ * An xstate `inspect` handler that emits `machine.transition` trace events onto
+ * `onTrace`, sharing the SAME versioned envelope and per-root-actor `seq`
+ * registry as {@link provideExecutors}' `onTrace`. Pair the two on one actor to
+ * get a single ordered trace stream (request + transition events) for the
+ * uncontrolled path:
+ *
+ * ```ts
+ * const bound = provideExecutors(machine, executors, { onTrace });
+ * const actor = createActor(bound, { inspect: traceTransitions(onTrace) });
+ * ```
+ *
+ * Only ROOT-actor transitions are traced (matching `runAgent`'s
+ * `machine.transition`); child-actor transitions are ignored. Attribute the
+ * event via its envelope `runId`.
+ *
+ * By design this path has NO `run.start`/`run.end` events: `createActor` has no
+ * run boundary the way `runAgent` does, so the stream starts at the actor's
+ * first transition. It also does NOT emit `emit` trace events: in this xstate
+ * build emitted events are delivered through `actor.on(...)`, not the inspection
+ * protocol, so they are not observable from an `inspect` handler — subscribe
+ * with `actor.on('*', ...)` if you need them.
+ */
+declare function traceTransitions<TMachine extends AnyStateMachine = AnyStateMachine>(onTrace: (event: AgentTraceEvent<TMachine>) => void): (inspectionEvent: InspectionEvent) => void;
+/**
+ * Default machine-owned idle signal used by {@link runAgent}: an active
+ * snapshot that accepts an external event anywhere in its active hierarchy,
+ * or declares interaction metadata on an active state.
+ *
+ * Compose this in `setupAgent({ isIdle })` when the application has additional
+ * wait states: `isIdle: (snapshot) => isAgentIdle(snapshot) || snapshot.hasTag('waiting')`.
+ * Pending work and active invoked children are checked separately by the
+ * runner, so this function only answers whether the state is an intentional
+ * external wait.
+ */
+declare function isAgentIdle(snapshot: AnyMachineSnapshot): boolean;
+//#endregion
+export { AGENT_USAGE_EVENT_TYPE as $, AgentMachineVersionMismatchError as A, assertJsonSerializable as B, AGENT_EVENT_SCHEMA_VERSION as C, AgentLogEntry as D, AgentInitEvent as E, NonSerializableAgentEventError as F, getUsageFromEvents as G, forkEventLog as H, ReplayOptions as I, replay as J, initEntry as K, ReplayResult as L, AgentReplayDivergenceError as M, CreateReplayEntryOptions as N, AgentLogInit as O, JsonValue$1 as P, executeAgentRequest as Q, agentCallOccurrence as R, createInMemoryEventLogStore as S, AgentEventLogError as T, getLogExecutionId as U, createReplayEntry as V, getSnapshotStateHash as W, AgentRequest as X, validateReplayEntries as Y, AgentStepRequest as Z, runAgent as _, AgentSnapshotDivergedError as a, AgentEventLogConflictError as b, AgentUserInputExecutor as c, PendingUserInput as d, AgentUsageEvent as et, RunAgentErrorCause as f, isAgentIdle as g, inspectTransitions as h, AgentRunMeta as i, AgentPersistedSnapshot as j, AgentLogVerification as k, InspectedActorRef as l, RunAgentResult as m, AgentInputFrom as n, AgentTraceEvent as o, RunAgentOptions as p, rebindActorSession as q, AgentMaxModelCallsExceededError as r, AgentTransitionHandler as s, AGENT_TRACE_SCHEMA_VERSION as t, JsonSerializableTraceEvent as u, serializeTraceEvent as v, AGENT_INIT_EVENT_TYPE as w, AgentEventLogStore as x, traceTransitions as y, assertAgentLogEntry as z };