@axlsdk/axl 0.17.6 → 0.17.7

package/dist/index.d.cts

@@ -855,6 +855,14 @@ type ExecutionInfo = {
     duration: number;
     result?: unknown;
     error?: string;
+    /** Caller-supplied metadata threaded verbatim from `ExecuteOptions.metadata`
+     *  (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. */
+    metadata?: Record<string, unknown>;
 };
 /** Record of an agent handoff event (persisted in session metadata).
  *
@@ -1447,6 +1455,30 @@ interface StateStore {
     getExecution?(executionId: string): Promise<ExecutionInfo | null>;
     /** List recent executions (most recent first). */
     listExecutions?(limit?: number): Promise<ExecutionInfo[]>;
+    /**
+     * 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-
+     * forgotten and operator-driven cleanup. Symmetric to `deleteEvalResult`.
+     *
+     * **Custom store implementors:** This delete must be **total** —
+     * sweep every per-execution surface your store maintains. The runtime's
+     * `runtime.deleteExecution` does NOT call separate `deleteCheckpoints` /
+     * `deleteExecutionState` / `finalizeStreamingEvents` after this; one
+     * call should clean EVERYTHING owned by the executionId. The built-in
+     * stores remove:
+     *   - the canonical execution-history row and its indexes,
+     *   - all checkpoints for the id,
+     *   - the suspended-state row + its pending-set membership,
+     *   - the streaming-event buffer + its in-flight-ids membership,
+     *   - any pending awaitHuman decision row.
+     * Skipping any of these leaks PII through `recoverIncompleteStreams()`
+     * or `getPendingDecisions()`, breaking the GDPR delete contract.
+     *
+     * For multi-table SQL stores: wrap the deletes in a transaction. For
+     * Redis-style stores: use MULTI/EXEC. Idempotency is required —
+     * deleting an unknown id returns `false` without throwing.
+     */
+    deleteExecution?(executionId: string): Promise<boolean>;
     /** Save an eval result to history. */
     saveEvalResult?(entry: EvalHistoryEntry): Promise<void>;
     /** List eval history entries (most recent first). */
@@ -1455,6 +1487,31 @@ interface StateStore {
     deleteEvalResult?(id: string): Promise<boolean>;
     /** List all session IDs (used by Studio session browser). */
     listSessions?(): Promise<string[]>;
+    /**
+     * Append a batch of events to the streaming buffer for an execution.
+     * Should be idempotent w.r.t. the executionId being new vs existing
+     * (first call also registers the id in the "in-flight" index used by
+     * `listStreamingExecutions`).
+     */
+    appendStreamingEvents?(executionId: string, events: AxlEvent[]): Promise<void>;
+    /**
+     * Finalize a streaming execution — delete its buffer + un-register it
+     * from the in-flight index. Called by the runtime after the canonical
+     * `executionHistory` blob has been written, so the streaming buffer
+     * is no longer the source of truth for this execution.
+     */
+    finalizeStreamingEvents?(executionId: string): Promise<void>;
+    /**
+     * List execution IDs that have a streaming buffer but no corresponding
+     * completed `executionHistory` — i.e., runs whose process died mid-flight.
+     * The runtime calls this from `recoverIncompleteStreams()`.
+     */
+    listStreamingExecutions?(): Promise<string[]>;
+    /**
+     * Read the events accumulated in the streaming buffer for an execution.
+     * Returns `[]` if no buffer exists.
+     */
+    getStreamingEvents?(executionId: string): Promise<AxlEvent[]>;
     close?(): Promise<void>;
     deleteCheckpoints?(executionId: string): Promise<void>;
 }
@@ -1632,6 +1689,44 @@ type StateConfig = {
      * integer or `Infinity`.
      */
     maxEventsPerExecution?: number;
+    /**
+     * When to persist execution events to the state store.
+     *
+     * - `'terminal'` (default, back-compat) — events are buffered in memory
+     *   and written to `executionHistory` only at the terminal `done`/`error`
+     *   event. Fastest path; if the process crashes mid-run, the events are
+     *   lost. Fine for development and short-running workflows.
+     *
+     * - `'streaming'` — events are batched and written to a streaming buffer
+     *   throughout the run (via `StateStore.appendStreamingEvents`), then the
+     *   buffer is finalized when the canonical `executionHistory` is saved at
+     *   terminal exit. If the process crashes mid-run, call
+     *   `runtime.recoverIncompleteStreams()` on the next process to reconstruct
+     *   the partial `ExecutionInfo` from the streaming buffer (status: `'failed'`,
+     *   error: `'process terminated'`). Use this in production when you need to
+     *   know "what did the workflow do up to the crash."
+     *
+     * Excluded from streaming flush even in `'streaming'` mode: `token`,
+     * `partial_object`, `string_delta` (high-volume, reconstructable from
+     * the persisted `agent_call_end.data`).
+     */
+    persist?: 'terminal' | 'streaming';
+    /**
+     * Number of events buffered before flushing to the streaming store.
+     * Default `100`. Set to `1` for per-event flush (highest durability,
+     * one Redis round-trip per emit — adds latency proportional to RTT).
+     *
+     * Only meaningful when `persist === 'streaming'`.
+     */
+    streamingBatchSize?: number;
+    /**
+     * Max milliseconds between flushes when the batch hasn't filled up.
+     * Default `1000`. Together with `streamingBatchSize`, bounds the
+     * "events lost on crash" window to `min(batchSize-of-events, interval-of-time)`.
+     *
+     * Only meaningful when `persist === 'streaming'`.
+     */
+    streamingBatchInterval?: number;
 };
 /** Global defaults */
 type DefaultsConfig = {
@@ -2762,6 +2857,30 @@ declare class AxlRuntime extends EventEmitter {
      *  `events` field — keeps the log to one line per row instead of one per
      *  rebuild tick. */
     private warnedMalformedExecutions;
+    /** Streaming-mode flusher. `undefined` when persist === 'terminal'
+     *  (back-compat default — no buffering overhead, no batching timer). */
+    private streamingFlusher?;
+    /** Execution IDs that are eligible for streaming-buffer durability —
+     *  populated by `execute()` / `stream()`. `createContext()` flows are
+     *  deliberately NOT added: ad-hoc contexts (tool tests, Studio playground,
+     *  evals) have no terminal `persistExecution` path that would finalize the
+     *  streaming buffer, so allowing them to write would leave phantom orphan
+     *  buffers that `recoverIncompleteStreams()` later mis-recovers as failed
+     *  executions. Membership is removed in `persistExecution` once the
+     *  canonical save + finalize chain has been scheduled. */
+    private streamableExecutionIds;
+    /** Execution IDs deleted by `runtime.deleteExecution()` while still in
+     *  flight. `persistExecution` skips its save + cache write when the
+     *  executionId is in this set — preventing a workflow that completes after
+     *  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
+     *  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;
     constructor(config?: AxlConfig);
     /**
      * Whether `config.trace.redact` is enabled on this runtime. A narrow
@@ -2824,6 +2943,12 @@ declare class AxlRuntime extends EventEmitter {
     /**
      * Persist a completed/failed execution to the state store (fire-and-forget)
      * and move it from the active executions map to the historical cache.
+     *
+     * 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.
      */
     private persistExecution;
     /** Register a workflow with the runtime. */
@@ -2932,18 +3057,76 @@ declare class AxlRuntime extends EventEmitter {
      *  before invoking `shutdown()`. A `Session.send` invoked after the
      *  drain snapshot is taken can still race a closed state store. */
     shutdown(): Promise<void>;
+    /**
+     * 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.
+     *
+     * 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.
+     */
+    recoverIncompleteStreams(): Promise<ExecutionInfo[]>;
     /** Abort a running execution by its ID. */
     abort(executionId: string): void;
     /** Get execution details by ID. */
     getExecution(executionId: string): Promise<ExecutionInfo | undefined>;
     /** 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
+     * 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).
+     *
+     * In-flight handling: if the execution is still running, this method
+     * **aborts** it (via the registered abort controller) AND marks the id for
+     * skip-on-persist so the workflow's eventual `workflow_end` doesn't
+     * resurrect the row. The workflow itself terminates normally — callers
+     * iterating the returned `AxlStream` will see the abort flow through. If
+     * you need a hard hand-off (delete completes before the workflow tears
+     * down), call `runtime.abort(id)` and `await` the stream/execute promise
+     * before calling this. `streamableExecutionIds` is cleared eagerly so
+     * events emitted during the wind-down don't re-create the streaming
+     * buffer in the store after the deleteExecution-issued DEL.
+     *
+     * Audit trail: emits `execution_deleted` on the runtime's `EventEmitter`
+     * with `{ executionId, wasActive, hadPendingDecision }` so compliance
+     * apps can subscribe via `runtime.on('execution_deleted', ...)` for a
+     * "who deleted what when" log without wrapping this method. Fires
+     * regardless of whether the id was actually present.
+     *
+     * Use cases: GDPR right-to-be-forgotten, operator-driven cleanup of
+     * specific runs (e.g. a workflow that recorded PII the user requested
+     * scrubbed). For bulk eviction by age, use a `RedisStore` TTL instead
+     * (`defaultTtl` / `ttls.executionHistory`).
+     */
+    deleteExecution(id: string): Promise<boolean>;
     /**
      * Delete an eval history entry by id. Removes from in-memory cache and
      * the configured StateStore. Returns true if an entry was actually removed.
      *
      * Ensures lazy-loaded history is loaded first so the in-memory cache and
      * the store can't drift apart on the deletion path.
+     *
+     * Emits `eval_deleted` on the runtime's `EventEmitter` with
+     * `{ id, eval, removed }`. Fires on every call — including attempts
+     * against unknown ids (`removed: false`) — symmetric to `execution_deleted`.
+     * Studio's eval-trends aggregator subscribes to this event so deleted
+     * runs don't linger in the trends panel for up to 5 minutes (until the
+     * next periodic rebuild).
      */
     deleteEvalResult(id: string): Promise<boolean>;
     /** Get eval result history (most recent first). */
@@ -3775,10 +3958,16 @@ declare class MemoryStore implements StateStore {
     saveExecution(execution: ExecutionInfo): Promise<void>;
     getExecution(executionId: string): Promise<ExecutionInfo | null>;
     listExecutions(limit?: number): Promise<ExecutionInfo[]>;
+    deleteExecution(executionId: string): Promise<boolean>;
     saveEvalResult(entry: EvalHistoryEntry): Promise<void>;
     listEvalResults(limit?: number): Promise<EvalHistoryEntry[]>;
     deleteEvalResult(id: string): Promise<boolean>;
     listSessions(): Promise<string[]>;
+    private streamingEvents;
+    appendStreamingEvents(executionId: string, events: AxlEvent[]): Promise<void>;
+    finalizeStreamingEvents(executionId: string): Promise<void>;
+    listStreamingExecutions(): Promise<string[]>;
+    getStreamingEvents(executionId: string): Promise<AxlEvent[]>;
     close(): Promise<void>;
     deleteCheckpoints(executionId: string): Promise<void>;
     private persistAwaitHumanState;
@@ -3815,6 +4004,10 @@ declare class SQLiteStore implements StateStore {
      *   numeric step values become stringified names ("0", "1", …) to
      *   preserve replay continuity for in-flight executions across the
      *   upgrade boundary.
+     * - v3 (ExecutionInfo.metadata): add `execution_history.metadata`
+     *   column (TEXT, nullable, JSON-serialized) so caller-supplied
+     *   `ExecuteOptions.metadata` round-trips through history. Existing
+     *   rows get `NULL`, deserialized as `metadata: undefined`.
      *
      * Applied BEFORE `initTables()` so the subsequent `CREATE TABLE
      * IF NOT EXISTS` runs against the post-migration column name. Fresh
@@ -3849,6 +4042,7 @@ declare class SQLiteStore implements StateStore {
     saveExecution(execution: ExecutionInfo): Promise<void>;
     getExecution(executionId: string): Promise<ExecutionInfo | null>;
     listExecutions(limit?: number): Promise<ExecutionInfo[]>;
+    deleteExecution(executionId: string): Promise<boolean>;
     saveEvalResult(entry: EvalHistoryEntry): Promise<void>;
     listEvalResults(limit?: number): Promise<EvalHistoryEntry[]>;
     deleteEvalResult(id: string): Promise<boolean>;
@@ -3865,6 +4059,115 @@ declare class SQLiteStore implements StateStore {
     deleteCheckpoints(executionId: string): Promise<void>;
 }
 
+/** Options accepted by {@link RedisStore.create}. */
+interface RedisStoreOptions {
+    /** Redis connection URL (e.g. `redis://localhost:6379`). Defaults to `redis://localhost:6379`. */
+    url?: string;
+    /**
+     * Prefix prepended to every Redis key written by this store. Defaults to
+     * `'axl:'`. Useful when multiple Axl deployments share a Redis cluster
+     * (e.g. `'axl:prod:'` vs `'axl:staging:'`) or when coexisting with other
+     * applications' keys.
+     *
+     * The prefix is concatenated as-given — no normalization. If you want a
+     * trailing colon, include it. Whitespace and unusual characters are
+     * accepted as-is. Only the empty string is rejected, to prevent accidental
+     * collisions with non-Axl keys.
+     *
+     * Operator note: Redis SCAN/KEYS patterns interpret `*`, `?`, and `[`/`]`
+     * as glob meta-characters. If your prefix contains any of these, the
+     * runtime accepts it (literal SET/HSET/etc. don't use globs and round-
+     * trip cleanly), but operators trying to clean up with
+     * `redis-cli SCAN 0 MATCH '<prefix>*'` will need to escape them. Stick
+     * to alphanumerics, hyphens, underscores, and colons for the best
+     * operator experience.
+     */
+    keyPrefix?: string;
+    /**
+     * Skip the lazy backfill of legacy execution / eval-history entries into
+     * the sorted-set indexes during `RedisStore.create()`. Default `false`
+     * (backfill runs on startup, one MULTI per 500-entry chunk plus two
+     * probes — cheap when there's nothing to do).
+     *
+     * Set to `true` for installs at six-figure execution counts where the
+     * startup cost is unacceptable. Until you call `backfillExecutionIndex()` /
+     * `backfillEvalIndex()` manually (e.g. during a maintenance window),
+     * `listExecutions` / `listEvalResults` fall back to the legacy
+     * SET + N×GET + JS-sort read path — correct but slow at scale.
+     */
+    skipMigration?: boolean;
+    /**
+     * Default TTL in **seconds** applied to every storage category that has
+     * a TTL-capable storage shape. Omitted by default — keys never expire,
+     * matching pre-#3 behavior.
+     *
+     * Per-category overrides via {@link ttls} take precedence. Set a category
+     * to `null` in {@link ttls} to opt that category out of the default.
+     *
+     * Strongly recommended in production: without a TTL every save accumulates
+     * forever and your Redis instance will eventually OOM.
+     *
+     * @example
+     * ```ts
+     * await RedisStore.create({
+     *   url: 'redis://localhost:6379',
+     *   defaultTtl: 60 * 60 * 24 * 30, // 30 days
+     * });
+     * ```
+     */
+    defaultTtl?: number;
+    /**
+     * Per-category TTL overrides in **seconds**. Use to assign different
+     * lifetimes per category (e.g. short-lived checkpoints, long-lived eval
+     * history). Set a category to `null` to explicitly disable TTL for it
+     * even when {@link defaultTtl} is set. Omitting a category means it falls
+     * back to {@link defaultTtl} (or no TTL if neither is set).
+     *
+     * `pendingDecision` is intentionally NOT in this map — pending decisions
+     * are stored as fields of a shared hash (`axl:decisions`), so a TTL on
+     * that key would expire ALL pending decisions at once, which is almost
+     * never what you want. Resolve decisions individually via
+     * `resolveDecision()` instead.
+     *
+     * Window semantics:
+     * - **Sliding window** (write-only refresh): `memory`, `session`,
+     *   `sessionMeta`. Every write resets the TTL, so active *writers* keep
+     *   their data and inactive ones forget. Reads do NOT refresh the TTL —
+     *   a read-only workload (e.g. agent recalling memories without writing
+     *   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.
+     */
+    ttls?: {
+        session?: number | null;
+        sessionMeta?: number | null;
+        checkpoint?: number | null;
+        executionState?: number | null;
+        executionHistory?: number | null;
+        evalHistory?: number | null;
+        memory?: number | null;
+        /**
+         * TTL for the `state.persist: 'streaming'` per-execution event buffer
+         * (`exec-events:{id}` list). Safety net for the scenario where the
+         * operator forgets to wire `runtime.recoverIncompleteStreams()` into
+         * startup — without this TTL, orphaned buffers from crashed
+         * processes accumulate indefinitely. Default `null` (no TTL —
+         * matches pre-streaming-mode behavior; explicit opt-in for the
+         * safety net so recovery isn't surprised by buffers that aged out).
+         *
+         * **MUST be longer than your recovery cadence.** If you restart
+         * processes every 12h and the buffer TTL is 1h, any crash whose
+         * recovery hasn't fired within the hour loses its events to TTL
+         * eviction. Recommended floor: 24× your max time-between-restarts.
+         */
+        streamingEvents?: number | null;
+    };
+}
 /**
  * Redis-backed StateStore using the official `redis` (node-redis) client.
  *
@@ -3876,23 +4179,77 @@ declare class SQLiteStore implements StateStore {
  */
 declare class RedisStore implements StateStore {
     private client;
+    private keyPrefix;
+    private ttls;
     private constructor();
+    /**
+     * Resolve the TTL for a given storage category. Returns `undefined` when
+     * no TTL applies (category is `null` in resolved config, the value is
+     * non-positive — Redis EXPIRE 0 immediately deletes, which is almost
+     * never intended — or the value is non-finite).
+     *
+     * Non-finite values (`NaN`, `±Infinity`) defensively map to `undefined`
+     * rather than being passed to Redis, where they'd surface as a wire-level
+     * protocol error at the worst possible time (first write under load).
+     */
+    private ttlFor;
     /**
      * Create a connected RedisStore instance.
      *
-     * @param url - Redis connection URL (e.g. `redis://localhost:6379`). Defaults to `redis://localhost:6379`.
+     * Accepts either a URL string (back-compat) or a {@link RedisStoreOptions}
+     * object. The object form is required to set a custom `keyPrefix`.
+     *
+     * @example
+     * ```ts
+     * // Default prefix 'axl:'
+     * const store = await RedisStore.create('redis://localhost:6379');
+     *
+     * // Custom prefix for shared-cluster deployments
+     * const store = await RedisStore.create({
+     *   url: 'redis://localhost:6379',
+     *   keyPrefix: 'axl:prod:',
+     * });
+     * ```
+     */
+    static create(options?: string | RedisStoreOptions): Promise<RedisStore>;
+    /**
+     * Backfill the execution-history sorted-set from the legacy ID set.
+     * Idempotent — runs only if the ZSET is missing entries the SET has.
+     * Safe to call manually if you constructed the store with
+     * `skipMigration: true`.
      */
-    static create(url?: string): Promise<RedisStore>;
+    backfillExecutionIndex(): Promise<void>;
+    /** Backfill the eval-history sorted-set. Symmetric to `backfillExecutionIndex`. */
+    backfillEvalIndex(): Promise<void>;
+    /**
+     * Shared implementation for both backfill paths. Reads SET members,
+     * batch-MGETs their data blobs in chunks, and ZADDs each into the new
+     * sorted-set inside a single MULTI per chunk.
+     */
+    private backfillHistoryIndex;
     private checkpointKey;
     private sessionKey;
     private sessionMetaKey;
+    private sessionIdsKey;
     private decisionsKey;
     private executionStateKey;
     private pendingExecSetKey;
     private execHistoryKey;
     private execHistorySetKey;
+    /**
+     * Sorted-set index for execution history, scored by `startedAt`. Drives
+     * the O(log N) `listExecutions` fast path; the legacy SET above is kept
+     * as a fallback for users running with `skipMigration: true` before
+     * they've called `backfillExecutionIndex()` manually.
+     */
+    private execHistoryZsetKey;
     private evalHistoryKey;
     private evalHistorySetKey;
+    /** Sorted-set index for eval history, scored by `timestamp`. See above. */
+    private evalHistoryZsetKey;
+    private memoryKey;
+    private streamingEventsKey;
+    private streamingIdsKey;
     saveCheckpoint(executionId: string, name: string, data: unknown): Promise<void>;
     getCheckpoint(executionId: string, name: string): Promise<unknown | null>;
     saveSession(sessionId: string, history: ChatMessage[]): Promise<void>;
@@ -3906,13 +4263,33 @@ declare class RedisStore implements StateStore {
     saveExecutionState(executionId: string, state: ExecutionState): Promise<void>;
     getExecutionState(executionId: string): Promise<ExecutionState | null>;
     listPendingExecutions(): Promise<string[]>;
+    saveMemory(scope: string, key: string, value: unknown): Promise<void>;
+    getMemory(scope: string, key: string): Promise<unknown | null>;
+    getAllMemory(scope: string): Promise<Array<{
+        key: string;
+        value: unknown;
+    }>>;
+    deleteMemory(scope: string, key: string): Promise<void>;
     saveExecution(execution: ExecutionInfo): Promise<void>;
     getExecution(executionId: string): Promise<ExecutionInfo | null>;
     listExecutions(limit?: number): Promise<ExecutionInfo[]>;
+    deleteExecution(executionId: string): Promise<boolean>;
     saveEvalResult(entry: EvalHistoryEntry): Promise<void>;
     listEvalResults(limit?: number): Promise<EvalHistoryEntry[]>;
     deleteEvalResult(id: string): Promise<boolean>;
+    /**
+     * 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).
+     */
+    private listHistoryByZset;
     listSessions(): Promise<string[]>;
+    appendStreamingEvents(executionId: string, events: AxlEvent[]): Promise<void>;
+    finalizeStreamingEvents(executionId: string): Promise<void>;
+    listStreamingExecutions(): Promise<string[]>;
+    getStreamingEvents(executionId: string): Promise<AxlEvent[]>;
     /** Close the Redis connection. */
     close(): Promise<void>;
     deleteCheckpoints(executionId: string): Promise<void>;