@axlsdk/axl 0.26.0 → 0.27.1

package/dist/index.d.ts

@@ -1887,9 +1887,11 @@ type ExecutionInfoV1 = {
      *  (or `runtime.stream()`'s `options.metadata`). Persisted as part of the
      *  `ExecutionInfo` snapshot so callers have a stable, queryable surface for
      *  tags like `userId`, `tenantId`, or correlation ids without parsing the
-     *  event timeline. Filter via `runtime.getExecutions()` + an in-process
-     *  `.filter()`; secondary indexes on this field are intentionally not
-     *  provided — `StateStore` is a persistence boundary, not a query engine. */
+     *  event timeline. Filter in process while paging with
+     *  `runtime.getExecutions({ limit, cursor })` (see
+     *  docs/migration/execution-history-retention.md); secondary indexes on this
+     *  field are intentionally not provided — `StateStore` is a persistence
+     *  boundary, not a query engine. */
     metadata?: Record<string, unknown>;
 };
 /** Stored execution written before explicit event schema versioning. */
@@ -3900,8 +3902,27 @@ interface StateStore {
     saveExecution?(execution: HistoricalExecutionInfo): Promise<void>;
     /** Get a specific execution by ID from history. */
     getExecution?(executionId: string): Promise<HistoricalExecutionInfo | null>;
-    /** List recent executions (most recent first). */
-    listExecutions?(limit?: number): Promise<HistoricalExecutionInfo[]>;
+    /**
+     * List recent executions, most recent first. The built-in stores order by
+     * `startedAt` descending and break ties by `executionId` descending, so the
+     * order is total and stable across calls.
+     *
+     * `options.cursor` asks for the page that starts strictly after that
+     * position in the same order. The runtime passes it only when the store
+     * sets {@link StateStore.historyPaging}; other stores are listed in full and
+     * paged in process.
+     */
+    listExecutions?(limit?: number, options?: {
+        cursor?: ExecutionCursor;
+    }): Promise<HistoricalExecutionInfo[]>;
+    /**
+     * Set to `true` when `listExecutions` honors `options.cursor` with the
+     * `(startedAt DESC, executionId DESC)` order. The built-in stores set it.
+     * Leave it unset if your store ignores the cursor: the runtime then lists
+     * everything and pages in process, which is correct but reads the whole
+     * history on every page.
+     */
+    readonly historyPaging?: boolean;
     /**
      * Delete an execution from history by ID. Returns `true` if an entry was
      * deleted, `false` if the ID didn't exist. Used for GDPR right-to-be-
@@ -3963,8 +3984,10 @@ interface StateStore {
      * bytes on a timer and at startup. Physical deletion is therefore EVENTUAL,
      * not synchronous with the store's expiry.
      *
-     * Built-ins implement it: `MemoryStore` and `SqliteStore` never expire, so
-     * `expiresAt` is `undefined`; `RedisStore` reports existence and any live TTL.
+     * Built-ins implement it. `MemoryStore` and `SQLiteStore` report the
+     * absolute expiry they stored when `ttls.evalHistory` was configured at the
+     * row's first write, and no `expiresAt` otherwise; `RedisStore` reports
+     * existence and any live TTL. An expired row reports `{ exists: false }`.
      * A custom store WITHOUT this method cannot host managed artifact capture —
      * `AxlRuntime` rejects that configuration when it is constructed rather than
      * after a run has spent money.
@@ -3973,6 +3996,39 @@ interface StateStore {
         exists: boolean;
         expiresAt?: number;
     }>;
+    /**
+     * Apply the store's configured history retention to records that were
+     * saved without one (for example before an upgrade, or before a retention
+     * was set), and repair the store's listing indexes. Processes one batch and
+     * returns the cursor to continue from; call again with that cursor until it
+     * is `null`. Axl never calls this itself: run it when you choose to.
+     *
+     * For each record in the batch that has no expiry, and only when a
+     * retention is configured for `options.kind`:
+     * - a record whose window has already passed is deleted, with the same
+     *   per-run data a normal expiry removes;
+     * - any other record gets the expiry it would have had: the retention
+     *   counted from its last save (`completedAt` for executions, falling back
+     *   to `startedAt`; `timestamp` for eval rows).
+     *
+     * Records that already have an expiry keep it. With no retention
+     * configured for the kind (unset or `null`), nothing is expired or armed.
+     *
+     * The walk is oldest first, by `(startedAt, executionId)` for executions
+     * and `(timestamp, id)` for eval rows, and the cursor is a position in that
+     * order rather than an offset, so records removed behind it (by this call,
+     * a concurrent delete or an expiry) never cause a record to be skipped.
+     * Running it to completion twice changes nothing the second time.
+     *
+     * **Custom store implementors:** custom stores own their retention and may
+     * implement this with the same contract, or leave it out. Built-ins:
+     * - `MemoryStore` and `SQLiteStore` act on their rows directly; they keep
+     *   no separate index, so `indexed` and `deadIndexEntries` are always `0`.
+     * - `RedisStore` also adds records that already carry a TTL to its expiry
+     *   index (`indexed`) and removes index entries whose record is gone
+     *   (`deadIndexEntries`).
+     */
+    applyHistoryRetention?(options: HistoryRetentionOptions): Promise<HistoryRetentionResult>;
     /** List all session IDs (used by Studio session browser). */
     listSessions?(): Promise<string[]>;
     /**
@@ -4003,6 +4059,71 @@ interface StateStore {
     close?(): Promise<void>;
     deleteCheckpoints?(executionId: string): Promise<void>;
 }
+/**
+ * Position in execution history, used to fetch the next page. Pages are
+ * ordered by `startedAt` descending, then `executionId` descending; a cursor
+ * built from the last item of one page returns the items strictly after it.
+ */
+type ExecutionCursor = {
+    startedAt: number;
+    executionId: string;
+};
+/**
+ * History retention, in **seconds**, shared by the built-in stores
+ * (`MemoryStore`, `SQLiteStore`, and the matching categories of
+ * `RedisStore`'s `ttls`).
+ *
+ * - A positive number expires the record that many seconds after it is saved.
+ * - `null` or unset keeps it forever.
+ *
+ * Windows differ per category:
+ * - `executionHistory` counts from the record's **last** save; saving the same
+ *   execution again restarts the window.
+ * - `evalHistory` counts from the row's **first** write. Saving the same eval
+ *   id again keeps the expiry it already had, and `updateEvalResult` never
+ *   changes it.
+ *
+ * Retention applies to records saved while it is configured; rows written
+ * before keep whatever expiry they had until you run
+ * {@link StateStore.applyHistoryRetention}. Custom stores own their retention.
+ */
+type HistoryTtls = {
+    executionHistory?: number | null;
+    evalHistory?: number | null;
+};
+/** Which history {@link StateStore.applyHistoryRetention} processes. */
+type HistoryRetentionKind = 'executions' | 'evals';
+/**
+ * Where {@link StateStore.applyHistoryRetention} continues from: the last
+ * record of the previous batch, oldest-first. `time` is `startedAt` for
+ * executions and `timestamp` for eval rows. Pass it back unchanged; it is
+ * plain JSON, so it can be stored between runs.
+ */
+type HistoryRetentionCursor = {
+    time: number;
+    id: string;
+};
+/** Options for {@link StateStore.applyHistoryRetention}. */
+type HistoryRetentionOptions = {
+    kind: HistoryRetentionKind;
+    /** Records examined per call. A positive integer; defaults to 500. */
+    batchSize?: number;
+    /** The `cursor` returned by the previous call. Omit or pass `null` to start. */
+    cursor?: HistoryRetentionCursor | null;
+};
+/** What one {@link StateStore.applyHistoryRetention} call did. */
+type HistoryRetentionResult = {
+    /** Records with no expiry whose window had already passed, now deleted. */
+    expired: number;
+    /** Records with no expiry that now have one. */
+    armed: number;
+    /** Records that already had an expiry, newly added to the store's expiry index (Redis). */
+    indexed: number;
+    /** Index entries whose record no longer exists, now removed (Redis). */
+    deadIndexEntries: number;
+    /** Pass to the next call, or `null` when the walk is finished. */
+    cursor: HistoryRetentionCursor | null;
+};
 /** Persisted eval history entry. */
 type EvalHistoryEntry = {
     id: string;
@@ -4187,8 +4308,21 @@ type TraceConfig = {
 /** State store configuration */
 type StateConfig = {
     store?: StateStore | 'memory' | 'sqlite';
+    /**
+     * Options for the store built by `store: 'sqlite'`: the database file and
+     * optional history retention (seconds; see `HistoryTtls`).
+     */
     sqlite?: {
         path: string;
+        ttls?: HistoryTtls;
+    };
+    /**
+     * Options for the store built by `store: 'memory'` (the default): history
+     * retention in seconds and a maximum number of execution records.
+     */
+    memory?: {
+        ttls?: HistoryTtls;
+        maxExecutions?: number;
     };
     /**
      * Maximum number of events retained in `ExecutionInfo.events` per
@@ -4212,6 +4346,21 @@ type StateConfig = {
      * integer or `Infinity`.
      */
     maxEventsPerExecution?: number;
+    /**
+     * How many recently finished runs the runtime keeps in process when the
+     * state store cannot keep execution history itself, that is, when it lacks
+     * `saveExecution` or `listExecutions`. The cache stands in for the missing
+     * methods: `getExecutions()` lists from it, and `getExecution(id)` falls
+     * back to it when the store cannot fetch by id either. The least recently
+     * used run is dropped first. (A store that saves and lists but has no
+     * `getExecution` needs no cache: by-id reads scan its listing.)
+     *
+     * The built-in stores have all three methods, so the runtime never keeps
+     * this cache for them: history is read through the store on every call.
+     *
+     * Default: 1_000. `0` turns the cache off. Must be a non-negative integer.
+     */
+    recentExecutionsCacheSize?: number;
     /**
      * When to persist execution events to the state store.
      *
@@ -4275,8 +4424,11 @@ type DiagnosticsConfig = {
     schemaOversizedTokens?: number;
     /**
      * Silence the one-time `console.warn` diagnostics (the structured
-     * `schema_diagnostic` events still fire). Also silenceable process-wide via
-     * `AXL_DIAGNOSTICS_SILENT=true`.
+     * `schema_diagnostic` events still fire). This includes the large-listing
+     * warning and the retention warning of a SQLite store the runtime creates
+     * from `state.store: 'sqlite'`; a store you construct yourself warns before
+     * the runtime exists, so use its `ttls` or the environment variable. Also
+     * silenceable process-wide via `AXL_DIAGNOSTICS_SILENT=true`.
      */
     silent?: boolean;
     /**
@@ -4738,10 +4890,7 @@ type WorkflowContextInit = {
      *    fn callbacks). Composed name: `__auto/<primitive>/<n>`.
      *
      *  Root contexts default to a fresh `{ byAgent: new Map(), root: 0 }`. */
-    autoCheckpointCounters?: {
-        byAgent: Map<string, number>;
-        root: number;
-    };
+    autoCheckpointCounters?: AutoCheckpointState;
     /** Internal: root-shared state for branch continuations that must settle
      *  before the runtime emits the workflow terminal and snapshots cost. */
     branchDrainState?: BranchDrainState;
@@ -4771,6 +4920,13 @@ type PendingDecisionResolver = {
      *  deleteExecution joins this barrier before its total store sweep. */
     cleanupFinished: Promise<void>;
 };
+/** Automatic checkpoint bookkeeping, shared by an execution's child contexts. */
+type AutoCheckpointState = {
+    byAgent: Map<string, number>;
+    root: number;
+    /** An automatic checkpoint failed to save, so none are saved from here on. */
+    saveFailed?: boolean;
+};
 /**
  * The central coordination object for all Axl primitives.
  * Carries execution state, tracing, budget tracking, and session history.
@@ -6124,8 +6280,6 @@ declare class AxlRuntime extends EventEmitter {
     private mcpManager?;
     private memoryManager?;
     private spanManager;
-    private historicalExecutions;
-    private historicalExecutionsLoadPromise;
     /** Per-session in-process serialization. Each entry is a chain of pending
      *  work for that session id — `Session.send` / `Session.stream` await the
      *  prior entry before reading history, so concurrent calls produce a
@@ -6161,12 +6315,34 @@ declare class AxlRuntime extends EventEmitter {
      *  a delete from resurrecting the (intentionally-removed) row. Entries are
      *  removed once the would-be persist has been short-circuited. */
     private pendingDeletedExecutions;
-    /** In-flight `persistExecution` chains (save → finalize). `shutdown()`
-     *  awaits these before closing the StateStore so a workflow whose abort
+    /** In-flight `persistExecution` chains (save → finalize) and crash-
+     *  recovery saves. `shutdown()` awaits these before closing the StateStore so a workflow whose abort
      *  triggers a persist-during-shutdown isn't racing a closed connection.
      *  The Set is mutated by the chain's own `.finally` so entries clear as
      *  soon as the work settles. */
     private persistInflight;
+    /** Finished runs whose history save has not settled, keyed by execution
+     *  id. Reads serve the snapshot until the save lands, so a run is visible
+     *  the moment it finishes (read-your-writes). `deleteExecution()` awaits
+     *  the entry before deleting from the store, so a save that lands late
+     *  cannot re-create a deleted run. Each entry removes itself when its save
+     *  settles (success or failure), but only if it is still the current entry
+     *  for that id, so the map holds only in-flight saves. */
+    private pendingSaves;
+    /** Recently finished runs, kept only when the store cannot save, list, or
+     *  fetch execution history itself (and the cache size is not `0`).
+     *  `undefined` for every built-in store: execution history is read through
+     *  the store on every call and never cached here. */
+    private readonly recentRuns;
+    /** Execution ids `recoverIncompleteStreams()` is working on, each with a
+     *  promise that settles when recovery is done with that id.
+     *  `deleteExecution()` awaits it, so a recovered record cannot land after
+     *  the delete. */
+    private recoveringExecutions;
+    /** Execution ids with a `deleteExecution()` in progress, with a count of
+     *  concurrent deletes. Recovery skips them: their store sweep removes the
+     *  streaming buffer it would otherwise turn back into a record. */
+    private deletingExecutions;
     /** Resolved diagnostic artifact backend, when `diagnostics.artifacts` is set. */
     private artifactStore?;
     private artifactLeaseMs;
@@ -6400,13 +6576,15 @@ declare class AxlRuntime extends EventEmitter {
     private runWorkflowBody;
     /**
      * Persist a completed/failed execution to the state store (fire-and-forget)
-     * and move it from the active executions map to the historical cache.
+     * and remove it from the active executions map. Until the save settles the
+     * run is served from `pendingSaves`; afterwards from the store (or, for a
+     * store that cannot keep history, from `recentRuns`).
      *
      * Resurrection guard: if `runtime.deleteExecution(id)` was called while
      * this execution was still running, the id will be in
-     * `pendingDeletedExecutions`. In that case we skip the save AND the
-     * historical-cache write, and finalize the streaming buffer (if any) so
-     * the buffer doesn't outlive the delete.
+     * `pendingDeletedExecutions`. In that case we skip the save AND every
+     * in-process record of the run, and finalize the streaming buffer (if any)
+     * so the buffer doesn't outlive the delete.
      */
     private persistExecution;
     /** Register a workflow with the runtime. */
@@ -6474,7 +6652,6 @@ declare class AxlRuntime extends EventEmitter {
             maxQueueBytes?: number;
         };
     }): Promise<unknown>;
-    /** Get all execution info (running + completed + historical). */
     /** Normalize an execution loaded from a `StateStore` so the
      *  historical event union holds for downstream consumers
      *  (Studio aggregators, REST routes, redaction). Custom or legacy stores
@@ -6483,7 +6660,37 @@ declare class AxlRuntime extends EventEmitter {
      *  `exec.events` and takes down dependent features. Returns a normalized
      *  copy; logs at most one warning per `executionId`. */
     private normalizeStoredExecution;
-    getExecutions(): Promise<HistoricalExecutionInfo[]>;
+    /**
+     * List executions, newest first: running runs, runs whose save is still in
+     * flight, and the history the state store holds. Ordered by `startedAt`,
+     * then `executionId`, both descending.
+     *
+     * With no options, returns every retained run. Pass `limit` for one page,
+     * and `cursor` (built from the last item of the previous page) for the
+     * page after it. Each call reads through the store, so runs finished or
+     * deleted by other runtimes sharing the store are reflected immediately.
+     * A call without `limit` that returns more than 1 000 runs warns once per
+     * process (silenced by `diagnostics.silent`); pass `limit: Infinity` to ask
+     * for everything without the warning.
+     *
+     * @throws {AxlError} `INVALID_ARGUMENT` for a `limit` that is not a positive
+     *   integer (`Infinity` means no limit) or a malformed `cursor`.
+     */
+    getExecutions(options?: {
+        limit?: number;
+        cursor?: ExecutionCursor;
+    }): Promise<HistoricalExecutionInfo[]>;
+    /**
+     * Read one page of execution history from the store: the records strictly
+     * after `cursor`, newest first, at least `limit + overlap` of them when the
+     * store holds that many (all of them when `limit` is unset).
+     *
+     * Only a store that declares `historyPaging` is handed the cursor. Any
+     * other store is listed in full and paged here: filtering the output of a
+     * store that ignored the cursor would return its first page again, and an
+     * empty page after that.
+     */
+    private listStoredExecutions;
     /**
      * Create a WorkflowContext for ad-hoc use (evals, tool testing, prototyping).
      * The context has access to the runtime's providers, state store, MCP manager,
@@ -6546,35 +6753,70 @@ declare class AxlRuntime extends EventEmitter {
      * Recover executions whose process died mid-run when `state.persist:
      * 'streaming'` was configured. Synthesizes a partial `ExecutionInfo`
      * from the streaming buffer for each — `status: 'failed'`, error
-     * `'process terminated'` — registers them in the historical cache so
-     * they show up in `getExecutions()`, persists them via the store's
-     * `saveExecution`, and finalizes the streaming buffer.
+     * `'process terminated'` — persists them via the store's
+     * `saveExecution` (so they show up in `getExecutions()`), and finalizes
+     * the streaming buffer.
      *
      * Idempotent — if the streaming buffer is already gone (or
      * `listStreamingExecutions` is empty), this is a no-op. Returns the
      * list of recovered `ExecutionInfo`s for caller introspection.
      *
-     * Wire this into your process startup AFTER `runtime.getExecutions()`
-     * has lazy-loaded the historical cache. Order matters: completed
-     * executions already in the store should not be overwritten by a
-     * stale streaming buffer that the previous process didn't get to
-     * finalize. The implementation checks the historical store before
-     * synthesizing, so a re-run is safe.
+     * A run whose final record already exists is never recovered: for each
+     * buffered id this asks the store's `getExecution(id)` and, when a record
+     * is there, only drops the leftover buffer. It does not list history, so
+     * its cost does not grow with the size of the store. A store without
+     * `getExecution` cannot be checked, and every buffered run is recovered.
+     *
+     * Wire this into process startup, before the process accepts new work:
+     * a run live in another process looks the same as a crashed one.
+     * `deleteExecution(id)` called while recovery is working on that id waits
+     * for recovery to finish with it, so the recovered record cannot outlive
+     * the delete.
      */
     recoverIncompleteStreams(): Promise<HistoricalExecutionInfo[]>;
+    /** Recover one buffered execution. Returns the synthesized record, or
+     *  `undefined` when there was nothing to recover. */
+    private recoverStreamingExecution;
     /** Abort a running execution by its ID. */
     abort(executionId: string): void;
-    /** Get execution details by ID. */
+    /**
+     * Get execution details by ID. Looks in order at running runs, runs whose
+     * save is still in flight, the state store (its `getExecution`, or a scan
+     * of its listing when it has `listExecutions` but no `getExecution`), and
+     * (only for a store that cannot list or save history) the recent-runs
+     * cache. Nothing read from the store is cached, so a run deleted or
+     * expired elsewhere is gone on the next call, and every run
+     * `getExecutions()` lists can be fetched here.
+     */
     getExecution(executionId: string): Promise<HistoricalExecutionInfo | undefined>;
+    /**
+     * By-id read for a store that lists but cannot fetch by id. A paging store
+     * is scanned page by page with the cursor, stopping at the match; any
+     * other store is listed once in full. Returns `null` when the store cannot
+     * list or does not hold the run.
+     */
+    private findInStoreListing;
+    /** The recent-runs cache stands in for listing when the store cannot list
+     *  runs, or never receives them because it cannot save. */
+    private recentRunsServeListing;
+    /** The recent-runs cache stands in for by-id reads when the store cannot
+     *  fetch or list runs (it exists only then), or never receives them because
+     *  it cannot save. */
+    private recentRunsServeReads;
     /** Save an eval result to history. */
     saveEvalResult(entry: EvalHistoryEntry): Promise<void>;
     /**
      * Delete an execution from history by id. Removes from the active map (if
-     * still running), the historical cache, the configured StateStore, AND
+     * still running), the recent-runs cache, the configured StateStore, AND
      * any execution-scoped side state — pending awaitHuman decisions,
      * resolver maps, streaming buffer registration, in-flight abort controller.
-     * Returns true if an entry was actually removed from any of the three
-     * primary surfaces (active map, historical cache, store).
+     * Returns true if the run was running, had a save in flight, or was
+     * removed from the recent-runs cache or the store.
+     *
+     * If the run has already finished but its history save has not landed
+     * yet, this method waits for that save (whether it succeeds or fails)
+     * before deleting, so the save cannot re-create the deleted record. It
+     * likewise waits for `recoverIncompleteStreams()` to finish with the id.
      *
      * In-flight handling: if the execution is still running, this method
      * **aborts** it (via the registered abort controller) AND marks the id for
@@ -6599,6 +6841,7 @@ declare class AxlRuntime extends EventEmitter {
      * (`defaultTtl` / `ttls.executionHistory`).
      */
     deleteExecution(id: string): Promise<boolean>;
+    private deleteExecutionWhileMarked;
     /**
      * Delete an eval history entry by id. Removes from in-memory cache and
      * the configured StateStore. Returns true if an entry was actually removed.
@@ -9476,6 +9719,24 @@ declare class OpenRouterTranscriptionProvider implements TranscriptionProvider {
     private resolveKey;
 }
 
+/** Options for {@link MemoryStore}. */
+type MemoryStoreOptions = {
+    /**
+     * History retention in seconds. A positive number expires a record that
+     * many seconds after it is saved; `null` or unset keeps it. See
+     * {@link HistoryTtls} for how each category's window is counted.
+     */
+    ttls?: HistoryTtls;
+    /**
+     * Maximum number of execution-history records kept. When a save goes over
+     * the limit, the oldest records in listing order (earliest `startedAt`,
+     * then lowest `executionId`) are removed. A positive integer or `Infinity`
+     * (no limit). Default: 1 000.
+     */
+    maxExecutions?: number;
+    /** Clock in epoch milliseconds, used for retention. Defaults to `Date.now`. */
+    now?: () => number;
+};
 /**
  * In-memory implementation of StateStore.
  * Fast for development and testing, but lost on process restart.
@@ -9484,6 +9745,11 @@ declare class OpenRouterTranscriptionProvider implements TranscriptionProvider {
  * status "waiting") is persisted to a temporary file so it survives restarts.
  * This is the one exception to "memory means ephemeral" — because a human
  * could take hours to respond, and losing that state is unacceptable.
+ *
+ * History can be bounded by time (`ttls`) and by count (`maxExecutions`,
+ * which keeps the newest 1 000 runs by default).
+ * Expired records are never returned and are physically removed, a bounded
+ * batch at a time, on later saves of the same kind.
  */
 declare class MemoryStore implements StateStore {
     private checkpoints;
@@ -9492,9 +9758,23 @@ declare class MemoryStore implements StateStore {
     private decisions;
     private executionStates;
     private memories;
+    /**
+     * Iteration order is last-save order: a save deletes and re-inserts its key.
+     * With one retention per store and a clock that does not run backwards, that
+     * is also expiry order, which lets the prune stop at the first live record.
+     */
     private executionHistory;
+    /** Every key in `executionHistory`, sorted oldest first in listing order. */
+    private executionOrder;
+    /**
+     * Iteration order is first-write order (a re-save keeps the key's position
+     * and its expiry), which is also expiry order for the same reason as above.
+     */
     private evalHistory;
-    constructor();
+    private readonly ttls;
+    private readonly maxExecutions;
+    private readonly now;
+    constructor(options?: MemoryStoreOptions);
     saveCheckpoint(executionId: string, name: string, data: unknown): Promise<void>;
     getCheckpoint(executionId: string, name: string): Promise<unknown | null>;
     saveSession(sessionId: string, history: ChatMessage[]): Promise<void>;
@@ -9517,18 +9797,64 @@ declare class MemoryStore implements StateStore {
     deleteMemory(scope: string, key: string): Promise<void>;
     saveExecution(execution: HistoricalExecutionInfo): Promise<void>;
     getExecution(executionId: string): Promise<HistoricalExecutionInfo | null>;
-    listExecutions(limit?: number): Promise<HistoricalExecutionInfo[]>;
+    /** Supports `listExecutions(limit, { cursor })`. */
+    readonly historyPaging = true;
+    listExecutions(limit?: number, options?: {
+        cursor?: ExecutionCursor;
+    }): Promise<HistoricalExecutionInfo[]>;
     deleteExecution(executionId: string): Promise<boolean>;
+    /**
+     * Write an eval history row. Retention counts from the row's first write:
+     * re-saving a live row keeps its expiry (and its position in expiry order).
+     * A row that has already expired is replaced as a new one.
+     */
     saveEvalResult(entry: EvalHistoryEntry): Promise<void>;
-    /** Update-only write: see `StateStore.updateEvalResult`. */
+    /** Update-only write: see `StateStore.updateEvalResult`. Never changes retention. */
     updateEvalResult(entry: EvalHistoryEntry): Promise<boolean>;
     listEvalResults(limit?: number): Promise<EvalHistoryEntry[]>;
     deleteEvalResult(id: string): Promise<boolean>;
-    /** In-memory history never expires on its own — only existence is meaningful. */
+    /** Existence plus the expiry stored at the row's first write, if any. */
     getEvalRetention(id: string): Promise<{
         exists: boolean;
         expiresAt?: number;
     }>;
+    /**
+     * See `StateStore.applyHistoryRetention`. Every record this store holds was
+     * saved under the retention it was constructed with, so in practice a run
+     * finds nothing to expire or arm; the method exists so the same maintenance
+     * code works against every built-in store. There is no separate index, so
+     * `indexed` and `deadIndexEntries` are always `0`.
+     *
+     * An armed record keeps its place in last-save order, which is also where
+     * its expiry (last save + retention) belongs, so the prune-on-save order
+     * still holds.
+     */
+    applyHistoryRetention(options: HistoryRetentionOptions): Promise<HistoryRetentionResult>;
+    /** Index of the first order key not older than `key` (binary search). */
+    private executionOrderLowerBound;
+    private insertExecutionOrder;
+    /** Remove a history record and its listing-index key. Returns whether one existed. */
+    private removeExecutionRecord;
+    /**
+     * A run leaving history through retention (expiry or `maxExecutions`) takes
+     * its leftover per-run data with it: checkpoints (kept today when a run
+     * fails), saved execution state and any streaming buffer. Pending decisions
+     * are not touched. The runtime never writes execution state, and a run is
+     * only saved to history once it has finished, so nothing still running
+     * depends on what is removed here.
+     */
+    private expireExecutionRecord;
+    /**
+     * Remove up to `PRUNE_BATCH` expired execution records, oldest save first.
+     * Stops at the first live record: Map order is last-save order, which is
+     * expiry order while the clock moves forward. If the clock steps back, a
+     * few expired records wait for a later save; reads still filter them.
+     */
+    private pruneExpiredExecutions;
+    /** Evict the oldest records in listing order until the count bound holds. */
+    private evictOverflowExecutions;
+    /** Remove up to `PRUNE_BATCH` expired eval rows, oldest first write first. */
+    private pruneExpiredEvals;
     listSessions(): Promise<string[]>;
     private streamingEvents;
     appendStreamingEvents(executionId: string, events: AxlEvent[]): Promise<void>;
@@ -9541,6 +9867,19 @@ declare class MemoryStore implements StateStore {
     private loadPersistedState;
 }
 
+/** Options for {@link SQLiteStore}. */
+type SQLiteStoreOptions = {
+    /**
+     * History retention in seconds. A positive number expires a record that
+     * many seconds after it is saved; `null` or unset keeps it. See
+     * {@link HistoryTtls} for how each category's window is counted. With
+     * `executionHistory` unset, the store warns once per process; set it (to
+     * `null` to keep history forever) to silence the warning.
+     */
+    ttls?: HistoryTtls;
+    /** Clock in epoch milliseconds, used for retention. Defaults to `Date.now`. */
+    now?: () => number;
+};
 /**
  * SQLite-backed StateStore using better-sqlite3.
  *
@@ -9552,7 +9891,9 @@ declare class MemoryStore implements StateStore {
  */
 declare class SQLiteStore implements StateStore {
     private db;
-    constructor(filePath: string);
+    private readonly ttls;
+    private readonly now;
+    constructor(filePath: string, options?: SQLiteStoreOptions);
     /**
      * Idempotent schema migration. Tracks version via `PRAGMA user_version`
      * so reopens skip applied steps. Wrapped in `BEGIN IMMEDIATE` so
@@ -9579,6 +9920,11 @@ declare class SQLiteStore implements StateStore {
      *   Existing rows remain `NULL`, the documented v1 sentinel.
      * - v5 (observation completeness): add `execution_history.observation`.
      *   Existing rows remain `NULL`, meaning they predate the contract.
+     * - v6 (history retention): add nullable `expires_at` (epoch ms) to
+     *   `execution_history` and `eval_history`. Existing rows remain `NULL`
+     *   (never expire), so an upgrade deletes nothing. The single-column
+     *   `started_at` index is replaced by `(started_at, execution_id)`, which
+     *   serves the tie-safe listing order.
      *
      * Applied BEFORE `initTables()` so the subsequent `CREATE TABLE
      * IF NOT EXISTS` runs against the post-migration column name. Fresh
@@ -9611,24 +9957,52 @@ declare class SQLiteStore implements StateStore {
     getExecutionState(executionId: string): Promise<ExecutionState | null>;
     listPendingExecutions(): Promise<string[]>;
     saveExecution(execution: HistoricalExecutionInfo): Promise<void>;
+    /**
+     * Remove up to `PRUNE_BATCH` expired execution-history rows, together with
+     * each run's leftover checkpoints and saved execution state, inside the
+     * caller's transaction. Pending decisions are not touched. The runtime
+     * never writes execution state, and a run is only saved to history once it
+     * has finished, so nothing still running depends on what is removed here.
+     */
+    private pruneExpiredExecutions;
+    /** Remove up to `PRUNE_BATCH` expired eval-history rows (caller's transaction). */
+    private pruneExpiredEvals;
     getExecution(executionId: string): Promise<HistoricalExecutionInfo | null>;
-    listExecutions(limit?: number): Promise<HistoricalExecutionInfo[]>;
+    /** Supports `listExecutions(limit, { cursor })`. */
+    readonly historyPaging = true;
+    listExecutions(limit?: number, options?: {
+        cursor?: ExecutionCursor;
+    }): Promise<HistoricalExecutionInfo[]>;
     deleteExecution(executionId: string): Promise<boolean>;
+    /**
+     * Write an eval history row. Retention counts from the row's first write:
+     * re-saving a live row keeps its `expires_at` (including none, for a row
+     * written without retention). A row that has already expired is replaced
+     * as a new one.
+     */
     saveEvalResult(entry: EvalHistoryEntry): Promise<void>;
     /**
      * Update-only write: see `StateStore.updateEvalResult`. `UPDATE ... WHERE id`
-     * touches nothing when the row is gone, where `INSERT OR REPLACE` would
-     * resurrect it — and SQLite history has no expiry, so a resurrection here is
-     * permanent.
+     * touches nothing when the row is gone or expired, where `INSERT OR REPLACE`
+     * would resurrect it. `expires_at` is left as it was.
      */
     updateEvalResult(entry: EvalHistoryEntry): Promise<boolean>;
     listEvalResults(limit?: number): Promise<EvalHistoryEntry[]>;
     deleteEvalResult(id: string): Promise<boolean>;
-    /** SQLite history has no automatic expiry — only existence is meaningful. */
+    /** Existence plus the expiry stored at the row's first write, if any. */
     getEvalRetention(id: string): Promise<{
         exists: boolean;
         expiresAt?: number;
     }>;
+    /**
+     * See `StateStore.applyHistoryRetention`. One batch runs in one immediate
+     * transaction, so no other writer can change a row between this call
+     * reading it and acting on it. Only rows whose `expires_at` is `NULL` are
+     * touched. An expired execution takes its checkpoints and saved execution
+     * state with it, as a normal expiry does. There is no separate index, so
+     * `indexed` and `deadIndexEntries` are always `0`.
+     */
+    applyHistoryRetention(options: HistoryRetentionOptions): Promise<HistoryRetentionResult>;
     listSessions(): Promise<string[]>;
     saveMemory(scope: string, key: string, value: unknown): Promise<void>;
     getMemory(scope: string, key: string): Promise<unknown | null>;
@@ -9642,6 +10016,20 @@ declare class SQLiteStore implements StateStore {
     deleteCheckpoints(executionId: string): Promise<void>;
 }
 
+/**
+ * A change in a {@link RedisStore}'s connection, passed to
+ * {@link RedisStoreOptions.onConnectionEvent}.
+ *
+ * - `error`: the connection was lost or a reconnect attempt failed. Arrives
+ *   once per attempt while Redis is down.
+ * - `reconnected`: the store is connected again and commands work.
+ */
+type RedisConnectionEvent = {
+    type: 'error';
+    error: Error;
+} | {
+    type: 'reconnected';
+};
 /** Options accepted by {@link RedisStore.create}. */
 interface RedisStoreOptions {
     /** Redis connection URL (e.g. `redis://localhost:6379`). Defaults to `redis://localhost:6379`. */
@@ -9666,6 +10054,16 @@ interface RedisStoreOptions {
      * operator experience.
      */
     keyPrefix?: string;
+    /**
+     * Called when the connection is lost, a reconnect attempt fails, or the
+     * connection comes back, for routing to a logger, metrics, or a health check.
+     * Replaces the default logging of one line per outage and one on recovery.
+     *
+     * Not called for a failed `create()`, whose rejection reports the failure,
+     * or after `close()`. A callback that throws or rejects is reported with
+     * `console.error` and otherwise ignored.
+     */
+    onConnectionEvent?: (event: RedisConnectionEvent) => void;
     /**
      * Skip the lazy backfill of legacy execution / eval-history entries into
      * the sorted-set indexes during `RedisStore.create()`. Default `false`
@@ -9720,11 +10118,19 @@ interface RedisStoreOptions {
      *   new ones) eventually ages out. If you need read-activity to count
      *   as "active," issue a no-op `ctx.remember` against a sentinel key
      *   per session turn.
-     * - **Fixed window**: `checkpoint`, `executionState`, `executionHistory`,
-     *   `evalHistory`. The TTL is set on the first write and isn't extended
-     *   on subsequent writes (via `EXPIRE ... NX`). Designed for runtime-
-     *   controlled lifecycles like executions, where the data should age
-     *   out on a schedule from creation.
+     * - **Fixed from the first write**: `checkpoint`, `streamingEvents`
+     *   (`EXPIRE ... NX`) and `evalHistory` (a re-save re-applies the remaining
+     *   `PTTL`; `updateEvalResult` uses `KEEPTTL`). Later writes never extend
+     *   the window, and an eval row that exists without a TTL stays untimed.
+     * - **Restarted on every save**: `executionState`, `executionHistory`
+     *   (`SET ... EX`). An execution record is kept for the full window after
+     *   its last save, which is normally when the run finished.
+     *
+     * `executionHistory` and `evalHistory` have the same meaning as the
+     * `ttls` option of `MemoryStore` and `SQLiteStore` (see `HistoryTtls`).
+     * With neither `executionHistory` (any value, `null` included) nor
+     * {@link defaultTtl} set, `create()` warns once per process that
+     * execution history is kept forever.
      */
     ttls?: {
         session?: number | null;
@@ -9761,10 +10167,40 @@ interface RedisStoreOptions {
  * async `RedisStore.create()` factory, which connects before returning.
  */
 declare class RedisStore implements StateStore {
-    private client;
+    private connection;
     private keyPrefix;
     private ttls;
     private constructor();
+    /**
+     * Whether the store can send commands right now, for a health check or for
+     * telling an outage from other failures when a call rejects. `false` while
+     * reconnecting and after `close()`.
+     */
+    get isConnected(): boolean;
+    /**
+     * The client for sending a command, failing immediately while disconnected.
+     *
+     * Every command goes through here because node-redis's `disableOfflineQueue`
+     * rejects single commands but not `multi().exec()`, which would wait for a
+     * reconnect attempt to fail or succeed. Nothing may `await` between
+     * `client.multi()` and `.exec()`, or a transaction could get past this check.
+     *
+     * A closed store isn't "unavailable": it falls through to node-redis's own
+     * "The client is closed" rejection.
+     */
+    private get client();
+    /**
+     * History kinds with a prune running in this process. A save skips its
+     * prune while another one of the same kind is in flight: the running one
+     * already covers the oldest expired entries. Created lazily so the
+     * instance needs no constructor state.
+     */
+    private prunesInFlight?;
+    /**
+     * Supports `listExecutions(limit, { cursor })`. A getter rather than a
+     * field so it lives on the prototype.
+     */
+    get historyPaging(): boolean;
     /**
      * Resolve the TTL for a given storage category. Returns `undefined` when
      * no TTL applies (category is `null` in resolved config, the value is
@@ -9830,6 +10266,8 @@ declare class RedisStore implements StateStore {
     private evalHistorySetKey;
     /** Sorted-set index for eval history, scored by `timestamp`. See above. */
     private evalHistoryZsetKey;
+    /** Keys and blob parsing for one kind of history. See {@link HistoryIndex}. */
+    private historyIndex;
     private memoryKey;
     private streamingEventsKey;
     private streamingIdsKey;
@@ -9855,7 +10293,9 @@ declare class RedisStore implements StateStore {
     deleteMemory(scope: string, key: string): Promise<void>;
     saveExecution(execution: HistoricalExecutionInfo): Promise<void>;
     getExecution(executionId: string): Promise<HistoricalExecutionInfo | null>;
-    listExecutions(limit?: number): Promise<HistoricalExecutionInfo[]>;
+    listExecutions(limit?: number, options?: {
+        cursor?: ExecutionCursor;
+    }): Promise<HistoricalExecutionInfo[]>;
     deleteExecution(executionId: string): Promise<boolean>;
     /**
      * Write an eval history row.
@@ -9878,7 +10318,9 @@ declare class RedisStore implements StateStore {
      * lifetime, so the race costs at most one window's length, never the window
      * itself. It also carries no Redis version floor, where `KEEPTTL` needs 6.0.
      *
-     * The index entries carry no TTL and age out lazily, as with `saveExecution`.
+     * As with `saveExecution`, a timed row is also scored in the expiry sorted
+     * set (by the expiry it carries, so a re-save keeps its score), an untimed
+     * one is taken out of it, and a bounded prune follows the save.
      */
     saveEvalResult(entry: EvalHistoryEntry): Promise<void>;
     /**
@@ -9922,13 +10364,70 @@ declare class RedisStore implements StateStore {
         expiresAt?: number;
     }>;
     /**
-     * Shared list-by-sorted-set implementation. Uses ZREVRANGEBYSCORE +
-     * MGET when the ZSET is populated (post-migration). Falls back to the
-     * legacy SET + N×GET + JS-sort path when the ZSET is empty or smaller
-     * than the SET (covers users that constructed with `skipMigration: true`
-     * before calling backfill).
+     * Shared list-by-sorted-set implementation, newest first by
+     * `(score DESC, member DESC)`, starting strictly after `cursor` when given.
+     *
+     * Fast path (the time sorted set is at least as large as the id set): walk
+     * the sorted set in chunks and MGET each chunk's blobs. Index entries whose
+     * blob is gone (expired, or deleted before the prune caught up) are skipped,
+     * and the walk keeps reading until it has `limit` live records or the set
+     * runs out, however many dead entries are in the way. Each chunk restarts
+     * at the last member read, by score and member, rather than at an offset,
+     * so entries added or removed meanwhile cannot shift the walk.
+     *
+     * Slow path (the time sorted set is behind the id set: backfill has not
+     * run): read every id with GET, then sort and apply the cursor in process.
      */
     private listHistoryByZset;
+    /**
+     * Run one prune of `index`'s kind after a save. A prune failure does not
+     * fail the save, whose MULTI already committed the record: it is reported
+     * once per process and the next save of that kind tries again. That also
+     * covers a Redis user whose ACL denies `EVAL`.
+     */
+    private pruneHistoryAfterSave;
+    private pruneHistory;
+    /**
+     * Run {@link PRUNE_HISTORY_INDEX_SCRIPT} over `ids`, at most PRUNE_BATCH
+     * per call so one script never blocks the server for long.
+     */
+    private runPruneScript;
+    /**
+     * See `StateStore.applyHistoryRetention`. One call:
+     *
+     * 1. On the first call of a walk (no cursor), backfills the time sorted
+     *    set from the id set if it is behind (see `backfillExecutionIndex`).
+     * 2. Reads the next `batchSize` ids from the time sorted set, oldest first
+     *    by `(score, member)`, strictly after the cursor. The read restarts at
+     *    the cursor's position by value, never by offset.
+     * 3. MGETs their blobs and reads each live blob's PTTL.
+     * 4. In one MULTI, for each live blob:
+     *    - a TTL (`PTTL > 0`): `ZADD NX` to the expiry set at now + PTTL. A
+     *      record already in the expiry set keeps its entry (`indexed` counts
+     *      only new entries).
+     *    - no TTL (`-1`), with a retention configured: `PEXPIREAT … NX` at last
+     *      save + retention. `NX` applies only to a key that still has no TTL,
+     *      so a record re-saved meanwhile keeps the fresh window its save gave
+     *      it. A window that has already passed uses a timestamp in the past,
+     *      which makes Redis delete the key, again only if it is still untimed.
+     * 5. Adds each newly armed record to the expiry set (`ZADD NX`).
+     * 6. Runs the prune script (`PRUNE_HISTORY_INDEX_SCRIPT`) over ids whose
+     *    blob is gone and ids just deleted in step 4. It checks each blob
+     *    atomically, so a record re-saved at any point stays listed and a
+     *    deleted one is never re-indexed.
+     *
+     * Blobs are never written. A record deleted while the call runs can leave
+     * an entry in the expiry set only; the next prune removes it.
+     */
+    applyHistoryRetention(options: HistoryRetentionOptions): Promise<HistoryRetentionResult>;
+    /**
+     * Up to `count` members of the time sorted set strictly after `cursor`,
+     * oldest first by `(score, member)`. The members sharing the cursor's score
+     * are read in full and filtered by member; the rest start just above that
+     * score. Neither read uses an offset, so entries removed or added
+     * meanwhile cannot shift the walk.
+     */
+    private readRetentionBatch;
     listSessions(): Promise<string[]>;
     appendStreamingEvents(executionId: string, events: AxlEvent[]): Promise<void>;
     finalizeStreamingEvents(executionId: string): Promise<void>;
@@ -9942,6 +10441,11 @@ declare class RedisStore implements StateStore {
      * must not get a rejected promise for it. `MemoryStore.close()` and
      * better-sqlite3's `close()` are both no-ops the second time; node-redis
      * instead rejects with "The client is closed", so absorb that here.
+     *
+     * Bounded, so a shutdown can't hang on Redis. `QUIT` lets queued commands
+     * finish on a healthy connection, but node-redis never settles it if the
+     * socket closes first, and a stalled server may never answer it. While
+     * disconnected it couldn't be sent at all.
      */
     close(): Promise<void>;
     deleteCheckpoints(executionId: string): Promise<void>;
@@ -10014,4 +10518,4 @@ declare class NoopSpanManager implements SpanManager {
  */
 declare function createSpanManager(config?: TelemetryConfig): Promise<SpanManager>;
 
-export { AXL_EVENT_TYPES, AXL_EVENT_TYPES_V2, AXL_TOOL_LIFECYCLE_TYPES_V2, AZURE_PROFILE, type Accounting, type AccountingCompleteness, type AccountingReason, type AccountingUsage, AdmissionController, AdmissionDeniedError, type Agent, type AgentCallEndData, type AgentCallInfo, type AgentCallParams, type AgentCallStartData, type AgentConfig, AnthropicProvider, type AnyWorkflow, type ApiKeySource, type ArtifactManifest, type ArtifactOwner, type ArtifactStatus, type ArtifactWriteResult, type AskOptions, type AskScoped, type AuthHeader, type AwaitHumanData, type AwaitHumanOptions, type AwaitHumanResolvedData, type AxlConfig, AxlError, type AxlEvent, type AxlEventBase, AxlEventBus, type AxlEventOf, type AxlEventType, type AxlEventV2, type AxlEventV2Of, AxlRuntime, AxlStream, BEDROCK_PROFILE, BUILTIN_PROFILES, BudgetExceededError, type BudgetOptions, type BudgetResult, CONFIG_CANDIDATES, COST_BEARING_LEAF_TYPES, type CallTiming, type CapabilityFlags, type CaptureCorrelation, type CapturedCorrection, type CapturedError, type CapturedExternalRequestRecord, type CapturedJsonValue, type CapturedMessage, type CapturedModelRequestRecord, type CapturedOperationRef, type CapturedPhase, type CapturedRequest, type CapturedRequestRecord, type CapturedResponse, type ChatMessage, type ChatOptions, type CheckpointEventData, type CoalescedPartialObject, type CostProvenance, type CreateContextOptions, DEEPSEEK_PROFILE, DEFAULT_MAX_QUEUE_BYTES, DEFAULT_MAX_RECORD_BYTES, DEFAULT_MAX_RUN_BYTES, type DecisionCleanupFailedEvent, type DelegateData, type DelegateOptions, type DiagnosticArtifactStore, type DiagnosticArtifactsConfig, type DiagnosticsConfig, type DispatchAdmission, type Effort, type EffortResolution, type EmbedResult, type EmbedUsage, type Embedder, type EvalExecuteWorkflow, type EvalHistoryEntry, type EvalProgressEventShape, type EventStreamOptions, EventStreamOverflowError, type ExecuteOptions, type ExecutionInfo, type ExecutionInfoV1, type ExecutionInfoV2, type ExecutionState, type ExternalOperationDescriptor, type ExternalOperationRecord, type ExternalOperationReport, FileDiagnosticArtifactStore, type FinishReason, type FoldedOperationRecord, GROQ_PROFILE, GeminiProvider, GeminiTranscriptionProvider, type GuardrailBlockHandler, type GuardrailData, GuardrailError, type GuardrailResult, type GuardrailsConfig, type HandoffDescriptor, type HandoffRecord, type HandoffReturnData, type HandoffStartData, type HistoricalAxlEvent, type HistoricalExecutionInfo, type HumanDecision, InMemoryVectorStore, type InputAudioPart, type InputContentPart, type InputGuardrail, type InputImagePart, type InputMediaSource, type InputModalitySupport, type InputTextPart, InvalidModelInputError, InvalidTranscriptionInputError, LLAMACPP_PROFILE, LMSTUDIO_PROFILE, type LegacyAxlEventV1, type LegacyExecutionInfoV1, MAX_INLINE_MODEL_INPUT_BYTES, MAX_INLINE_TRANSCRIPTION_BYTES, MISTRAL_PROFILE, type MapOptions, MaxTurnsError, McpManager, type McpServer, type McpServerConfig, type McpToolDefinition, type McpToolResult, type MemoryConfig, type MemoryEventData, MemoryManager, MemoryStore, type ModelCallRecord, type ModelInput, type ModelInputDescriptor, type ModelTimingRollup, NoConsensus, NoopSpanManager, OLLAMA_PROFILE, OPENAI_PRICING, OPENAI_PROFILE, OPENROUTER_PROFILE, type ObservationStatus, type OpenAICompatibleOptions, OpenAICompatibleProvider, OpenAIEmbedder, OpenAIProvider, OpenAIResponsesProvider, OpenAITranscriptionProvider, OpenRouterTranscriptionProvider, type OpenedArtifact, type OperationKind, type OperationPurpose, type OutputGuardrail, type OutputValidator, type PendingDecision, type PerModel, type PricingSource, type PricingTable, type ProfileInputModalities, type Provider, type ProviderAdapter, type ProviderDiagnosticData, ProviderError, type ProviderInputValidationRequest, type ProviderInputValidationResult, type ProviderProfile, ProviderRegistry, type ProviderResponse, QuorumNotMet, REDACTED, REDACTION_RULES, type RaceOptions, type RateLimitConfig, RateLimiter, type ReasoningCapture, type ReasoningContextReset, type ReasoningEmit, type ReasoningProfile, type ReasoningRoundTrip, type RecallOptions, type RecallResult, type RecordedAudioSource, RedisStore, type RememberOptions, type RememberResult, RequestCaptureChannel, type RequestCaptureOptions, type RequestCaptureSink, type RequestCaptureStatus, type ResolvedThinkingOptions, type Result, type RetryFeedbackHook, type RetryFeedbackInfo, type RetryFeedbackResult, type RetryPolicy, type RuntimeEvalConfigShape, SGLANG_PROFILE, SQLiteStore, type SchemaCheckData, type SchemaDiagnosticData, type SchemaPromptOption, Session, type SessionOptions, type SpanAttributeValue, type SpanAttributes, type SpanHandle, type SpanManager, type SpawnOptions, SqliteVectorStore, type StagedArtifact, StallTimeoutError, type StateStore, type StreamChunk, type StringDeltaData, type StringStreamEvent, type StringStreamFilter, type TelemetryConfig, ThinkTagScanner, type TimeoutBreakdown, TimeoutError, type Tool, type ToolApprovalData, type ToolArgumentIssue, type ToolCallCancellation, type ToolCallData, type ToolCallEndData, type ToolCallFailure, type ToolCallMessage, type ToolCallOutcome, type ToolCallRejectedData, type ToolCallRejectedEvent, type ToolCallStartData, type ToolCallStartDataV2, type ToolChoice, type ToolConfig, type ToolDeniedData, type ToolEventError, ToolFailure, type ToolFailureConstructor, type ToolFailureOptions, type ToolHooks, type ToolLifecycleEventV2, type ToolModelOutput, ToolModelOutputError, type TrackExecutionMetadata, type TrackExecutionResult, type TrackOutcomeOptions, type TrackedOutcome, type Transcript, type TranscriptionCapabilities, TranscriptionOperationError, type TranscriptionProvider, TranscriptionProviderRegistry, type TranscriptionProviderRequest, type TranscriptionProviderResult, type TranscriptionRequest, UnsupportedEventSchemaVersionError, UnsupportedModelInputError, UnsupportedModelOptionError, UnsupportedTranscriptionInputError, VLLM_PROFILE, type ValidateData, type ValidateResult, ValidationError, type VectorEntry, type VectorResult, type VectorStore, type VerifyData, VerifyError, type VerifyOptions, type VerifyRetry, type VoteOptions, type Workflow, type WorkflowConfig, WorkflowContext, type WorkflowContextInit, type WorkflowEndData, type WorkflowStartData, XAI_PROFILE, agent, capturedJournalLineSchema, createSpanManager, defineConfig, estimateOpenAICost, eventCostContribution, expandGlob, externalOperation, externalOperationRecordSchema, extractJson, extractThinkTags, findConfig, foldJournal, foldedOperationRecordSchema, getEventSchemaVersion, getExecutionEventSchemaVersion, hasPositiveBillableWork, hasPositiveTokens, importModule, inputText, isAdmissionDeniedError, isCostBearingLeaf, isRetryableStatus, isRootLevel, isUnpricedLeaf, isUsableCost, modelCallRecordSchema, needsTsxLoader, normalizeStoredExecution, openaiReasoningEmit, parsePartialJson, pickDefault, pickExport, priceFromTable, reasoningEffortEmit, reasoningObjectEmit, redactCapturedRequest, redactEvent, redactHistoricalEvent, redactModelCallRecord, registerConditions, resolveApiKey, resolvePerModel, resolveRuntime, resolveThinkingOptions, stringStreamFromEvents, summarizeModelInput, tool, workflow, zodToJsonSchema };
+export { AXL_EVENT_TYPES, AXL_EVENT_TYPES_V2, AXL_TOOL_LIFECYCLE_TYPES_V2, AZURE_PROFILE, type Accounting, type AccountingCompleteness, type AccountingReason, type AccountingUsage, AdmissionController, AdmissionDeniedError, type Agent, type AgentCallEndData, type AgentCallInfo, type AgentCallParams, type AgentCallStartData, type AgentConfig, AnthropicProvider, type AnyWorkflow, type ApiKeySource, type ArtifactManifest, type ArtifactOwner, type ArtifactStatus, type ArtifactWriteResult, type AskOptions, type AskScoped, type AuthHeader, type AwaitHumanData, type AwaitHumanOptions, type AwaitHumanResolvedData, type AxlConfig, AxlError, type AxlEvent, type AxlEventBase, AxlEventBus, type AxlEventOf, type AxlEventType, type AxlEventV2, type AxlEventV2Of, AxlRuntime, AxlStream, BEDROCK_PROFILE, BUILTIN_PROFILES, BudgetExceededError, type BudgetOptions, type BudgetResult, CONFIG_CANDIDATES, COST_BEARING_LEAF_TYPES, type CallTiming, type CapabilityFlags, type CaptureCorrelation, type CapturedCorrection, type CapturedError, type CapturedExternalRequestRecord, type CapturedJsonValue, type CapturedMessage, type CapturedModelRequestRecord, type CapturedOperationRef, type CapturedPhase, type CapturedRequest, type CapturedRequestRecord, type CapturedResponse, type ChatMessage, type ChatOptions, type CheckpointEventData, type CoalescedPartialObject, type CostProvenance, type CreateContextOptions, DEEPSEEK_PROFILE, DEFAULT_MAX_QUEUE_BYTES, DEFAULT_MAX_RECORD_BYTES, DEFAULT_MAX_RUN_BYTES, type DecisionCleanupFailedEvent, type DelegateData, type DelegateOptions, type DiagnosticArtifactStore, type DiagnosticArtifactsConfig, type DiagnosticsConfig, type DispatchAdmission, type Effort, type EffortResolution, type EmbedResult, type EmbedUsage, type Embedder, type EvalExecuteWorkflow, type EvalHistoryEntry, type EvalProgressEventShape, type EventStreamOptions, EventStreamOverflowError, type ExecuteOptions, type ExecutionCursor, type ExecutionInfo, type ExecutionInfoV1, type ExecutionInfoV2, type ExecutionState, type ExternalOperationDescriptor, type ExternalOperationRecord, type ExternalOperationReport, FileDiagnosticArtifactStore, type FinishReason, type FoldedOperationRecord, GROQ_PROFILE, GeminiProvider, GeminiTranscriptionProvider, type GuardrailBlockHandler, type GuardrailData, GuardrailError, type GuardrailResult, type GuardrailsConfig, type HandoffDescriptor, type HandoffRecord, type HandoffReturnData, type HandoffStartData, type HistoricalAxlEvent, type HistoricalExecutionInfo, type HistoryRetentionCursor, type HistoryRetentionKind, type HistoryRetentionOptions, type HistoryRetentionResult, type HistoryTtls, type HumanDecision, InMemoryVectorStore, type InputAudioPart, type InputContentPart, type InputGuardrail, type InputImagePart, type InputMediaSource, type InputModalitySupport, type InputTextPart, InvalidModelInputError, InvalidTranscriptionInputError, LLAMACPP_PROFILE, LMSTUDIO_PROFILE, type LegacyAxlEventV1, type LegacyExecutionInfoV1, MAX_INLINE_MODEL_INPUT_BYTES, MAX_INLINE_TRANSCRIPTION_BYTES, MISTRAL_PROFILE, type MapOptions, MaxTurnsError, McpManager, type McpServer, type McpServerConfig, type McpToolDefinition, type McpToolResult, type MemoryConfig, type MemoryEventData, MemoryManager, MemoryStore, type MemoryStoreOptions, type ModelCallRecord, type ModelInput, type ModelInputDescriptor, type ModelTimingRollup, NoConsensus, NoopSpanManager, OLLAMA_PROFILE, OPENAI_PRICING, OPENAI_PROFILE, OPENROUTER_PROFILE, type ObservationStatus, type OpenAICompatibleOptions, OpenAICompatibleProvider, OpenAIEmbedder, OpenAIProvider, OpenAIResponsesProvider, OpenAITranscriptionProvider, OpenRouterTranscriptionProvider, type OpenedArtifact, type OperationKind, type OperationPurpose, type OutputGuardrail, type OutputValidator, type PendingDecision, type PerModel, type PricingSource, type PricingTable, type ProfileInputModalities, type Provider, type ProviderAdapter, type ProviderDiagnosticData, ProviderError, type ProviderInputValidationRequest, type ProviderInputValidationResult, type ProviderProfile, ProviderRegistry, type ProviderResponse, QuorumNotMet, REDACTED, REDACTION_RULES, type RaceOptions, type RateLimitConfig, RateLimiter, type ReasoningCapture, type ReasoningContextReset, type ReasoningEmit, type ReasoningProfile, type ReasoningRoundTrip, type RecallOptions, type RecallResult, type RecordedAudioSource, type RedisConnectionEvent, RedisStore, type RedisStoreOptions, type RememberOptions, type RememberResult, RequestCaptureChannel, type RequestCaptureOptions, type RequestCaptureSink, type RequestCaptureStatus, type ResolvedThinkingOptions, type Result, type RetryFeedbackHook, type RetryFeedbackInfo, type RetryFeedbackResult, type RetryPolicy, type RuntimeEvalConfigShape, SGLANG_PROFILE, SQLiteStore, type SQLiteStoreOptions, type SchemaCheckData, type SchemaDiagnosticData, type SchemaPromptOption, Session, type SessionOptions, type SpanAttributeValue, type SpanAttributes, type SpanHandle, type SpanManager, type SpawnOptions, SqliteVectorStore, type StagedArtifact, StallTimeoutError, type StateStore, type StreamChunk, type StringDeltaData, type StringStreamEvent, type StringStreamFilter, type TelemetryConfig, ThinkTagScanner, type TimeoutBreakdown, TimeoutError, type Tool, type ToolApprovalData, type ToolArgumentIssue, type ToolCallCancellation, type ToolCallData, type ToolCallEndData, type ToolCallFailure, type ToolCallMessage, type ToolCallOutcome, type ToolCallRejectedData, type ToolCallRejectedEvent, type ToolCallStartData, type ToolCallStartDataV2, type ToolChoice, type ToolConfig, type ToolDeniedData, type ToolEventError, ToolFailure, type ToolFailureConstructor, type ToolFailureOptions, type ToolHooks, type ToolLifecycleEventV2, type ToolModelOutput, ToolModelOutputError, type TrackExecutionMetadata, type TrackExecutionResult, type TrackOutcomeOptions, type TrackedOutcome, type Transcript, type TranscriptionCapabilities, TranscriptionOperationError, type TranscriptionProvider, TranscriptionProviderRegistry, type TranscriptionProviderRequest, type TranscriptionProviderResult, type TranscriptionRequest, UnsupportedEventSchemaVersionError, UnsupportedModelInputError, UnsupportedModelOptionError, UnsupportedTranscriptionInputError, VLLM_PROFILE, type ValidateData, type ValidateResult, ValidationError, type VectorEntry, type VectorResult, type VectorStore, type VerifyData, VerifyError, type VerifyOptions, type VerifyRetry, type VoteOptions, type Workflow, type WorkflowConfig, WorkflowContext, type WorkflowContextInit, type WorkflowEndData, type WorkflowStartData, XAI_PROFILE, agent, capturedJournalLineSchema, createSpanManager, defineConfig, estimateOpenAICost, eventCostContribution, expandGlob, externalOperation, externalOperationRecordSchema, extractJson, extractThinkTags, findConfig, foldJournal, foldedOperationRecordSchema, getEventSchemaVersion, getExecutionEventSchemaVersion, hasPositiveBillableWork, hasPositiveTokens, importModule, inputText, isAdmissionDeniedError, isCostBearingLeaf, isRetryableStatus, isRootLevel, isUnpricedLeaf, isUsableCost, modelCallRecordSchema, needsTsxLoader, normalizeStoredExecution, openaiReasoningEmit, parsePartialJson, pickDefault, pickExport, priceFromTable, reasoningEffortEmit, reasoningObjectEmit, redactCapturedRequest, redactEvent, redactHistoricalEvent, redactModelCallRecord, registerConditions, resolveApiKey, resolvePerModel, resolveRuntime, resolveThinkingOptions, stringStreamFromEvents, summarizeModelInput, tool, workflow, zodToJsonSchema };