@athenaintel/react 0.41.3 → 0.42.2

package/dist/agent-runtime/src/use-deep-agent-thread.d.ts

@@ -0,0 +1,352 @@
+import { StatewireThread } from '@assistant-ui/react-statewire';
+import { type DeepAgentHeadersResolver } from './deep-agent-transport-recipe';
+import { type DeepAgentMessageAuthor } from './message-author';
+import { type DeepAgentMessageWindowDeclaration, readDeepAgentMessageWindow } from './message-window';
+import { type DeepAgentConversionMemory, type DeepAgentMessageConversionOptions } from './messages';
+import { type DeepAgentProtocolStatus } from './protocol';
+import type { DeepAgentAttachTimingEvent } from './statewire-attach-observer';
+import type { StatewireDiagnosticsRecorder } from './statewire-diagnostics';
+import { type StatewireTransportOptions } from './statewire-transport';
+import type { DeepAgentThreadPrewarmPool } from './thread-prewarm';
+import { type DeepAgentThreadSnapshotCache } from './thread-snapshot-cache';
+import type { DeepAgentToolOutputStore } from './tool-outputs';
+import type { DeepAgentWithdrawnTurns } from './withdrawn-turns';
+import type { DeepAgentConnectionState, DeepAgentLaneProjection, DeepAgentStreamValues } from './types';
+type ThreadOptions = StatewireThread.Options<DeepAgentStreamValues>;
+export type { DeepAgentHeadersResolver } from './deep-agent-transport-recipe';
+/**
+ * The identity of one attach of a thread: the thread, the host's `attachKey`
+ * and the lane epoch (`UseDeepAgentThreadOptions['laneEpoch']`). The transport
+ * mount and every per-attach decision (snapshot seed, pooled hello, conversion
+ * memory, the host's per-thread latches, send recovery) key off it, so a new
+ * lane epoch is a new attach exactly like a thread switch.
+ */
+export declare function deepAgentAttachId({ threadId, attachKey, laneEpoch, }: {
+    threadId: string;
+    attachKey?: string | number | undefined;
+    laneEpoch?: number;
+}): string;
+/**
+ * How an attach's FIRST frame is sourced, decided once per attach at mount: the
+ * hello a pooled pre-dialed attach already replicated (`prewarm`), a remembered
+ * snapshot seed (`snapshot`), or nothing (`none` — the thread loads until its
+ * hello).
+ */
+export type DeepAgentAttachSource = 'prewarm' | 'snapshot' | 'none';
+export interface UseDeepAgentThreadOptions {
+    threadId: string;
+    /** Base URL of the deep-agent statewire host (the `…/v2/threads` mount). */
+    baseUrl: string;
+    /** Transport selection: SSE when true, WebSocket otherwise. */
+    sse?: boolean;
+    /**
+     * Auth headers for the transport. Statewire passes `{ staleAuth: true }`
+     * when the previous credential was refused, so resolvers that can
+     * force-renew should honor it.
+     */
+    headers: DeepAgentHeadersResolver;
+    /**
+     * Statewire session store for reconnect command-session recovery (e.g. the
+     * mobile AsyncStorage-backed store). Host-resolved; omitted, sessions are
+     * process-local.
+     */
+    sessionStore?: StatewireTransportOptions['sessionStore'];
+    /**
+     * Mounted storage seams for the thread: `session` holds the lane identity and
+     * the commands still awaiting a durable verdict, so a reload resumes the lane
+     * instead of minting a new client (browser hosts pass `LocalStorageSession`
+     * from `@assistant-ui/react-statewire/local-storage`); `composer` persists the
+     * draft. Mutually exclusive with `sessionStore` — statewire refuses a session
+     * mounted twice.
+     */
+    storage?: ThreadOptions['storage'];
+    /** True only for a never-started local chat; existing empty threads still load until their snapshot. */
+    isNewChat?: boolean;
+    /**
+     * Extra transport-key discriminator for the SAME thread. The session is keyed
+     * by `threadId` alone by default; hosts that must re-read the server snapshot
+     * without a thread switch (a run dispatched outside this client, e.g. a
+     * backgrounded AOP run writing the thread's first messages) bump this to
+     * remount the session against the same URL.
+     */
+    attachKey?: string | number;
+    /**
+     * Bumped when the durable lane this mount runs on is replaced by a lane of
+     * another scope (another principal signed in, or another backend) while the
+     * thread stays mounted; `useDeepAgentRuntime` derives it from the session
+     * `key`. Each epoch remounts the whole statewire thread (its session with
+     * the client id, lane clocks and journal it loaded, the session storage, the
+     * composer and the thread state) instead of moving it to the new lane, and
+     * is an attach identity of its own. Its first attach seeds nothing this tab
+     * remembered of the thread and takes no dial pooled for it: both were
+     * captured as the previous principal. It reads `isNewChat` afresh, so a
+     * thread that persisted under the previous principal attaches at once.
+     * Default 0.
+     */
+    laneEpoch?: number;
+    /**
+     * Host gate: park the transport instead of attaching — no socket, no retry
+     * loop. The thread element stays mounted so assistant-ui consumers keep
+     * rendering. Pass it when the host already knows every attach would be denied (e.g.
+     * the signed-in user has no workspace yet), so a locked-out tab does not
+     * hammer the attach endpoint on every backoff interval. `reason` is the
+     * connection message; a park with none (a `pending` session lane) reads
+     * like a never-started chat.
+     */
+    suspended?: {
+        reason?: string | undefined;
+    } | false;
+    /**
+     * Adapter capabilities the host UI exposes. Defaults preserve each client's
+     * pre-extraction surface — pass what the product mounts.
+     */
+    capabilities?: {
+        edit?: boolean;
+        continue?: boolean;
+        reload?: boolean;
+        unstable_switchBranch?: boolean;
+    };
+    /** Which run lanes project into the message tail; see {@link DeepAgentLaneProjection}. */
+    laneProjection?: DeepAgentLaneProjection;
+    /**
+     * Render quiet tools (`QUIET_TOOL_NAMES`, e.g. `submit_feedback`) like any
+     * other tool call. Off by default; pass it only for viewers allowed to see
+     * them (Olympus: Athena's internal admins on managed cloud).
+     */
+    showQuietTools?: boolean;
+    /**
+     * The viewer, as the backend would stamp them (`metadata.custom.author`).
+     * Stamped onto this client's own optimistic bubbles — a send still in flight
+     * has no host `meta` yet — so a just-sent turn is attributed, and the
+     * multi-author avatar gate flips for a second poster, without waiting for
+     * the acknowledgment. Replicated entries carry the host's own stamp instead.
+     * Compared field-wise, so callers need not memoize the object.
+     */
+    selfAuthor?: DeepAgentMessageAuthor | null;
+    /**
+     * Snapshot host context when each user message is submitted, before it is
+     * journaled. Includes programmatic appends, keyboard sends, queued messages,
+     * steering, and edits. The async getter starts immediately at submission;
+     * sends retain their order while it resolves. Retries, queue text edits,
+     * lane moves, reload, and continue preserve the original association.
+     * Return JSON-serializable metadata; optional capture failures can
+     * return an explicit null field rather than blocking the message.
+     *
+     * Declared structurally rather than as `ThreadOptions['getMessageMetadata']`:
+     * the option is what the monorepo patches into
+     * `@assistant-ui/react-statewire@0.31.0`, and the published sources must also
+     * compile against the unpatched upstream typings, where the library does not
+     * know the option and ignores it.
+     */
+    getMessageMetadata?: (() => Record<string, unknown> | undefined | Promise<Record<string, unknown> | undefined>) | undefined;
+    /** Host-owned adapters: attachments (upload/mention choreography), speech, feedback. */
+    adapters?: ThreadOptions['adapters'];
+    /**
+     * Transport lifecycle recorder (attach latency, reconnect loops, command
+     * settle fates, stale-auth renewals) fed from the hook's own seams. Pass one
+     * only when the host's diagnostics channel is enabled — the recorder is
+     * observed on hot paths, and an absent recorder costs a single optional call.
+     */
+    diagnostics?: StatewireDiagnosticsRecorder;
+    /**
+     * Per-tab LRU of the last wire state seen per thread. When set, every
+     * hydrated state the transport publishes is remembered, and a mount of a
+     * remembered thread seeds `initialState` from the cache (through
+     * {@link toThreadSnapshotSeed}) — the thread renders its last-known
+     * messages on the first frame instead of holding a loading treatment for
+     * the attach round-trip, and projects "running" when the run was live at
+     * capture (else "ready"). The attach snapshot then
+     * REPLACES the seeded state (statewire's `initialState` contract), so a
+     * thread that advanced elsewhere reconciles in one round-trip. New chats
+     * keep their preload and never read the cache.
+     */
+    snapshotCache?: DeepAgentThreadSnapshotCache;
+    /**
+     * The head window this surface wants: declared on every attach
+     * (`x-athena-deep-agent-window`, part of the transport recipe) so the hello
+     * of a client the host does not remember carries the newest `size`
+     * messages, and stated as `athena/interest` after the hello only when the
+     * hello's head is narrower — never to shrink it (the host holds what a
+     * viewer has loaded for the life of its connection). The resolved chain is
+     * joined with the mounted message documents into the converted transcript
+     * (see `message-window.ts`); older pages load through
+     * `useDeepAgentWindowSync`. Read once per attach.
+     */
+    messageWindow?: DeepAgentMessageWindowDeclaration;
+    /**
+     * Set only by a surface that pages a cut lane's earlier steps wherever it
+     * shows a lane's steps (`useDeepAgentLaneHistory`). Its attaches then
+     * declare the lane-cut contract version, and the host sends a finished
+     * `task` card with a deep transcript cut to its newest steps (see
+     * `DeepAgentProtocolDeclaration`). Omitted, every attach declares the
+     * default version and finished cards ride whole. Part of the transport
+     * recipe: a prewarm controller for this thread must be given the same
+     * value. Read once per attach.
+     */
+    laneHistory?: boolean;
+    /**
+     * Joins the interest window off the mounted documents; the default is
+     * {@link readDeepAgentMessageWindow}. Olympus passes
+     * `readDeepAgentFollowedWindow`, which also reads the lanes it follows onto
+     * their `task` cards.
+     */
+    readMessageWindow?: typeof readDeepAgentMessageWindow;
+    /**
+     * Creates each attach's conversion memory; the default is
+     * {@link createDeepAgentMessageConversionCache}. Olympus passes
+     * `createSubagentTranscriptConversionCache`, which also turns each `task`
+     * card's nested transcript into its tool-call part's `messages`.
+     */
+    createConversionCache?: (options: DeepAgentMessageConversionOptions) => DeepAgentConversionMemory;
+    /**
+     * Full tool outputs fetched back for the wire's cut tool messages
+     * (`history/tool_output`); the thread re-converts when one lands.
+     */
+    toolOutputs?: DeepAgentToolOutputStore;
+    /**
+     * User turns this client took back ahead of the wire (a user stop before
+     * any assistant output); the thread re-converts when one opens or closes.
+     */
+    withdrawnTurns?: DeepAgentWithdrawnTurns;
+    /**
+     * Pre-dialed attaches (see `thread-prewarm.ts`). When the pool holds a root
+     * for this thread at mount, the thread takes the hello it replicated as its
+     * seed — the transcript is the first frame — and dials its own attach
+     * against the instance the pool warmed; the pooled root is disposed in the
+     * same step, so one socket is live per thread after mount. Never seeded for
+     * a preloaded new chat or a suspended attach; such a root is discarded.
+     */
+    prewarmPool?: DeepAgentThreadPrewarmPool<DeepAgentStreamValues>;
+    /**
+     * Attach-path timing: socket open, hello size + handler cost, server retry
+     * hints — attributed to the attach's own thread, since a late event from the
+     * thread being left can land after the host has moved on.
+     */
+    onAttachTiming?: (info: {
+        threadId: string;
+        event: DeepAgentAttachTimingEvent;
+    }) => void;
+    /** Where this attach's first frame comes from; once per attach, at mount. */
+    onAttachSource?: (info: {
+        threadId: string;
+        source: DeepAgentAttachSource;
+    }) => void;
+    /** Full transport error policy (paywall, toast, telemetry) — client-owned. */
+    onError?: ThreadOptions['onError'];
+    /**
+     * Raw statewire state observer (first-attach latches, telemetry). The state
+     * argument is never `undefined`/`null`: passes where the wire has no
+     * snapshot yet (pre-attach, replay boundaries) deliver the typed
+     * `DEEP_AGENT_PRE_STREAM_STATE` default — `isDeepAgentStateHydrated`
+     * distinguishes them from a real (possibly empty) snapshot.
+     */
+    onStateChange?: ThreadOptions['onStateChange'];
+    /** Raw command-lifecycle observer (send-failure salvage, telemetry). */
+    onCommandChange?: ThreadOptions['onCommandChange'];
+    /** Raw connection observer (reconnect handles, telemetry). */
+    onRawConnectionChange?: ThreadOptions['onConnectionChange'];
+    /**
+     * Projected connection status changes, deduped per thread, with `null` on
+     * unmount so an indicator never shows a stale status.
+     */
+    onConnectionChange?: (connection: DeepAgentConnectionState | null) => void;
+    /** Notified when a run starts/stops so the page can reflect the running thread. */
+    onRunningChange?: (isRunning: boolean) => void;
+    /**
+     * Notified once per thread with the `runConfig` carried by the statewire
+     * snapshot (the backend's persisted panel config, seeded in `_load_history`),
+     * so the host can hydrate its config store from the thread. Notified with
+     * `null` (at most once per attach) when a server snapshot arrives WITHOUT a
+     * persisted config, so a host waiting on hydration can stop waiting; a
+     * config appearing on a later snapshot of the same attach (mirrored at run
+     * start) still delivers the config notification.
+     */
+    onServerRunConfig?: (config: Record<string, unknown> | null) => void;
+    /**
+     * Notified when the snapshot's `outOfBandRunActive` flag changes: the host set
+     * it while a run executing OUTSIDE this surface (an AOP / HTTP-route run)
+     * is actively writing the thread's bare-namespace history, which the host
+     * live-refreshes onto the wire. Lets the page show run-in-progress
+     * treatment instead of an empty conversation, and stand down its own
+     * re-attach polling. Change-notified per attach (an initial `false` before
+     * the snapshot stays silent), mirroring `onRunningChange`.
+     */
+    onOutOfBandRunActive?: (outOfBandRunActive: boolean) => void;
+    /**
+     * Notified with the state's session-asset lifecycle flag
+     * ({@link readSessionPersisted}) PAIRED with the thread it describes: `false`
+     * while the thread's `session` asset provably does not exist yet (a
+     * never-started chat's preload, a first run before the mint), `true` once
+     * minted, `null` when the state carries no flag (a host that predates it).
+     *
+     * Fired from the converter pass, so the pair is read from the state of the
+     * thread this attach was mounted for. A component reading the flag off the
+     * client store instead lags the mounted thread id by one render on a switch
+     * and can pair the new id with the previous thread's flag — releasing a
+     * session-scoped read for a row the backend has not minted. Change-notified
+     * per attach; the first pass of every attach notifies, so a host holding a
+     * read back until it hears from the mounted thread always does.
+     */
+    onSessionPersistedChange?: (event: {
+        threadId: string;
+        sessionPersisted: boolean | null;
+    }) => void;
+    /**
+     * Notified with the wire-contract status once the attach snapshot
+     * advertises the `protocol` lane, and again whenever it changes (a
+     * re-attach after a server roll can advertise a new `version`). Telemetry
+     * and per-version behaviour only: the host has no minimum client version,
+     * so nothing about the status gates a send. Never called for
+     * pre-declaration servers (their snapshots carry no lane) — absence of a
+     * call means "no advertisement", not "compatible".
+     */
+    onProtocolChange?: (status: DeepAgentProtocolStatus) => void;
+}
+/** One thread's replicated running state, keyed so a switch between two
+ * threads with the same status still re-notifies (the host page clears its
+ * per-thread state on selection, mirroring the connection dedupe below). */
+export interface RunningSnapshot {
+    threadId: string;
+    isRunning: boolean;
+}
+/** Whether the thread's `session` asset exists, read off a statewire state, or
+ * `null` when the state does not carry the flag.
+ *
+ * Absence is not absence of the asset: a snapshot from a host that predates
+ * the flag has no such key, and reading that as "the asset does not exist"
+ * would gate a read the client is entitled to make, with nothing left to
+ * un-gate it. A new thread's preload seeds `false` (see `initialState`), so
+ * the pre-attach pass of a chat that cannot have an asset yet still gates.
+ *
+ * Hosts pass this to `useStatewireState` so the flag and the thread it belongs
+ * to are read in one component — a thread switch then cannot pair one thread's
+ * id with the other's flag. */
+export declare function readSessionPersisted(state: unknown): boolean | null;
+/** Whether a converter pass must notify `onRunningChange`.
+ *
+ * The mount's very first status notifies only when it is `true` (a snapshot
+ * carrying a live run) — an initial `false` before the snapshot must stay
+ * silent so it cannot clear a still-valid indicator. After that, every
+ * transition notifies, and so does the first status after a thread switch
+ * (the host page clears its per-thread state on selection, so a switch
+ * between two threads with the same status must still re-notify). */
+export declare function shouldNotifyRunningChange(previous: RunningSnapshot | null, next: RunningSnapshot): boolean;
+/**
+ * The shared deep-agent Statewire thread.
+ *
+ * `StatewireThread` (from `@assistant-ui/react-statewire`) attaches to the
+ * agora-hosted thread at `${baseUrl}/${threadId}` (WebSocket by default,
+ * with SSE retained only as a host-selected compatibility switch): the backend
+ * hosts the thread state and this client
+ * replicates it live, so the server snapshot is the single source of history
+ * (no local import, no `/status` resume probing) and run scheduling — queueing,
+ * steering, stop, edit rewinds — rides the built-in `run/*` commands.
+ *
+ * The thread element is keyed by `threadId`, so a thread switch remounts the
+ * session against the new URL instead of importing history in place.
+ *
+ * Returns the thread element for the host's own `useAui({ thread })` — web
+ * hosts take `useAui` from `@assistant-ui/react`, React Native hosts from
+ * `@assistant-ui/react-native`; this package imports neither.
+ */
+export declare function useDeepAgentThread({ threadId, baseUrl, sse, headers, sessionStore, storage, isNewChat, attachKey, laneEpoch, suspended, capabilities, laneProjection, showQuietTools, selfAuthor, getMessageMetadata, adapters, diagnostics, snapshotCache, messageWindow, laneHistory, readMessageWindow, createConversionCache, toolOutputs, withdrawnTurns, prewarmPool, onAttachTiming, onAttachSource, onError, onStateChange, onCommandChange, onRawConnectionChange, onConnectionChange, onRunningChange, onServerRunConfig, onOutOfBandRunActive, onSessionPersistedChange, onProtocolChange, }: UseDeepAgentThreadOptions): import("@assistant-ui/tap").ResourceElement<import("@assistant-ui/store").ClientOutput<"thread">>;

package/dist/agent-runtime/src/use-deep-agent-thread.js

@@ -13,6 +13,14 @@ import { pairDeepAgentStateWithThread, isDeepAgentStateHydrated, readDeepAgentSt
 import { StatewireSuspended } from "./statewire-suspended.js";
 import { DEEP_AGENT_STATEWIRE_PROTOCOL } from "./statewire-transport.js";
 import { toThreadSnapshotSeed } from "./thread-snapshot-cache.js";
+function deepAgentAttachId({
+  threadId,
+  attachKey,
+  laneEpoch = 0
+}) {
+  const attach = attachKey === void 0 ? threadId : `${threadId}:${attachKey}`;
+  return laneEpoch === 0 ? attach : `${attach}#lane-epoch:${laneEpoch}`;
+}
 function readSessionPersisted(state) {
   const flag = state == null ? void 0 : state.sessionPersisted;
   return typeof flag === "boolean" ? flag : null;
@@ -33,15 +41,20 @@ function useDeepAgentThread({
   storage,
   isNewChat = false,
   attachKey,
+  laneEpoch = 0,
   suspended = false,
   capabilities,
   laneProjection = "both",
+  showQuietTools = false,
   selfAuthor = null,
   getMessageMetadata,
   adapters,
   diagnostics,
   snapshotCache,
   messageWindow,
+  laneHistory = false,
+  readMessageWindow = readDeepAgentMessageWindow,
+  createConversionCache = createDeepAgentMessageConversionCache,
   toolOutputs,
   withdrawnTurns,
   prewarmPool,
@@ -83,6 +96,8 @@ function useDeepAgentThread({
   headersRef.current = headers;
   const messageWindowRef = useRef(messageWindow);
   messageWindowRef.current = messageWindow;
+  const laneHistoryRef = useRef(laneHistory);
+  laneHistoryRef.current = laneHistory;
   const interestRef = useRef({ attachId: "", stated: false });
   const lastMessagesRef = useRef(null);
   const [toolOutputsVersion, setToolOutputsVersion] = useState(0);
@@ -109,7 +124,7 @@ function useDeepAgentThread({
   const absentStateRunConfigAttachRef = useRef(null);
   const threadIdRef = useRef(threadId);
   threadIdRef.current = threadId;
-  const attachId = attachKey === void 0 ? threadId : `${threadId}:${attachKey}`;
+  const attachId = deepAgentAttachId({ threadId, attachKey, laneEpoch });
   const attachIdRef = useRef(attachId);
   attachIdRef.current = attachId;
   const [authParked, setAuthParked] = useState(null);
@@ -155,7 +170,9 @@ function useDeepAgentThread({
           (_a3 = onOutOfBandRunActiveRef.current) == null ? void 0 : _a3.call(onOutOfBandRunActiveRef, stateOutOfBandRunActive);
         });
       }
-      const protocolStatus = projectDeepAgentProtocol(state);
+      const protocolStatus = projectDeepAgentProtocol(state, {
+        laneHistory: laneHistoryRef.current
+      });
       if (protocolStatus !== null) {
         const previous = ((_a2 = lastProtocolRef.current) == null ? void 0 : _a2.attachId) === attachIdRef.current ? lastProtocolRef.current.status : null;
         if (previous === null || previous.protocolVersion !== protocolStatus.protocolVersion) {
@@ -209,32 +226,38 @@ function useDeepAgentThread({
     },
     []
   );
-  const preloadRef = useRef({ threadId, preload: isNewChat });
-  if (preloadRef.current.threadId !== threadId)
-    preloadRef.current = { threadId, preload: isNewChat };
+  const preloadRef = useRef({ threadId, laneEpoch, preload: isNewChat });
+  if (preloadRef.current.threadId !== threadId || preloadRef.current.laneEpoch !== laneEpoch)
+    preloadRef.current = { threadId, laneEpoch, preload: isNewChat };
   const snapshotCacheRef = useRef(snapshotCache);
   snapshotCacheRef.current = snapshotCache;
   const snapshotSeedRef = useRef(null);
   if (snapshotSeedRef.current === null || snapshotSeedRef.current.attachId !== attachId) {
     const preload = preloadRef.current.preload;
+    const laneReplaced = snapshotSeedRef.current !== null && snapshotSeedRef.current.laneEpoch !== laneEpoch;
+    if (laneReplaced) snapshotCache == null ? void 0 : snapshotCache.forget(threadId);
     let pooledState;
     if (prewarmPool == null ? void 0 : prewarmPool.has(threadId)) {
-      if (preload || suspended) {
+      if (preload || suspended || laneReplaced) {
         prewarmPool.discard(threadId);
       } else {
         pooledState = (_a = prewarmPool.take(threadId)) == null ? void 0 : _a.state;
       }
     }
-    const remembered = preload || suspended ? void 0 : pooledState ?? (snapshotCache == null ? void 0 : snapshotCache.take(threadId));
+    const remembered = preload || suspended || laneReplaced ? void 0 : pooledState ?? (snapshotCache == null ? void 0 : snapshotCache.take(threadId));
     const seed = remembered ? toThreadSnapshotSeed(remembered) : void 0;
-    snapshotSeedRef.current = { attachId, seed };
+    snapshotSeedRef.current = { attachId, laneEpoch, seed };
     const source = pooledState !== void 0 ? "prewarm" : seed ? "snapshot" : "none";
     const notifySource = onAttachSourceRef.current;
     if (notifySource) queueMicrotask(() => notifySource({ threadId, source }));
   }
   const conversionCacheRef = useRef(null);
-  if (conversionCacheRef.current === null || conversionCacheRef.current.attachId !== attachId) {
-    conversionCacheRef.current = { attachId, cache: createDeepAgentMessageConversionCache() };
+  if (conversionCacheRef.current === null || conversionCacheRef.current.attachId !== attachId || conversionCacheRef.current.showQuietTools !== showQuietTools) {
+    conversionCacheRef.current = {
+      attachId,
+      showQuietTools,
+      cache: createConversionCache({ showQuietTools })
+    };
   }
   const conversionCache = conversionCacheRef.current.cache;
   const lastStateMessagesRef = useRef(
@@ -244,7 +267,7 @@ function useDeepAgentThread({
     (wireState, meta) => {
       var _a2, _b, _c, _d, _e, _f, _g;
       const values = readDeepAgentStreamValues(wireState);
-      const window = readDeepAgentMessageWindow(meta.mounted);
+      const window = readMessageWindow(meta.mounted);
       const held = ((_a2 = lastMessagesRef.current) == null ? void 0 : _a2.attachId) === attachId ? lastMessagesRef.current.messages : null;
       const messages = (window == null ? void 0 : window.messages) ?? values.messages ?? held ?? [];
       if (window !== null || messages.length > 0) lastMessagesRef.current = { attachId, messages };
@@ -335,9 +358,9 @@ function useDeepAgentThread({
       }
       return converter(state, ((_g = (_f = state.runs) == null ? void 0 : _f[0]) == null ? void 0 : _g.status) === "running", conversionCache);
     },
-    [attachId, conversionCache, converter, materialize, threadId]
+    [attachId, conversionCache, converter, materialize, readMessageWindow, threadId]
   );
-  return StatewireThread({
+  const thread = StatewireThread({
     // The transport stamps this protocol on every command; the thread client
     // must declare it too or the core skips the optimistic folds and a send
     // stays invisible until the server frame lands.
@@ -386,6 +409,7 @@ function useDeepAgentThread({
           isNew: preloadRef.current.preload,
           headers: (ctx) => headersRef.current(ctx),
           messageWindow: messageWindowRef.current,
+          laneHistory: laneHistoryRef.current,
           sessionStore,
           onAuthResolve: (ctx) => {
             var _a2;
@@ -449,8 +473,10 @@ function useDeepAgentThread({
       })
     }
   });
+  return laneEpoch === 0 ? thread : withKey(`lane-epoch:${laneEpoch}`, thread);
 }
 export {
+  deepAgentAttachId,
   readSessionPersisted,
   shouldNotifyRunningChange,
   useDeepAgentThread