@athenaintel/react 0.41.1 → 0.41.3

package/README.md

@@ -807,6 +807,18 @@ Both use the same bearer / API key as session creation. The full recipe
 template skill `voice-session-guide.md`. `createAthenaVoiceSession` is also
 exported if you hold the bridge state yourself.
 
+## What's new in 0.41.3
+
+**A pinned session stays in the sidebar.** The session list reads the newest 50 sessions, and its Pinned group was built from that page alone, so a session pinned long ago left the sidebar once 50 newer sessions existed (on staging, four pinned sessions became three when two new sessions started). The provider now also reads the viewer's pinned sessions on their own (`favorites_only`, under the same app scope and search, every page of them up to 500) and adds the ones the page does not list to the Pinned group. Unpinning such a session takes it out of the sidebar, since it is not one of the newest. Nothing to change in your app.
+
+**"Completed with issues" means the turn ended on a problem.** A finished turn's collapsed card said "Completed with issues" when any tool call in it had failed, so a long run that opened its pull request after a few failed reads or commands read as a failure. It now says so only when the turn ended on a failed call (no later call completed) or held a call the person refused; otherwise it reads `Used N tools`. `getActivitySummary` follows the same rule.
+
+## What's new in 0.41.2
+
+**A session opened while its run is streaming shows, and keeps, its own model.** `useAthenaThreadModel()` could report `ready` with no model before the session's snapshot had arrived. On a session whose run was streaming, the connection reported `connected` before the attach snapshot applied, and the SDK took the placeholder the thread shows meanwhile, which holds no server config, as what the server sent. A picker seeded from it showed the agent's default model, and the provider then wrote that pick to the session (`config/patch {model: null}`), so the session lost its model for its next turns. `ready`, and every config write the provider decides, now wait for a state the server sent: the placeholder and a remembered snapshot never count, whenever the connection reports `connected`. The `statewire.attach` diagnostics span (time to the session's snapshot) now ends when that snapshot arrives, not when the thread first renders.
+
+Nothing to change in your app.
+
 ## What's new in 0.41.1
 
 **A chip in a computer app links to Athena, not to the app.** In an app a computer serves, Marathon hands the provider the app's own origin as its `appUrl`, so every asset and citation chip linked to `https://<app>/dashboard/spaces/…`, the app itself. Chips now link to the deployment's Athena frontend there (`https://staging-app.athenaintel.com/…` on staging), as the workbench's "Open in Athena" links already did. This matters most for a repository file citation, which 0.41.0 opens as its link. `athenaLinkAppUrl` is now exported from the URL helpers (still from the package root). An `appUrl` you configure that is not the page's own origin is used as configured.

package/dist/agent-runtime/src/durable-thread-snapshot-cache.cjs

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const threadSnapshotCache = require("./thread-snapshot-cache.cjs");
+const threadSnapshotMirror = require("./thread-snapshot-mirror.cjs");
+const DEFAULT_MAX_THREADS = 30;
+const OFFLINE_SNAPSHOT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+function browserOffline() {
+  var _a;
+  const host = globalThis;
+  return ((_a = host.navigator) == null ? void 0 : _a.onLine) === false;
+}
+function createDurableThreadSnapshotCache({
+  mirror,
+  isOffline = browserOffline,
+  maxThreads = DEFAULT_MAX_THREADS,
+  maxAgeMs,
+  offlineMaxAgeMs = OFFLINE_SNAPSHOT_MAX_AGE_MS,
+  now = () => Date.now()
+}) {
+  let ownerId = null;
+  let epoch = 0;
+  let primed = null;
+  let hydration = Promise.resolve();
+  const offline = /* @__PURE__ */ new Map();
+  const offlineSeeds = /* @__PURE__ */ new Map();
+  const restored = /* @__PURE__ */ new Set();
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const listener of listeners) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  };
+  const clearOfflineSeed = (threadId) => {
+    if (offlineSeeds.delete(threadId)) notify();
+  };
+  const keepOffline = (threadId, entry) => {
+    offline.delete(threadId);
+    offline.set(threadId, entry);
+    while (offline.size > maxThreads) {
+      const oldest = offline.keys().next().value;
+      if (oldest === void 0) break;
+      offline.delete(oldest);
+    }
+  };
+  const memory = threadSnapshotCache.createDeepAgentThreadSnapshotCache({
+    maxThreads,
+    maxAgeMs,
+    now,
+    onChange: (change) => {
+      const owner = ownerId;
+      if (owner === null) return;
+      switch (change.type) {
+        case "remember":
+          mirror.write({ ownerId: owner, threadId: change.threadId, state: change.state, at: change.at });
+          return;
+        case "forget":
+          mirror.remove({ ownerId: owner, threadId: change.threadId });
+          return;
+        case "clear":
+          return;
+      }
+    }
+  });
+  const offlineEntry = (threadId) => {
+    const entry = offline.get(threadId);
+    return entry && now() - entry.at <= offlineMaxAgeMs ? entry : void 0;
+  };
+  const dropEverything = () => {
+    memory.clear();
+    offline.clear();
+    restored.clear();
+    if (offlineSeeds.size > 0) {
+      offlineSeeds.clear();
+      notify();
+    }
+  };
+  return {
+    remember(threadId, state) {
+      memory.remember(threadId, state);
+      restored.delete(threadId);
+      if (threadSnapshotMirror.isRestingThreadSnapshot(state)) keepOffline(threadId, { state, at: now() });
+      clearOfflineSeed(threadId);
+    },
+    take(threadId) {
+      if (!isOffline()) return memory.take(threadId);
+      const entry = offlineEntry(threadId);
+      if (!entry) return void 0;
+      if (offlineSeeds.get(threadId) !== entry.at) {
+        offlineSeeds.set(threadId, entry.at);
+        notify();
+      }
+      return entry.state;
+    },
+    peek(threadId) {
+      return isOffline() ? offlineEntry(threadId) !== void 0 : memory.peek(threadId);
+    },
+    forget(threadId) {
+      memory.forget(threadId);
+      offline.delete(threadId);
+      restored.delete(threadId);
+      clearOfflineSeed(threadId);
+    },
+    clear() {
+      dropEverything();
+    },
+    owner: () => ownerId,
+    setOwner(next) {
+      if (next === ownerId) return hydration;
+      const previous = ownerId;
+      ownerId = next;
+      epoch += 1;
+      dropEverything();
+      if (previous !== null) void mirror.clearOwner(previous);
+      if (next === null) {
+        hydration = Promise.resolve();
+        return hydration;
+      }
+      const readEpoch = epoch;
+      const read = (primed == null ? void 0 : primed.ownerId) === next ? primed.read : mirror.load(next);
+      primed = null;
+      hydration = read.then((entries) => {
+        if (readEpoch !== epoch || ownerId !== next) return;
+        for (const entry of entries) {
+          if (!offline.has(entry.threadId)) keepOffline(entry.threadId, { state: entry.state, at: entry.at });
+          if (memory.peek(entry.threadId)) continue;
+          memory.restore(entry.threadId, entry.state, entry.at);
+          if (memory.peek(entry.threadId)) restored.add(entry.threadId);
+        }
+      });
+      return hydration;
+    },
+    prime(next) {
+      if (next === ownerId || (primed == null ? void 0 : primed.ownerId) === next) return;
+      primed = { ownerId: next, read: mirror.load(next) };
+    },
+    offlineSeedAt: (threadId) => offlineSeeds.get(threadId) ?? null,
+    subscribeOfflineSeeds(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    isRestored: (threadId) => restored.has(threadId),
+    whenHydrated: () => hydration,
+    async wipe() {
+      epoch += 1;
+      primed = null;
+      dropEverything();
+      await mirror.clearAll();
+    }
+  };
+}
+exports.OFFLINE_SNAPSHOT_MAX_AGE_MS = OFFLINE_SNAPSHOT_MAX_AGE_MS;
+exports.createDurableThreadSnapshotCache = createDurableThreadSnapshotCache;
+//# sourceMappingURL=durable-thread-snapshot-cache.cjs.map

package/dist/agent-runtime/src/durable-thread-snapshot-cache.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-thread-snapshot-cache.cjs","sources":["../../../../agent-runtime/src/durable-thread-snapshot-cache.ts"],"sourcesContent":["import {\n  createDeepAgentThreadSnapshotCache,\n  type DeepAgentThreadSnapshotCache,\n} from \"./thread-snapshot-cache\";\nimport { isRestingThreadSnapshot, type ThreadSnapshotMirror } from \"./thread-snapshot-mirror\";\nimport type { DeepAgentStreamValues } from \"./types\";\n\n/**\n * The thread snapshot cache with a durable, encrypted mirror behind it (`thread-snapshot-mirror.ts`):\n * a reload seeds a recently visited thread from what it last showed, and a thread can be read while\n * the transport cannot connect at all.\n *\n * - **Online, nothing changes.** `take` serves the in-memory entry within its age bound (one hour by\n *   default), exactly as the plain cache does, and the attach snapshot replaces the seed.\n * - **Offline** (`isOffline()`: the host's own word that Athena can't be reached), `take` serves the\n *   thread's last resting transcript this page holds (what it read, or what the mirror kept), up to\n *   `offlineMaxAgeMs` old and past the online bound, so a person can read their recent\n *   conversations on a plane. Never a mid-stream state: a run the connection dropped is a partial\n *   transcript, and the resting one before it is what shows. Every offline seed, however recent, is\n *   recorded with its capture time (`offlineSeedAt`) so the host can say the transcript is \"as of\"\n *   then; only the next state the wire delivers for the thread (its attach) clears it.\n * - **Owned.** Entries belong to one owner (`setOwner`): a change drops every entry, deletes the\n *   previous owner's mirrored records and reads the new owner's. A snapshot captured under one\n *   account never seeds a mount under another. `wipe` drops everything (a sign-out).\n */\nexport interface DurableThreadSnapshotCache extends DeepAgentThreadSnapshotCache {\n  peek(threadId: string): boolean;\n  /** Bind the cache to the acting owner (`null`: nobody signed in; nothing is mirrored). */\n  setOwner(ownerId: string | null): Promise<void>;\n  /**\n   * Start reading an owner's mirrored snapshots before the owner is known for sure (a host's\n   * last-owner hint at boot): `setOwner` adopts the read if that owner is the one bound, and it\n   * is discarded otherwise. Binds nothing and deletes nothing.\n   */\n  prime(ownerId: string): void;\n  /** The owner the cache is bound to. */\n  owner(): string | null;\n  /**\n   * When the seed `take` last served for `threadId` was captured, if it was served while Athena\n   * could not be reached; `null` otherwise, and again once the wire delivers the thread.\n   */\n  offlineSeedAt(threadId: string): number | null;\n  /** Calls `listener` whenever an offline seed is served or cleared; returns what stops it. */\n  subscribeOfflineSeeds(listener: () => void): () => void;\n  /** Whether the entry `take` would serve for `threadId` came back from the mirror. */\n  isRestored(threadId: string): boolean;\n  /** Resolves once the current owner's mirrored snapshots have been read (tests, telemetry). */\n  whenHydrated(): Promise<void>;\n  /** Drop every entry, in memory and in the mirror (a sign-out, a workspace switch). */\n  wipe(): Promise<void>;\n}\n\nexport interface DurableThreadSnapshotCacheOptions {\n  mirror: ThreadSnapshotMirror;\n  /** Whether Athena can't be reached right now (the host's reachability, or the browser's). */\n  isOffline?: () => boolean;\n  maxThreads?: number;\n  /** The online age bound (the plain cache's). */\n  maxAgeMs?: number;\n  /** How old a mirrored snapshot may be and still be read offline. */\n  offlineMaxAgeMs?: number;\n  now?: () => number;\n}\n\nconst DEFAULT_MAX_THREADS = 30;\n/** What a device keeps for reading offline: the offline plan's 30 days. */\nexport const OFFLINE_SNAPSHOT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;\n\nfunction browserOffline(): boolean {\n  const host = globalThis as { navigator?: { onLine?: boolean } };\n  return host.navigator?.onLine === false;\n}\n\nexport function createDurableThreadSnapshotCache({\n  mirror,\n  isOffline = browserOffline,\n  maxThreads = DEFAULT_MAX_THREADS,\n  maxAgeMs,\n  offlineMaxAgeMs = OFFLINE_SNAPSHOT_MAX_AGE_MS,\n  now = () => Date.now(),\n}: DurableThreadSnapshotCacheOptions): DurableThreadSnapshotCache {\n  let ownerId: string | null = null;\n  // Bumped on every owner change and wipe: a mirror read in flight then must not admit what it read.\n  let epoch = 0;\n  let primed: { ownerId: string; read: ReturnType<ThreadSnapshotMirror[\"load\"]> } | null = null;\n  let hydration: Promise<void> = Promise.resolve();\n  // Every resting snapshot readable offline (the mirror's, and this page's own), newest last.\n  const offline = new Map<string, { state: DeepAgentStreamValues; at: number }>();\n  const offlineSeeds = new Map<string, number>();\n  const restored = new Set<string>();\n  const listeners = new Set<() => void>();\n\n  const notify = (): void => {\n    for (const listener of listeners) {\n      try {\n        listener();\n      } catch {\n        // A host listener's fault never reaches the wire path.\n      }\n    }\n  };\n  const clearOfflineSeed = (threadId: string): void => {\n    if (offlineSeeds.delete(threadId)) notify();\n  };\n  const keepOffline = (threadId: string, entry: { state: DeepAgentStreamValues; at: number }): void => {\n    offline.delete(threadId);\n    offline.set(threadId, entry);\n    while (offline.size > maxThreads) {\n      const oldest = offline.keys().next().value;\n      if (oldest === undefined) break;\n      offline.delete(oldest);\n    }\n  };\n\n  const memory = createDeepAgentThreadSnapshotCache({\n    maxThreads,\n    maxAgeMs,\n    now,\n    onChange: (change) => {\n      const owner = ownerId;\n      if (owner === null) return;\n      switch (change.type) {\n        case \"remember\":\n          mirror.write({ ownerId: owner, threadId: change.threadId, state: change.state, at: change.at });\n          return;\n        case \"forget\":\n          mirror.remove({ ownerId: owner, threadId: change.threadId });\n          return;\n        case \"clear\":\n          return;\n      }\n    },\n  });\n\n  /** The thread's last resting transcript within the offline bound. */\n  const offlineEntry = (threadId: string): { state: DeepAgentStreamValues; at: number } | undefined => {\n    const entry = offline.get(threadId);\n    return entry && now() - entry.at <= offlineMaxAgeMs ? entry : undefined;\n  };\n\n  const dropEverything = (): void => {\n    memory.clear();\n    offline.clear();\n    restored.clear();\n    if (offlineSeeds.size > 0) {\n      offlineSeeds.clear();\n      notify();\n    }\n  };\n\n  return {\n    remember(threadId, state) {\n      memory.remember(threadId, state);\n      restored.delete(threadId);\n      // A mid-stream state keeps the resting transcript before it readable offline, as the mirror\n      // keeps that one's record. One too long to seal still reads from memory.\n      if (isRestingThreadSnapshot(state)) keepOffline(threadId, { state, at: now() });\n      // The wire delivered the thread: the transcript is current again.\n      clearOfflineSeed(threadId);\n    },\n    take(threadId) {\n      if (!isOffline()) return memory.take(threadId);\n      const entry = offlineEntry(threadId);\n      if (!entry) return undefined;\n      if (offlineSeeds.get(threadId) !== entry.at) {\n        offlineSeeds.set(threadId, entry.at);\n        notify();\n      }\n      return entry.state;\n    },\n    peek(threadId) {\n      return isOffline() ? offlineEntry(threadId) !== undefined : memory.peek(threadId);\n    },\n    forget(threadId) {\n      memory.forget(threadId);\n      offline.delete(threadId);\n      restored.delete(threadId);\n      clearOfflineSeed(threadId);\n    },\n    clear() {\n      dropEverything();\n    },\n    owner: () => ownerId,\n    setOwner(next) {\n      if (next === ownerId) return hydration;\n      const previous = ownerId;\n      ownerId = next;\n      epoch += 1;\n      dropEverything();\n      if (previous !== null) void mirror.clearOwner(previous);\n      if (next === null) {\n        hydration = Promise.resolve();\n        return hydration;\n      }\n      const readEpoch = epoch;\n      const read = primed?.ownerId === next ? primed.read : mirror.load(next);\n      primed = null;\n      hydration = read.then((entries) => {\n        // The owner moved on, or everything was wiped, while the read was in flight.\n        if (readEpoch !== epoch || ownerId !== next) return;\n        for (const entry of entries) {\n          if (!offline.has(entry.threadId)) keepOffline(entry.threadId, { state: entry.state, at: entry.at });\n          if (memory.peek(entry.threadId)) continue;\n          memory.restore(entry.threadId, entry.state, entry.at);\n          if (memory.peek(entry.threadId)) restored.add(entry.threadId);\n        }\n      });\n      return hydration;\n    },\n    prime(next) {\n      if (next === ownerId || primed?.ownerId === next) return;\n      primed = { ownerId: next, read: mirror.load(next) };\n    },\n    offlineSeedAt: (threadId) => offlineSeeds.get(threadId) ?? null,\n    subscribeOfflineSeeds(listener) {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n    isRestored: (threadId) => restored.has(threadId),\n    whenHydrated: () => hydration,\n    async wipe() {\n      epoch += 1;\n      primed = null;\n      dropEverything();\n      await mirror.clearAll();\n    },\n  };\n}\n"],"names":["createDeepAgentThreadSnapshotCache","isRestingThreadSnapshot"],"mappings":"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"}

package/dist/agent-runtime/src/durable-thread-snapshot-cache.js

@@ -0,0 +1,158 @@
+import { createDeepAgentThreadSnapshotCache } from "./thread-snapshot-cache.js";
+import { isRestingThreadSnapshot } from "./thread-snapshot-mirror.js";
+const DEFAULT_MAX_THREADS = 30;
+const OFFLINE_SNAPSHOT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+function browserOffline() {
+  var _a;
+  const host = globalThis;
+  return ((_a = host.navigator) == null ? void 0 : _a.onLine) === false;
+}
+function createDurableThreadSnapshotCache({
+  mirror,
+  isOffline = browserOffline,
+  maxThreads = DEFAULT_MAX_THREADS,
+  maxAgeMs,
+  offlineMaxAgeMs = OFFLINE_SNAPSHOT_MAX_AGE_MS,
+  now = () => Date.now()
+}) {
+  let ownerId = null;
+  let epoch = 0;
+  let primed = null;
+  let hydration = Promise.resolve();
+  const offline = /* @__PURE__ */ new Map();
+  const offlineSeeds = /* @__PURE__ */ new Map();
+  const restored = /* @__PURE__ */ new Set();
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const listener of listeners) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  };
+  const clearOfflineSeed = (threadId) => {
+    if (offlineSeeds.delete(threadId)) notify();
+  };
+  const keepOffline = (threadId, entry) => {
+    offline.delete(threadId);
+    offline.set(threadId, entry);
+    while (offline.size > maxThreads) {
+      const oldest = offline.keys().next().value;
+      if (oldest === void 0) break;
+      offline.delete(oldest);
+    }
+  };
+  const memory = createDeepAgentThreadSnapshotCache({
+    maxThreads,
+    maxAgeMs,
+    now,
+    onChange: (change) => {
+      const owner = ownerId;
+      if (owner === null) return;
+      switch (change.type) {
+        case "remember":
+          mirror.write({ ownerId: owner, threadId: change.threadId, state: change.state, at: change.at });
+          return;
+        case "forget":
+          mirror.remove({ ownerId: owner, threadId: change.threadId });
+          return;
+        case "clear":
+          return;
+      }
+    }
+  });
+  const offlineEntry = (threadId) => {
+    const entry = offline.get(threadId);
+    return entry && now() - entry.at <= offlineMaxAgeMs ? entry : void 0;
+  };
+  const dropEverything = () => {
+    memory.clear();
+    offline.clear();
+    restored.clear();
+    if (offlineSeeds.size > 0) {
+      offlineSeeds.clear();
+      notify();
+    }
+  };
+  return {
+    remember(threadId, state) {
+      memory.remember(threadId, state);
+      restored.delete(threadId);
+      if (isRestingThreadSnapshot(state)) keepOffline(threadId, { state, at: now() });
+      clearOfflineSeed(threadId);
+    },
+    take(threadId) {
+      if (!isOffline()) return memory.take(threadId);
+      const entry = offlineEntry(threadId);
+      if (!entry) return void 0;
+      if (offlineSeeds.get(threadId) !== entry.at) {
+        offlineSeeds.set(threadId, entry.at);
+        notify();
+      }
+      return entry.state;
+    },
+    peek(threadId) {
+      return isOffline() ? offlineEntry(threadId) !== void 0 : memory.peek(threadId);
+    },
+    forget(threadId) {
+      memory.forget(threadId);
+      offline.delete(threadId);
+      restored.delete(threadId);
+      clearOfflineSeed(threadId);
+    },
+    clear() {
+      dropEverything();
+    },
+    owner: () => ownerId,
+    setOwner(next) {
+      if (next === ownerId) return hydration;
+      const previous = ownerId;
+      ownerId = next;
+      epoch += 1;
+      dropEverything();
+      if (previous !== null) void mirror.clearOwner(previous);
+      if (next === null) {
+        hydration = Promise.resolve();
+        return hydration;
+      }
+      const readEpoch = epoch;
+      const read = (primed == null ? void 0 : primed.ownerId) === next ? primed.read : mirror.load(next);
+      primed = null;
+      hydration = read.then((entries) => {
+        if (readEpoch !== epoch || ownerId !== next) return;
+        for (const entry of entries) {
+          if (!offline.has(entry.threadId)) keepOffline(entry.threadId, { state: entry.state, at: entry.at });
+          if (memory.peek(entry.threadId)) continue;
+          memory.restore(entry.threadId, entry.state, entry.at);
+          if (memory.peek(entry.threadId)) restored.add(entry.threadId);
+        }
+      });
+      return hydration;
+    },
+    prime(next) {
+      if (next === ownerId || (primed == null ? void 0 : primed.ownerId) === next) return;
+      primed = { ownerId: next, read: mirror.load(next) };
+    },
+    offlineSeedAt: (threadId) => offlineSeeds.get(threadId) ?? null,
+    subscribeOfflineSeeds(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    isRestored: (threadId) => restored.has(threadId),
+    whenHydrated: () => hydration,
+    async wipe() {
+      epoch += 1;
+      primed = null;
+      dropEverything();
+      await mirror.clearAll();
+    }
+  };
+}
+export {
+  OFFLINE_SNAPSHOT_MAX_AGE_MS,
+  createDurableThreadSnapshotCache
+};
+//# sourceMappingURL=durable-thread-snapshot-cache.js.map

package/dist/agent-runtime/src/durable-thread-snapshot-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-thread-snapshot-cache.js","sources":["../../../../agent-runtime/src/durable-thread-snapshot-cache.ts"],"sourcesContent":["import {\n  createDeepAgentThreadSnapshotCache,\n  type DeepAgentThreadSnapshotCache,\n} from \"./thread-snapshot-cache\";\nimport { isRestingThreadSnapshot, type ThreadSnapshotMirror } from \"./thread-snapshot-mirror\";\nimport type { DeepAgentStreamValues } from \"./types\";\n\n/**\n * The thread snapshot cache with a durable, encrypted mirror behind it (`thread-snapshot-mirror.ts`):\n * a reload seeds a recently visited thread from what it last showed, and a thread can be read while\n * the transport cannot connect at all.\n *\n * - **Online, nothing changes.** `take` serves the in-memory entry within its age bound (one hour by\n *   default), exactly as the plain cache does, and the attach snapshot replaces the seed.\n * - **Offline** (`isOffline()`: the host's own word that Athena can't be reached), `take` serves the\n *   thread's last resting transcript this page holds (what it read, or what the mirror kept), up to\n *   `offlineMaxAgeMs` old and past the online bound, so a person can read their recent\n *   conversations on a plane. Never a mid-stream state: a run the connection dropped is a partial\n *   transcript, and the resting one before it is what shows. Every offline seed, however recent, is\n *   recorded with its capture time (`offlineSeedAt`) so the host can say the transcript is \"as of\"\n *   then; only the next state the wire delivers for the thread (its attach) clears it.\n * - **Owned.** Entries belong to one owner (`setOwner`): a change drops every entry, deletes the\n *   previous owner's mirrored records and reads the new owner's. A snapshot captured under one\n *   account never seeds a mount under another. `wipe` drops everything (a sign-out).\n */\nexport interface DurableThreadSnapshotCache extends DeepAgentThreadSnapshotCache {\n  peek(threadId: string): boolean;\n  /** Bind the cache to the acting owner (`null`: nobody signed in; nothing is mirrored). */\n  setOwner(ownerId: string | null): Promise<void>;\n  /**\n   * Start reading an owner's mirrored snapshots before the owner is known for sure (a host's\n   * last-owner hint at boot): `setOwner` adopts the read if that owner is the one bound, and it\n   * is discarded otherwise. Binds nothing and deletes nothing.\n   */\n  prime(ownerId: string): void;\n  /** The owner the cache is bound to. */\n  owner(): string | null;\n  /**\n   * When the seed `take` last served for `threadId` was captured, if it was served while Athena\n   * could not be reached; `null` otherwise, and again once the wire delivers the thread.\n   */\n  offlineSeedAt(threadId: string): number | null;\n  /** Calls `listener` whenever an offline seed is served or cleared; returns what stops it. */\n  subscribeOfflineSeeds(listener: () => void): () => void;\n  /** Whether the entry `take` would serve for `threadId` came back from the mirror. */\n  isRestored(threadId: string): boolean;\n  /** Resolves once the current owner's mirrored snapshots have been read (tests, telemetry). */\n  whenHydrated(): Promise<void>;\n  /** Drop every entry, in memory and in the mirror (a sign-out, a workspace switch). */\n  wipe(): Promise<void>;\n}\n\nexport interface DurableThreadSnapshotCacheOptions {\n  mirror: ThreadSnapshotMirror;\n  /** Whether Athena can't be reached right now (the host's reachability, or the browser's). */\n  isOffline?: () => boolean;\n  maxThreads?: number;\n  /** The online age bound (the plain cache's). */\n  maxAgeMs?: number;\n  /** How old a mirrored snapshot may be and still be read offline. */\n  offlineMaxAgeMs?: number;\n  now?: () => number;\n}\n\nconst DEFAULT_MAX_THREADS = 30;\n/** What a device keeps for reading offline: the offline plan's 30 days. */\nexport const OFFLINE_SNAPSHOT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;\n\nfunction browserOffline(): boolean {\n  const host = globalThis as { navigator?: { onLine?: boolean } };\n  return host.navigator?.onLine === false;\n}\n\nexport function createDurableThreadSnapshotCache({\n  mirror,\n  isOffline = browserOffline,\n  maxThreads = DEFAULT_MAX_THREADS,\n  maxAgeMs,\n  offlineMaxAgeMs = OFFLINE_SNAPSHOT_MAX_AGE_MS,\n  now = () => Date.now(),\n}: DurableThreadSnapshotCacheOptions): DurableThreadSnapshotCache {\n  let ownerId: string | null = null;\n  // Bumped on every owner change and wipe: a mirror read in flight then must not admit what it read.\n  let epoch = 0;\n  let primed: { ownerId: string; read: ReturnType<ThreadSnapshotMirror[\"load\"]> } | null = null;\n  let hydration: Promise<void> = Promise.resolve();\n  // Every resting snapshot readable offline (the mirror's, and this page's own), newest last.\n  const offline = new Map<string, { state: DeepAgentStreamValues; at: number }>();\n  const offlineSeeds = new Map<string, number>();\n  const restored = new Set<string>();\n  const listeners = new Set<() => void>();\n\n  const notify = (): void => {\n    for (const listener of listeners) {\n      try {\n        listener();\n      } catch {\n        // A host listener's fault never reaches the wire path.\n      }\n    }\n  };\n  const clearOfflineSeed = (threadId: string): void => {\n    if (offlineSeeds.delete(threadId)) notify();\n  };\n  const keepOffline = (threadId: string, entry: { state: DeepAgentStreamValues; at: number }): void => {\n    offline.delete(threadId);\n    offline.set(threadId, entry);\n    while (offline.size > maxThreads) {\n      const oldest = offline.keys().next().value;\n      if (oldest === undefined) break;\n      offline.delete(oldest);\n    }\n  };\n\n  const memory = createDeepAgentThreadSnapshotCache({\n    maxThreads,\n    maxAgeMs,\n    now,\n    onChange: (change) => {\n      const owner = ownerId;\n      if (owner === null) return;\n      switch (change.type) {\n        case \"remember\":\n          mirror.write({ ownerId: owner, threadId: change.threadId, state: change.state, at: change.at });\n          return;\n        case \"forget\":\n          mirror.remove({ ownerId: owner, threadId: change.threadId });\n          return;\n        case \"clear\":\n          return;\n      }\n    },\n  });\n\n  /** The thread's last resting transcript within the offline bound. */\n  const offlineEntry = (threadId: string): { state: DeepAgentStreamValues; at: number } | undefined => {\n    const entry = offline.get(threadId);\n    return entry && now() - entry.at <= offlineMaxAgeMs ? entry : undefined;\n  };\n\n  const dropEverything = (): void => {\n    memory.clear();\n    offline.clear();\n    restored.clear();\n    if (offlineSeeds.size > 0) {\n      offlineSeeds.clear();\n      notify();\n    }\n  };\n\n  return {\n    remember(threadId, state) {\n      memory.remember(threadId, state);\n      restored.delete(threadId);\n      // A mid-stream state keeps the resting transcript before it readable offline, as the mirror\n      // keeps that one's record. One too long to seal still reads from memory.\n      if (isRestingThreadSnapshot(state)) keepOffline(threadId, { state, at: now() });\n      // The wire delivered the thread: the transcript is current again.\n      clearOfflineSeed(threadId);\n    },\n    take(threadId) {\n      if (!isOffline()) return memory.take(threadId);\n      const entry = offlineEntry(threadId);\n      if (!entry) return undefined;\n      if (offlineSeeds.get(threadId) !== entry.at) {\n        offlineSeeds.set(threadId, entry.at);\n        notify();\n      }\n      return entry.state;\n    },\n    peek(threadId) {\n      return isOffline() ? offlineEntry(threadId) !== undefined : memory.peek(threadId);\n    },\n    forget(threadId) {\n      memory.forget(threadId);\n      offline.delete(threadId);\n      restored.delete(threadId);\n      clearOfflineSeed(threadId);\n    },\n    clear() {\n      dropEverything();\n    },\n    owner: () => ownerId,\n    setOwner(next) {\n      if (next === ownerId) return hydration;\n      const previous = ownerId;\n      ownerId = next;\n      epoch += 1;\n      dropEverything();\n      if (previous !== null) void mirror.clearOwner(previous);\n      if (next === null) {\n        hydration = Promise.resolve();\n        return hydration;\n      }\n      const readEpoch = epoch;\n      const read = primed?.ownerId === next ? primed.read : mirror.load(next);\n      primed = null;\n      hydration = read.then((entries) => {\n        // The owner moved on, or everything was wiped, while the read was in flight.\n        if (readEpoch !== epoch || ownerId !== next) return;\n        for (const entry of entries) {\n          if (!offline.has(entry.threadId)) keepOffline(entry.threadId, { state: entry.state, at: entry.at });\n          if (memory.peek(entry.threadId)) continue;\n          memory.restore(entry.threadId, entry.state, entry.at);\n          if (memory.peek(entry.threadId)) restored.add(entry.threadId);\n        }\n      });\n      return hydration;\n    },\n    prime(next) {\n      if (next === ownerId || primed?.ownerId === next) return;\n      primed = { ownerId: next, read: mirror.load(next) };\n    },\n    offlineSeedAt: (threadId) => offlineSeeds.get(threadId) ?? null,\n    subscribeOfflineSeeds(listener) {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n    isRestored: (threadId) => restored.has(threadId),\n    whenHydrated: () => hydration,\n    async wipe() {\n      epoch += 1;\n      primed = null;\n      dropEverything();\n      await mirror.clearAll();\n    },\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/agent-runtime/src/protocol.cjs

@@ -18,6 +18,19 @@ function projectDeepAgentProtocol(state) {
     clientVersion: runconfigContract.DEEP_AGENT_PROTOCOL_VERSION
   };
 }
+const seedProtocolLanes = /* @__PURE__ */ new WeakSet();
+function withSeedProtocolLane(state) {
+  const lane = state.protocol;
+  if (typeof lane !== "object" || lane === null) return state;
+  const seeded = { ...lane };
+  seedProtocolLanes.add(seeded);
+  return { ...state, protocol: seeded };
+}
+function isDeepAgentHostState(state) {
+  if (typeof state !== "object" || state === null) return false;
+  const lane = state[runconfigContract.DEEP_AGENT_PROTOCOL_STATE_KEY];
+  return typeof lane === "object" && lane !== null && readDeepAgentProtocol(state) !== null && !seedProtocolLanes.has(lane);
+}
 function withDeclaredProtocolVersion(headers) {
   if (runconfigContract.DEEP_AGENT_PROTOCOL_VERSION_HEADER in headers) return headers;
   return {
@@ -25,7 +38,9 @@ function withDeclaredProtocolVersion(headers) {
     [runconfigContract.DEEP_AGENT_PROTOCOL_VERSION_HEADER]: String(runconfigContract.DEEP_AGENT_PROTOCOL_VERSION)
   };
 }
+exports.isDeepAgentHostState = isDeepAgentHostState;
 exports.projectDeepAgentProtocol = projectDeepAgentProtocol;
 exports.readDeepAgentProtocol = readDeepAgentProtocol;
 exports.withDeclaredProtocolVersion = withDeclaredProtocolVersion;
+exports.withSeedProtocolLane = withSeedProtocolLane;
 //# sourceMappingURL=protocol.cjs.map

package/dist/agent-runtime/src/protocol.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"protocol.cjs","sources":["../../../../agent-runtime/src/protocol.ts"],"sourcesContent":["import {\n  DEEP_AGENT_PROTOCOL_STATE_KEY,\n  DEEP_AGENT_PROTOCOL_VERSION,\n  DEEP_AGENT_PROTOCOL_VERSION_HEADER,\n} from './generated/runconfig-contract';\n\n/**\n * Wire-contract version declaration between the deep-agent statewire host and\n * this client build (the client half of agora's\n * `agora/graphs/athena_deep_agent/protocol_version.py`; upstream ask\n * assistant-ui/statewire #31506 would make this a library concern).\n *\n * - Declaration: {@link withDeclaredProtocolVersion} stamps the version this\n *   build speaks (`DEEP_AGENT_PROTOCOL_VERSION`, generated from the Python\n *   source of truth) onto the attach headers — they ride the first WS frame's\n *   mandatory `headers` field / the SSE request headers, so no statewire\n *   change is needed. The host records it for attach telemetry and\n *   per-version behaviour selection only.\n * - Advertisement: the host publishes its own `version` under the `protocol`\n *   state key in every attach snapshot; {@link readDeepAgentProtocol} /\n *   {@link projectDeepAgentProtocol} read it.\n *\n * There is no minimum client version: the host refuses no command for the\n * version its client declared (or for declaring none), so nothing here\n * compares versions or gates a send. Hosts still publish a `minClientVersion`\n * key (the constant 1) for installed clients whose lane reader required it;\n * this reader ignores it.\n *\n * Skew-tolerant on both sides: an old server advertises nothing (project\n * `null`, gate nothing), and a malformed lane reads as absent — the\n * declaration must never brick a client that could otherwise talk.\n */\nexport interface DeepAgentWireProtocol {\n  /** The wire-contract version the server speaks. */\n  version: number;\n}\n\n/** The advertised-lane projection a host surface reads. */\nexport interface DeepAgentProtocolStatus {\n  /** Server-advertised current contract version. */\n  protocolVersion: number;\n  /** The contract version THIS client build declares. */\n  clientVersion: number;\n}\n\nconst isContractVersion = (value: unknown): value is number =>\n  typeof value === 'number' && Number.isInteger(value) && value >= 1;\n\n/**\n * The server-advertised version lane off a raw statewire state, or `null`\n * while it is unreadable — pre-attach, a pre-negotiation server's snapshot\n * (no lane), or a malformed lane (tolerated as absent, never thrown on).\n */\nexport function readDeepAgentProtocol(state: unknown): DeepAgentWireProtocol | null {\n  if (typeof state !== 'object' || state === null) return null;\n  const lane = (state as Record<string, unknown>)[DEEP_AGENT_PROTOCOL_STATE_KEY];\n  if (typeof lane !== 'object' || lane === null) return null;\n  const { version } = lane as Record<string, unknown>;\n  if (!isContractVersion(version)) return null;\n  return { version };\n}\n\n/**\n * Project the advertised version for a host surface, or `null` while the\n * server has not advertised (see {@link readDeepAgentProtocol}). Pure and\n * selector-safe, mirroring `readSessionPersisted`.\n */\nexport function projectDeepAgentProtocol(state: unknown): DeepAgentProtocolStatus | null {\n  const lane = readDeepAgentProtocol(state);\n  if (lane === null) return null;\n  return {\n    protocolVersion: lane.version,\n    clientVersion: DEEP_AGENT_PROTOCOL_VERSION,\n  };\n}\n\n/**\n * Attach headers with this build's contract version declared. Applied by\n * `useDeepAgentThread` to every resolved header set, so all surfaces declare\n * without per-host wiring; an explicit entry (tests, forced overrides) wins.\n */\nexport function withDeclaredProtocolVersion(\n  headers: Record<string, string>\n): Record<string, string> {\n  if (DEEP_AGENT_PROTOCOL_VERSION_HEADER in headers) return headers;\n  return {\n    ...headers,\n    [DEEP_AGENT_PROTOCOL_VERSION_HEADER]: String(DEEP_AGENT_PROTOCOL_VERSION),\n  };\n}\n"],"names":["DEEP_AGENT_PROTOCOL_STATE_KEY","DEEP_AGENT_PROTOCOL_VERSION","DEEP_AGENT_PROTOCOL_VERSION_HEADER"],"mappings":";;;AA6CA,MAAM,oBAAoB,CAAC,UACzB,OAAO,UAAU,YAAY,OAAO,UAAU,KAAK,KAAK,SAAS;AAO5D,SAAS,sBAAsB,OAA8C;AAClF,MAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,QAAM,OAAQ,MAAkCA,+CAA6B;AAC7E,MAAI,OAAO,SAAS,YAAY,SAAS,KAAM,QAAO;AACtD,QAAM,EAAE,YAAY;AACpB,MAAI,CAAC,kBAAkB,OAAO,EAAG,QAAO;AACxC,SAAO,EAAE,QAAA;AACX;AAOO,SAAS,yBAAyB,OAAgD;AACvF,QAAM,OAAO,sBAAsB,KAAK;AACxC,MAAI,SAAS,KAAM,QAAO;AAC1B,SAAO;AAAA,IACL,iBAAiB,KAAK;AAAA,IACtB,eAAeC,kBAAAA;AAAAA,EAAA;AAEnB;AAOO,SAAS,4BACd,SACwB;AACxB,MAAIC,kBAAAA,sCAAsC,QAAS,QAAO;AAC1D,SAAO;AAAA,IACL,GAAG;AAAA,IACH,CAACA,kBAAAA,kCAAkC,GAAG,OAAOD,kBAAAA,2BAA2B;AAAA,EAAA;AAE5E;;;;"}
+{"version":3,"file":"protocol.cjs","sources":["../../../../agent-runtime/src/protocol.ts"],"sourcesContent":["import {\n  DEEP_AGENT_PROTOCOL_STATE_KEY,\n  DEEP_AGENT_PROTOCOL_VERSION,\n  DEEP_AGENT_PROTOCOL_VERSION_HEADER,\n} from './generated/runconfig-contract';\nimport type { DeepAgentStreamValues } from './types';\n\n/**\n * Wire-contract version declaration between the deep-agent statewire host and\n * this client build (the client half of agora's\n * `agora/graphs/athena_deep_agent/protocol_version.py`; upstream ask\n * assistant-ui/statewire #31506 would make this a library concern).\n *\n * - Declaration: {@link withDeclaredProtocolVersion} stamps the version this\n *   build speaks (`DEEP_AGENT_PROTOCOL_VERSION`, generated from the Python\n *   source of truth) onto the attach headers — they ride the first WS frame's\n *   mandatory `headers` field / the SSE request headers, so no statewire\n *   change is needed. The host records it for attach telemetry and\n *   per-version behaviour selection only.\n * - Advertisement: the host publishes its own `version` under the `protocol`\n *   state key in every attach snapshot; {@link readDeepAgentProtocol} /\n *   {@link projectDeepAgentProtocol} read it.\n *\n * There is no minimum client version: the host refuses no command for the\n * version its client declared (or for declaring none), so nothing here\n * compares versions or gates a send. Hosts still publish a `minClientVersion`\n * key (the constant 1) for installed clients whose lane reader required it;\n * this reader ignores it.\n *\n * Skew-tolerant on both sides: an old server advertises nothing (project\n * `null`, gate nothing), and a malformed lane reads as absent — the\n * declaration must never brick a client that could otherwise talk.\n */\nexport interface DeepAgentWireProtocol {\n  /** The wire-contract version the server speaks. */\n  version: number;\n}\n\n/** The advertised-lane projection a host surface reads. */\nexport interface DeepAgentProtocolStatus {\n  /** Server-advertised current contract version. */\n  protocolVersion: number;\n  /** The contract version THIS client build declares. */\n  clientVersion: number;\n}\n\nconst isContractVersion = (value: unknown): value is number =>\n  typeof value === 'number' && Number.isInteger(value) && value >= 1;\n\n/**\n * The server-advertised version lane off a raw statewire state, or `null`\n * while it is unreadable — pre-attach, a pre-negotiation server's snapshot\n * (no lane), or a malformed lane (tolerated as absent, never thrown on).\n */\nexport function readDeepAgentProtocol(state: unknown): DeepAgentWireProtocol | null {\n  if (typeof state !== 'object' || state === null) return null;\n  const lane = (state as Record<string, unknown>)[DEEP_AGENT_PROTOCOL_STATE_KEY];\n  if (typeof lane !== 'object' || lane === null) return null;\n  const { version } = lane as Record<string, unknown>;\n  if (!isContractVersion(version)) return null;\n  return { version };\n}\n\n/**\n * Project the advertised version for a host surface, or `null` while the\n * server has not advertised (see {@link readDeepAgentProtocol}). Pure and\n * selector-safe, mirroring `readSessionPersisted`.\n */\nexport function projectDeepAgentProtocol(state: unknown): DeepAgentProtocolStatus | null {\n  const lane = readDeepAgentProtocol(state);\n  if (lane === null) return null;\n  return {\n    protocolVersion: lane.version,\n    clientVersion: DEEP_AGENT_PROTOCOL_VERSION,\n  };\n}\n\n/**\n * The protocol lanes seeds carry ({@link withSeedProtocolLane}), by identity.\n * Statewire's optimistic folds are copy-on-write, so every state folded over a\n * seed keeps its lane object, while a state the host sent never holds one\n * (each is parsed off the wire).\n */\nconst seedProtocolLanes = new WeakSet<object>();\n\n/**\n * `state` with a protocol lane of its own, remembered as a seed's — for the\n * remembered states a mount is seeded with (`toThreadSnapshotSeed`), whose\n * lanes are what the host sent an earlier attach. The lane is copied rather\n * than remembered in place, so a live attach still holding the original object\n * is never read as a seed.\n */\nexport function withSeedProtocolLane(state: DeepAgentStreamValues): DeepAgentStreamValues {\n  const lane = state.protocol;\n  if (typeof lane !== 'object' || lane === null) return state;\n  const seeded = { ...lane };\n  seedProtocolLanes.add(seeded);\n  return { ...state, protocol: seeded };\n}\n\n/**\n * Whether `state` is one the host sent on this attach. The host advertises the\n * protocol lane in every attach snapshot and keeps it on every later frame;\n * the states a thread renders before its snapshot carry none (the placeholder\n * an existing thread loads with, and any optimistic fold over it) or a seed's\n * ({@link withSeedProtocolLane}).\n *\n * Decide anything about what the host holds — its config lane above all —\n * from these states only, never from the connection status: on a thread\n * mid-run the channel reports `connected` before the attach snapshot applies,\n * and a placeholder read as the host's says the thread has no config.\n *\n * A host predating the lane (2026-08-28) never answers true; the config lane\n * writes clients make (`config/patch`, 2026-09-05) came after it.\n */\nexport function isDeepAgentHostState(state: unknown): boolean {\n  if (typeof state !== 'object' || state === null) return false;\n  const lane = (state as Record<string, unknown>)[DEEP_AGENT_PROTOCOL_STATE_KEY];\n  return (\n    typeof lane === 'object' &&\n    lane !== null &&\n    readDeepAgentProtocol(state) !== null &&\n    !seedProtocolLanes.has(lane)\n  );\n}\n\n/**\n * Attach headers with this build's contract version declared. Applied by\n * `useDeepAgentThread` to every resolved header set, so all surfaces declare\n * without per-host wiring; an explicit entry (tests, forced overrides) wins.\n */\nexport function withDeclaredProtocolVersion(\n  headers: Record<string, string>\n): Record<string, string> {\n  if (DEEP_AGENT_PROTOCOL_VERSION_HEADER in headers) return headers;\n  return {\n    ...headers,\n    [DEEP_AGENT_PROTOCOL_VERSION_HEADER]: String(DEEP_AGENT_PROTOCOL_VERSION),\n  };\n}\n"],"names":["DEEP_AGENT_PROTOCOL_STATE_KEY","DEEP_AGENT_PROTOCOL_VERSION","DEEP_AGENT_PROTOCOL_VERSION_HEADER"],"mappings":";;;AA8CA,MAAM,oBAAoB,CAAC,UACzB,OAAO,UAAU,YAAY,OAAO,UAAU,KAAK,KAAK,SAAS;AAO5D,SAAS,sBAAsB,OAA8C;AAClF,MAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,QAAM,OAAQ,MAAkCA,+CAA6B;AAC7E,MAAI,OAAO,SAAS,YAAY,SAAS,KAAM,QAAO;AACtD,QAAM,EAAE,YAAY;AACpB,MAAI,CAAC,kBAAkB,OAAO,EAAG,QAAO;AACxC,SAAO,EAAE,QAAA;AACX;AAOO,SAAS,yBAAyB,OAAgD;AACvF,QAAM,OAAO,sBAAsB,KAAK;AACxC,MAAI,SAAS,KAAM,QAAO;AAC1B,SAAO;AAAA,IACL,iBAAiB,KAAK;AAAA,IACtB,eAAeC,kBAAAA;AAAAA,EAAA;AAEnB;AAQA,MAAM,wCAAwB,QAAA;AASvB,SAAS,qBAAqB,OAAqD;AACxF,QAAM,OAAO,MAAM;AACnB,MAAI,OAAO,SAAS,YAAY,SAAS,KAAM,QAAO;AACtD,QAAM,SAAS,EAAE,GAAG,KAAA;AACpB,oBAAkB,IAAI,MAAM;AAC5B,SAAO,EAAE,GAAG,OAAO,UAAU,OAAA;AAC/B;AAiBO,SAAS,qBAAqB,OAAyB;AAC5D,MAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,QAAM,OAAQ,MAAkCD,+CAA6B;AAC7E,SACE,OAAO,SAAS,YAChB,SAAS,QACT,sBAAsB,KAAK,MAAM,QACjC,CAAC,kBAAkB,IAAI,IAAI;AAE/B;AAOO,SAAS,4BACd,SACwB;AACxB,MAAIE,kBAAAA,sCAAsC,QAAS,QAAO;AAC1D,SAAO;AAAA,IACL,GAAG;AAAA,IACH,CAACA,kBAAAA,kCAAkC,GAAG,OAAOD,kBAAAA,2BAA2B;AAAA,EAAA;AAE5E;;;;;;"}

package/dist/agent-runtime/src/protocol.js

@@ -16,6 +16,19 @@ function projectDeepAgentProtocol(state) {
     clientVersion: DEEP_AGENT_PROTOCOL_VERSION
   };
 }
+const seedProtocolLanes = /* @__PURE__ */ new WeakSet();
+function withSeedProtocolLane(state) {
+  const lane = state.protocol;
+  if (typeof lane !== "object" || lane === null) return state;
+  const seeded = { ...lane };
+  seedProtocolLanes.add(seeded);
+  return { ...state, protocol: seeded };
+}
+function isDeepAgentHostState(state) {
+  if (typeof state !== "object" || state === null) return false;
+  const lane = state[DEEP_AGENT_PROTOCOL_STATE_KEY];
+  return typeof lane === "object" && lane !== null && readDeepAgentProtocol(state) !== null && !seedProtocolLanes.has(lane);
+}
 function withDeclaredProtocolVersion(headers) {
   if (DEEP_AGENT_PROTOCOL_VERSION_HEADER in headers) return headers;
   return {
@@ -24,8 +37,10 @@ function withDeclaredProtocolVersion(headers) {
   };
 }
 export {
+  isDeepAgentHostState,
   projectDeepAgentProtocol,
   readDeepAgentProtocol,
-  withDeclaredProtocolVersion
+  withDeclaredProtocolVersion,
+  withSeedProtocolLane
 };
 //# sourceMappingURL=protocol.js.map

package/dist/agent-runtime/src/protocol.js.map

@@ -1 +1 @@
-{"version":3,"file":"protocol.js","sources":["../../../../agent-runtime/src/protocol.ts"],"sourcesContent":["import {\n  DEEP_AGENT_PROTOCOL_STATE_KEY,\n  DEEP_AGENT_PROTOCOL_VERSION,\n  DEEP_AGENT_PROTOCOL_VERSION_HEADER,\n} from './generated/runconfig-contract';\n\n/**\n * Wire-contract version declaration between the deep-agent statewire host and\n * this client build (the client half of agora's\n * `agora/graphs/athena_deep_agent/protocol_version.py`; upstream ask\n * assistant-ui/statewire #31506 would make this a library concern).\n *\n * - Declaration: {@link withDeclaredProtocolVersion} stamps the version this\n *   build speaks (`DEEP_AGENT_PROTOCOL_VERSION`, generated from the Python\n *   source of truth) onto the attach headers — they ride the first WS frame's\n *   mandatory `headers` field / the SSE request headers, so no statewire\n *   change is needed. The host records it for attach telemetry and\n *   per-version behaviour selection only.\n * - Advertisement: the host publishes its own `version` under the `protocol`\n *   state key in every attach snapshot; {@link readDeepAgentProtocol} /\n *   {@link projectDeepAgentProtocol} read it.\n *\n * There is no minimum client version: the host refuses no command for the\n * version its client declared (or for declaring none), so nothing here\n * compares versions or gates a send. Hosts still publish a `minClientVersion`\n * key (the constant 1) for installed clients whose lane reader required it;\n * this reader ignores it.\n *\n * Skew-tolerant on both sides: an old server advertises nothing (project\n * `null`, gate nothing), and a malformed lane reads as absent — the\n * declaration must never brick a client that could otherwise talk.\n */\nexport interface DeepAgentWireProtocol {\n  /** The wire-contract version the server speaks. */\n  version: number;\n}\n\n/** The advertised-lane projection a host surface reads. */\nexport interface DeepAgentProtocolStatus {\n  /** Server-advertised current contract version. */\n  protocolVersion: number;\n  /** The contract version THIS client build declares. */\n  clientVersion: number;\n}\n\nconst isContractVersion = (value: unknown): value is number =>\n  typeof value === 'number' && Number.isInteger(value) && value >= 1;\n\n/**\n * The server-advertised version lane off a raw statewire state, or `null`\n * while it is unreadable — pre-attach, a pre-negotiation server's snapshot\n * (no lane), or a malformed lane (tolerated as absent, never thrown on).\n */\nexport function readDeepAgentProtocol(state: unknown): DeepAgentWireProtocol | null {\n  if (typeof state !== 'object' || state === null) return null;\n  const lane = (state as Record<string, unknown>)[DEEP_AGENT_PROTOCOL_STATE_KEY];\n  if (typeof lane !== 'object' || lane === null) return null;\n  const { version } = lane as Record<string, unknown>;\n  if (!isContractVersion(version)) return null;\n  return { version };\n}\n\n/**\n * Project the advertised version for a host surface, or `null` while the\n * server has not advertised (see {@link readDeepAgentProtocol}). Pure and\n * selector-safe, mirroring `readSessionPersisted`.\n */\nexport function projectDeepAgentProtocol(state: unknown): DeepAgentProtocolStatus | null {\n  const lane = readDeepAgentProtocol(state);\n  if (lane === null) return null;\n  return {\n    protocolVersion: lane.version,\n    clientVersion: DEEP_AGENT_PROTOCOL_VERSION,\n  };\n}\n\n/**\n * Attach headers with this build's contract version declared. Applied by\n * `useDeepAgentThread` to every resolved header set, so all surfaces declare\n * without per-host wiring; an explicit entry (tests, forced overrides) wins.\n */\nexport function withDeclaredProtocolVersion(\n  headers: Record<string, string>\n): Record<string, string> {\n  if (DEEP_AGENT_PROTOCOL_VERSION_HEADER in headers) return headers;\n  return {\n    ...headers,\n    [DEEP_AGENT_PROTOCOL_VERSION_HEADER]: String(DEEP_AGENT_PROTOCOL_VERSION),\n  };\n}\n"],"names":[],"mappings":";AA6CA,MAAM,oBAAoB,CAAC,UACzB,OAAO,UAAU,YAAY,OAAO,UAAU,KAAK,KAAK,SAAS;AAO5D,SAAS,sBAAsB,OAA8C;AAClF,MAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,QAAM,OAAQ,MAAkC,6BAA6B;AAC7E,MAAI,OAAO,SAAS,YAAY,SAAS,KAAM,QAAO;AACtD,QAAM,EAAE,YAAY;AACpB,MAAI,CAAC,kBAAkB,OAAO,EAAG,QAAO;AACxC,SAAO,EAAE,QAAA;AACX;AAOO,SAAS,yBAAyB,OAAgD;AACvF,QAAM,OAAO,sBAAsB,KAAK;AACxC,MAAI,SAAS,KAAM,QAAO;AAC1B,SAAO;AAAA,IACL,iBAAiB,KAAK;AAAA,IACtB,eAAe;AAAA,EAAA;AAEnB;AAOO,SAAS,4BACd,SACwB;AACxB,MAAI,sCAAsC,QAAS,QAAO;AAC1D,SAAO;AAAA,IACL,GAAG;AAAA,IACH,CAAC,kCAAkC,GAAG,OAAO,2BAA2B;AAAA,EAAA;AAE5E;"}
+{"version":3,"file":"protocol.js","sources":["../../../../agent-runtime/src/protocol.ts"],"sourcesContent":["import {\n  DEEP_AGENT_PROTOCOL_STATE_KEY,\n  DEEP_AGENT_PROTOCOL_VERSION,\n  DEEP_AGENT_PROTOCOL_VERSION_HEADER,\n} from './generated/runconfig-contract';\nimport type { DeepAgentStreamValues } from './types';\n\n/**\n * Wire-contract version declaration between the deep-agent statewire host and\n * this client build (the client half of agora's\n * `agora/graphs/athena_deep_agent/protocol_version.py`; upstream ask\n * assistant-ui/statewire #31506 would make this a library concern).\n *\n * - Declaration: {@link withDeclaredProtocolVersion} stamps the version this\n *   build speaks (`DEEP_AGENT_PROTOCOL_VERSION`, generated from the Python\n *   source of truth) onto the attach headers — they ride the first WS frame's\n *   mandatory `headers` field / the SSE request headers, so no statewire\n *   change is needed. The host records it for attach telemetry and\n *   per-version behaviour selection only.\n * - Advertisement: the host publishes its own `version` under the `protocol`\n *   state key in every attach snapshot; {@link readDeepAgentProtocol} /\n *   {@link projectDeepAgentProtocol} read it.\n *\n * There is no minimum client version: the host refuses no command for the\n * version its client declared (or for declaring none), so nothing here\n * compares versions or gates a send. Hosts still publish a `minClientVersion`\n * key (the constant 1) for installed clients whose lane reader required it;\n * this reader ignores it.\n *\n * Skew-tolerant on both sides: an old server advertises nothing (project\n * `null`, gate nothing), and a malformed lane reads as absent — the\n * declaration must never brick a client that could otherwise talk.\n */\nexport interface DeepAgentWireProtocol {\n  /** The wire-contract version the server speaks. */\n  version: number;\n}\n\n/** The advertised-lane projection a host surface reads. */\nexport interface DeepAgentProtocolStatus {\n  /** Server-advertised current contract version. */\n  protocolVersion: number;\n  /** The contract version THIS client build declares. */\n  clientVersion: number;\n}\n\nconst isContractVersion = (value: unknown): value is number =>\n  typeof value === 'number' && Number.isInteger(value) && value >= 1;\n\n/**\n * The server-advertised version lane off a raw statewire state, or `null`\n * while it is unreadable — pre-attach, a pre-negotiation server's snapshot\n * (no lane), or a malformed lane (tolerated as absent, never thrown on).\n */\nexport function readDeepAgentProtocol(state: unknown): DeepAgentWireProtocol | null {\n  if (typeof state !== 'object' || state === null) return null;\n  const lane = (state as Record<string, unknown>)[DEEP_AGENT_PROTOCOL_STATE_KEY];\n  if (typeof lane !== 'object' || lane === null) return null;\n  const { version } = lane as Record<string, unknown>;\n  if (!isContractVersion(version)) return null;\n  return { version };\n}\n\n/**\n * Project the advertised version for a host surface, or `null` while the\n * server has not advertised (see {@link readDeepAgentProtocol}). Pure and\n * selector-safe, mirroring `readSessionPersisted`.\n */\nexport function projectDeepAgentProtocol(state: unknown): DeepAgentProtocolStatus | null {\n  const lane = readDeepAgentProtocol(state);\n  if (lane === null) return null;\n  return {\n    protocolVersion: lane.version,\n    clientVersion: DEEP_AGENT_PROTOCOL_VERSION,\n  };\n}\n\n/**\n * The protocol lanes seeds carry ({@link withSeedProtocolLane}), by identity.\n * Statewire's optimistic folds are copy-on-write, so every state folded over a\n * seed keeps its lane object, while a state the host sent never holds one\n * (each is parsed off the wire).\n */\nconst seedProtocolLanes = new WeakSet<object>();\n\n/**\n * `state` with a protocol lane of its own, remembered as a seed's — for the\n * remembered states a mount is seeded with (`toThreadSnapshotSeed`), whose\n * lanes are what the host sent an earlier attach. The lane is copied rather\n * than remembered in place, so a live attach still holding the original object\n * is never read as a seed.\n */\nexport function withSeedProtocolLane(state: DeepAgentStreamValues): DeepAgentStreamValues {\n  const lane = state.protocol;\n  if (typeof lane !== 'object' || lane === null) return state;\n  const seeded = { ...lane };\n  seedProtocolLanes.add(seeded);\n  return { ...state, protocol: seeded };\n}\n\n/**\n * Whether `state` is one the host sent on this attach. The host advertises the\n * protocol lane in every attach snapshot and keeps it on every later frame;\n * the states a thread renders before its snapshot carry none (the placeholder\n * an existing thread loads with, and any optimistic fold over it) or a seed's\n * ({@link withSeedProtocolLane}).\n *\n * Decide anything about what the host holds — its config lane above all —\n * from these states only, never from the connection status: on a thread\n * mid-run the channel reports `connected` before the attach snapshot applies,\n * and a placeholder read as the host's says the thread has no config.\n *\n * A host predating the lane (2026-08-28) never answers true; the config lane\n * writes clients make (`config/patch`, 2026-09-05) came after it.\n */\nexport function isDeepAgentHostState(state: unknown): boolean {\n  if (typeof state !== 'object' || state === null) return false;\n  const lane = (state as Record<string, unknown>)[DEEP_AGENT_PROTOCOL_STATE_KEY];\n  return (\n    typeof lane === 'object' &&\n    lane !== null &&\n    readDeepAgentProtocol(state) !== null &&\n    !seedProtocolLanes.has(lane)\n  );\n}\n\n/**\n * Attach headers with this build's contract version declared. Applied by\n * `useDeepAgentThread` to every resolved header set, so all surfaces declare\n * without per-host wiring; an explicit entry (tests, forced overrides) wins.\n */\nexport function withDeclaredProtocolVersion(\n  headers: Record<string, string>\n): Record<string, string> {\n  if (DEEP_AGENT_PROTOCOL_VERSION_HEADER in headers) return headers;\n  return {\n    ...headers,\n    [DEEP_AGENT_PROTOCOL_VERSION_HEADER]: String(DEEP_AGENT_PROTOCOL_VERSION),\n  };\n}\n"],"names":[],"mappings":";AA8CA,MAAM,oBAAoB,CAAC,UACzB,OAAO,UAAU,YAAY,OAAO,UAAU,KAAK,KAAK,SAAS;AAO5D,SAAS,sBAAsB,OAA8C;AAClF,MAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,QAAM,OAAQ,MAAkC,6BAA6B;AAC7E,MAAI,OAAO,SAAS,YAAY,SAAS,KAAM,QAAO;AACtD,QAAM,EAAE,YAAY;AACpB,MAAI,CAAC,kBAAkB,OAAO,EAAG,QAAO;AACxC,SAAO,EAAE,QAAA;AACX;AAOO,SAAS,yBAAyB,OAAgD;AACvF,QAAM,OAAO,sBAAsB,KAAK;AACxC,MAAI,SAAS,KAAM,QAAO;AAC1B,SAAO;AAAA,IACL,iBAAiB,KAAK;AAAA,IACtB,eAAe;AAAA,EAAA;AAEnB;AAQA,MAAM,wCAAwB,QAAA;AASvB,SAAS,qBAAqB,OAAqD;AACxF,QAAM,OAAO,MAAM;AACnB,MAAI,OAAO,SAAS,YAAY,SAAS,KAAM,QAAO;AACtD,QAAM,SAAS,EAAE,GAAG,KAAA;AACpB,oBAAkB,IAAI,MAAM;AAC5B,SAAO,EAAE,GAAG,OAAO,UAAU,OAAA;AAC/B;AAiBO,SAAS,qBAAqB,OAAyB;AAC5D,MAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,QAAM,OAAQ,MAAkC,6BAA6B;AAC7E,SACE,OAAO,SAAS,YAChB,SAAS,QACT,sBAAsB,KAAK,MAAM,QACjC,CAAC,kBAAkB,IAAI,IAAI;AAE/B;AAOO,SAAS,4BACd,SACwB;AACxB,MAAI,sCAAsC,QAAS,QAAO;AAC1D,SAAO;AAAA,IACL,GAAG;AAAA,IACH,CAAC,kCAAkC,GAAG,OAAO,2BAA2B;AAAA,EAAA;AAE5E;"}

package/dist/agent-runtime/src/thread-snapshot-cache.cjs

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const protocol = require("./protocol.cjs");
 const DEFAULT_MAX_THREADS = 30;
 const DEFAULT_MAX_AGE_MS = 60 * 60 * 1e3;
 function createDeepAgentThreadSnapshotCache(options = {}) {
@@ -70,7 +71,7 @@ function toThreadSnapshotSeed(state) {
     outOfBandRunActive: _outOfBandRunActive,
     ...rest
   } = state;
-  return { ...rest, runs: seedRunsLane(state.runs) };
+  return protocol.withSeedProtocolLane({ ...rest, runs: seedRunsLane(state.runs) });
 }
 function seedRunsLane(runs) {
   const live = runs == null ? void 0 : runs[0];

package/dist/agent-runtime/src/thread-snapshot-cache.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"thread-snapshot-cache.cjs","sources":["../../../../agent-runtime/src/thread-snapshot-cache.ts"],"sourcesContent":["import type { DeepAgentStreamValues } from './types';\n\n/**\n * Per-tab LRU of the last wire state seen per thread, so a switch back to a\n * recently-visited thread can mount with that snapshot instead of an empty\n * \"loading\" state (see `UseDeepAgentThreadOptions.snapshotCache`). Entries are\n * references into states the wire already produced — remembering is O(1) and\n * copies nothing; the bound is `maxThreads` retained states.\n */\nexport interface DeepAgentThreadSnapshotCache {\n  /** Record the latest hydrated wire state for a thread. */\n  remember(threadId: string, state: DeepAgentStreamValues): void;\n  /** The freshest remembered state for a thread, or `undefined` when none is\n   * held or the entry aged out. */\n  take(threadId: string): DeepAgentStreamValues | undefined;\n  /**\n   * Drop a single thread's entry. Called when the server refuses\n   * authorization for the thread — a refused thread must not warm-paint on\n   * its next mount.\n   */\n  forget(threadId: string): void;\n  /**\n   * Drop every entry. Called when the acting identity changes — a snapshot\n   * captured under one account must never seed a mount under another.\n   */\n  clear(): void;\n  /**\n   * Whether a fresh entry is held for the thread, without consuming or\n   * touching it. Hosts read it at selection time to decide whether the switch\n   * can paint from a seed (no loading treatment) or must cover the attach\n   * wait. Optional so hand-rolled caches keep type-checking; the built-in\n   * cache implements it.\n   */\n  peek?(threadId: string): boolean;\n}\n\n/** A write observed on the cache — the durable-mirror seam (see `onChange`). */\nexport type DeepAgentThreadSnapshotCacheChange =\n  | { type: 'remember'; threadId: string; state: DeepAgentStreamValues; at: number }\n  | { type: 'forget'; threadId: string }\n  | { type: 'clear' };\n\nexport interface DeepAgentThreadSnapshotCacheOptions {\n  /** Threads retained; the least-recently written entry evicts beyond this. */\n  maxThreads?: number;\n  /**\n   * Entries older than this are dropped at read time. The seed's value is\n   * \"the thread you just left\" — a snapshot from long ago is more likely to\n   * flash content the server has since rewritten than to save a paint.\n   */\n  maxAgeMs?: number;\n  /**\n   * Observer of every write (`remember`, `forget`, `clear`). Hosts mirror\n   * entries into durable storage from here so a reload can seed too; the\n   * observer is never invoked for `restore`, which re-admits mirrored entries.\n   * Exceptions are swallowed — a mirror fault must not break the wire path.\n   */\n  onChange?: (change: DeepAgentThreadSnapshotCacheChange) => void;\n  /** Injectable clock (tests). */\n  now?: () => number;\n}\n\n/** The built-in cache: the host contract plus the durable-mirror re-admission. */\nexport interface CreatedDeepAgentThreadSnapshotCache extends DeepAgentThreadSnapshotCache {\n  peek(threadId: string): boolean;\n  /**\n   * Re-admit an entry captured earlier — a mirrored snapshot after a reload —\n   * under its ORIGINAL capture time, so the age bound still applies. Never\n   * displaces a fresher in-memory entry and never notifies `onChange`.\n   */\n  restore(threadId: string, state: DeepAgentStreamValues, at: number): void;\n}\n\nconst DEFAULT_MAX_THREADS = 30;\nconst DEFAULT_MAX_AGE_MS = 60 * 60 * 1000;\n\nexport function createDeepAgentThreadSnapshotCache(\n  options: DeepAgentThreadSnapshotCacheOptions = {}\n): CreatedDeepAgentThreadSnapshotCache {\n  const maxThreads = options.maxThreads ?? DEFAULT_MAX_THREADS;\n  const maxAgeMs = options.maxAgeMs ?? DEFAULT_MAX_AGE_MS;\n  const now = options.now ?? (() => Date.now());\n  const notify = (change: DeepAgentThreadSnapshotCacheChange): void => {\n    try {\n      options.onChange?.(change);\n    } catch {\n      // The mirror is best-effort; the in-memory cache stays authoritative.\n    }\n  };\n  // Map iteration order is insertion order; delete-then-set on every write\n  // keeps the first key the least-recently written.\n  const entries = new Map<string, { state: DeepAgentStreamValues; at: number }>();\n  const evict = (): void => {\n    while (entries.size > maxThreads) {\n      const oldest = entries.keys().next().value;\n      if (oldest === undefined) break;\n      entries.delete(oldest);\n    }\n  };\n  const fresh = (threadId: string): { state: DeepAgentStreamValues; at: number } | undefined => {\n    const entry = entries.get(threadId);\n    if (!entry) return undefined;\n    if (now() - entry.at > maxAgeMs) {\n      entries.delete(threadId);\n      return undefined;\n    }\n    return entry;\n  };\n  return {\n    remember(threadId, state) {\n      const at = now();\n      entries.delete(threadId);\n      entries.set(threadId, { state, at });\n      evict();\n      notify({ type: 'remember', threadId, state, at });\n    },\n    take(threadId) {\n      return fresh(threadId)?.state;\n    },\n    peek(threadId) {\n      return fresh(threadId) !== undefined;\n    },\n    restore(threadId, state, at) {\n      if (now() - at > maxAgeMs) return;\n      const existing = entries.get(threadId);\n      if (existing && existing.at >= at) return;\n      entries.delete(threadId);\n      entries.set(threadId, { state, at });\n      evict();\n    },\n    forget(threadId) {\n      entries.delete(threadId);\n      notify({ type: 'forget', threadId });\n    },\n    clear() {\n      entries.clear();\n      notify({ type: 'clear' });\n    },\n  };\n}\n\n/**\n * Shape a remembered wire state for use as a mount's `initialState`.\n *\n * Messages/todos and the other app-owned keys seed as captured. The run lane\n * seeds by what the user left: a thread whose run was `running` when the\n * snapshot was taken seeds a running entry (see {@link seedRunsLane}) so the\n * switch back reads Running with a Stop control on its first frame — the same\n * frame `runs: []` would render as \"ready\" with a Send button over a thread the\n * server is still mid-run on. Every other live-lifecycle lane normalizes to\n * resting: a seeded input request could collect a decision the server may have\n * already resolved, so an `input-required` entry seeds as no run at all.\n * `__interrupt__` is dropped for the same reason, and so are `ptc_subagents`\n * (the live in-eval dispatch lane — a seeded \"running\" dispatch card under a\n * resting thread would render active with no eval behind it) and\n * `outOfBandRunActive` (the host's out-of-band-run-in-progress flag — seeding a\n * finished run's `true` would hide the composer until the attach corrected\n * it). Durable thread properties (`runConfig`, `sessionPersisted`, …) seed as\n * captured; the attach snapshot then replaces the whole seed.\n */\nexport function toThreadSnapshotSeed(state: DeepAgentStreamValues): DeepAgentStreamValues {\n  const {\n    __interrupt__: _interrupt,\n    ptc_subagents: _ptcSubagents,\n    outOfBandRunActive: _outOfBandRunActive,\n    ...rest\n  } = state;\n  return { ...rest, runs: seedRunsLane(state.runs) };\n}\n\n/**\n * The run entries a seed carries.\n *\n * Only a `running` entry survives, and only its replicated identity and its\n * durable lanes: `runId` (the target of a Stop sent during the attach\n * round-trip — the live run's id if it is still running, and a refused stop\n * if it finished meanwhile), `epoch` (rides that Stop so a replayed stop cannot\n * end a later leg) and the `queue`/`steerQueue` entries (server lanes the tray\n * renders). The in-flight records rest until the snapshot: `dispatching` and\n * `nextDispatch` are batches the materializer would re-apply onto messages\n * that already contain them, `stopping` is a rewind the host may have\n * finished, `inputRequests` is a parked decision, and `error` is a failure the\n * next user run clears. An entry in any other status — `stopped`, `error`,\n * `input-required` — seeds as no run.\n */\nfunction seedRunsLane(\n  runs: DeepAgentStreamValues['runs']\n): NonNullable<DeepAgentStreamValues['runs']> {\n  const live = runs?.[0];\n  if (live === undefined || live.status !== 'running') return [];\n  return [\n    {\n      runId: live.runId,\n      status: 'running',\n      queue: live.queue,\n      steerQueue: live.steerQueue,\n      ...(live.epoch !== undefined && { epoch: live.epoch }),\n    },\n  ];\n}\n"],"names":[],"mappings":";;AAyEA,MAAM,sBAAsB;AAC5B,MAAM,qBAAqB,KAAK,KAAK;AAE9B,SAAS,mCACd,UAA+C,IACV;AACrC,QAAM,aAAa,QAAQ,cAAc;AACzC,QAAM,WAAW,QAAQ,YAAY;AACrC,QAAM,MAAM,QAAQ,QAAQ,MAAM,KAAK,IAAA;AACvC,QAAM,SAAS,CAAC,WAAqD;;AACnE,QAAI;AACF,oBAAQ,aAAR,iCAAmB;AAAA,IACrB,QAAQ;AAAA,IAER;AAAA,EACF;AAGA,QAAM,8BAAc,IAAA;AACpB,QAAM,QAAQ,MAAY;AACxB,WAAO,QAAQ,OAAO,YAAY;AAChC,YAAM,SAAS,QAAQ,KAAA,EAAO,OAAO;AACrC,UAAI,WAAW,OAAW;AAC1B,cAAQ,OAAO,MAAM;AAAA,IACvB;AAAA,EACF;AACA,QAAM,QAAQ,CAAC,aAA+E;AAC5F,UAAM,QAAQ,QAAQ,IAAI,QAAQ;AAClC,QAAI,CAAC,MAAO,QAAO;AACnB,QAAI,IAAA,IAAQ,MAAM,KAAK,UAAU;AAC/B,cAAQ,OAAO,QAAQ;AACvB,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AACA,SAAO;AAAA,IACL,SAAS,UAAU,OAAO;AACxB,YAAM,KAAK,IAAA;AACX,cAAQ,OAAO,QAAQ;AACvB,cAAQ,IAAI,UAAU,EAAE,OAAO,IAAI;AACnC,YAAA;AACA,aAAO,EAAE,MAAM,YAAY,UAAU,OAAO,IAAI;AAAA,IAClD;AAAA,IACA,KAAK,UAAU;;AACb,cAAO,WAAM,QAAQ,MAAd,mBAAiB;AAAA,IAC1B;AAAA,IACA,KAAK,UAAU;AACb,aAAO,MAAM,QAAQ,MAAM;AAAA,IAC7B;AAAA,IACA,QAAQ,UAAU,OAAO,IAAI;AAC3B,UAAI,IAAA,IAAQ,KAAK,SAAU;AAC3B,YAAM,WAAW,QAAQ,IAAI,QAAQ;AACrC,UAAI,YAAY,SAAS,MAAM,GAAI;AACnC,cAAQ,OAAO,QAAQ;AACvB,cAAQ,IAAI,UAAU,EAAE,OAAO,IAAI;AACnC,YAAA;AAAA,IACF;AAAA,IACA,OAAO,UAAU;AACf,cAAQ,OAAO,QAAQ;AACvB,aAAO,EAAE,MAAM,UAAU,SAAA,CAAU;AAAA,IACrC;AAAA,IACA,QAAQ;AACN,cAAQ,MAAA;AACR,aAAO,EAAE,MAAM,SAAS;AAAA,IAC1B;AAAA,EAAA;AAEJ;AAqBO,SAAS,qBAAqB,OAAqD;AACxF,QAAM;AAAA,IACJ,eAAe;AAAA,IACf,eAAe;AAAA,IACf,oBAAoB;AAAA,IACpB,GAAG;AAAA,EAAA,IACD;AACJ,SAAO,EAAE,GAAG,MAAM,MAAM,aAAa,MAAM,IAAI,EAAA;AACjD;AAiBA,SAAS,aACP,MAC4C;AAC5C,QAAM,OAAO,6BAAO;AACpB,MAAI,SAAS,UAAa,KAAK,WAAW,kBAAkB,CAAA;AAC5D,SAAO;AAAA,IACL;AAAA,MACE,OAAO,KAAK;AAAA,MACZ,QAAQ;AAAA,MACR,OAAO,KAAK;AAAA,MACZ,YAAY,KAAK;AAAA,MACjB,GAAI,KAAK,UAAU,UAAa,EAAE,OAAO,KAAK,MAAA;AAAA,IAAM;AAAA,EACtD;AAEJ;;;"}
+{"version":3,"file":"thread-snapshot-cache.cjs","sources":["../../../../agent-runtime/src/thread-snapshot-cache.ts"],"sourcesContent":["import { withSeedProtocolLane } from './protocol';\nimport type { DeepAgentStreamValues } from './types';\n\n/**\n * Per-tab LRU of the last wire state seen per thread, so a switch back to a\n * recently-visited thread can mount with that snapshot instead of an empty\n * \"loading\" state (see `UseDeepAgentThreadOptions.snapshotCache`). Entries are\n * references into states the wire already produced — remembering is O(1) and\n * copies nothing; the bound is `maxThreads` retained states.\n */\nexport interface DeepAgentThreadSnapshotCache {\n  /** Record the latest hydrated wire state for a thread. */\n  remember(threadId: string, state: DeepAgentStreamValues): void;\n  /** The freshest remembered state for a thread, or `undefined` when none is\n   * held or the entry aged out. */\n  take(threadId: string): DeepAgentStreamValues | undefined;\n  /**\n   * Drop a single thread's entry. Called when the server refuses\n   * authorization for the thread — a refused thread must not warm-paint on\n   * its next mount.\n   */\n  forget(threadId: string): void;\n  /**\n   * Drop every entry. Called when the acting identity changes — a snapshot\n   * captured under one account must never seed a mount under another.\n   */\n  clear(): void;\n  /**\n   * Whether a fresh entry is held for the thread, without consuming or\n   * touching it. Hosts read it at selection time to decide whether the switch\n   * can paint from a seed (no loading treatment) or must cover the attach\n   * wait. Optional so hand-rolled caches keep type-checking; the built-in\n   * cache implements it.\n   */\n  peek?(threadId: string): boolean;\n}\n\n/** A write observed on the cache — the durable-mirror seam (see `onChange`). */\nexport type DeepAgentThreadSnapshotCacheChange =\n  | { type: 'remember'; threadId: string; state: DeepAgentStreamValues; at: number }\n  | { type: 'forget'; threadId: string }\n  | { type: 'clear' };\n\nexport interface DeepAgentThreadSnapshotCacheOptions {\n  /** Threads retained; the least-recently written entry evicts beyond this. */\n  maxThreads?: number;\n  /**\n   * Entries older than this are dropped at read time. The seed's value is\n   * \"the thread you just left\" — a snapshot from long ago is more likely to\n   * flash content the server has since rewritten than to save a paint.\n   */\n  maxAgeMs?: number;\n  /**\n   * Observer of every write (`remember`, `forget`, `clear`). Hosts mirror\n   * entries into durable storage from here so a reload can seed too; the\n   * observer is never invoked for `restore`, which re-admits mirrored entries.\n   * Exceptions are swallowed — a mirror fault must not break the wire path.\n   */\n  onChange?: (change: DeepAgentThreadSnapshotCacheChange) => void;\n  /** Injectable clock (tests). */\n  now?: () => number;\n}\n\n/** The built-in cache: the host contract plus the durable-mirror re-admission. */\nexport interface CreatedDeepAgentThreadSnapshotCache extends DeepAgentThreadSnapshotCache {\n  peek(threadId: string): boolean;\n  /**\n   * Re-admit an entry captured earlier — a mirrored snapshot after a reload —\n   * under its ORIGINAL capture time, so the age bound still applies. Never\n   * displaces a fresher in-memory entry and never notifies `onChange`.\n   */\n  restore(threadId: string, state: DeepAgentStreamValues, at: number): void;\n}\n\nconst DEFAULT_MAX_THREADS = 30;\nconst DEFAULT_MAX_AGE_MS = 60 * 60 * 1000;\n\nexport function createDeepAgentThreadSnapshotCache(\n  options: DeepAgentThreadSnapshotCacheOptions = {}\n): CreatedDeepAgentThreadSnapshotCache {\n  const maxThreads = options.maxThreads ?? DEFAULT_MAX_THREADS;\n  const maxAgeMs = options.maxAgeMs ?? DEFAULT_MAX_AGE_MS;\n  const now = options.now ?? (() => Date.now());\n  const notify = (change: DeepAgentThreadSnapshotCacheChange): void => {\n    try {\n      options.onChange?.(change);\n    } catch {\n      // The mirror is best-effort; the in-memory cache stays authoritative.\n    }\n  };\n  // Map iteration order is insertion order; delete-then-set on every write\n  // keeps the first key the least-recently written.\n  const entries = new Map<string, { state: DeepAgentStreamValues; at: number }>();\n  const evict = (): void => {\n    while (entries.size > maxThreads) {\n      const oldest = entries.keys().next().value;\n      if (oldest === undefined) break;\n      entries.delete(oldest);\n    }\n  };\n  const fresh = (threadId: string): { state: DeepAgentStreamValues; at: number } | undefined => {\n    const entry = entries.get(threadId);\n    if (!entry) return undefined;\n    if (now() - entry.at > maxAgeMs) {\n      entries.delete(threadId);\n      return undefined;\n    }\n    return entry;\n  };\n  return {\n    remember(threadId, state) {\n      const at = now();\n      entries.delete(threadId);\n      entries.set(threadId, { state, at });\n      evict();\n      notify({ type: 'remember', threadId, state, at });\n    },\n    take(threadId) {\n      return fresh(threadId)?.state;\n    },\n    peek(threadId) {\n      return fresh(threadId) !== undefined;\n    },\n    restore(threadId, state, at) {\n      if (now() - at > maxAgeMs) return;\n      const existing = entries.get(threadId);\n      if (existing && existing.at >= at) return;\n      entries.delete(threadId);\n      entries.set(threadId, { state, at });\n      evict();\n    },\n    forget(threadId) {\n      entries.delete(threadId);\n      notify({ type: 'forget', threadId });\n    },\n    clear() {\n      entries.clear();\n      notify({ type: 'clear' });\n    },\n  };\n}\n\n/**\n * Shape a remembered wire state for use as a mount's `initialState`.\n *\n * Messages/todos and the other app-owned keys seed as captured. The run lane\n * seeds by what the user left: a thread whose run was `running` when the\n * snapshot was taken seeds a running entry (see {@link seedRunsLane}) so the\n * switch back reads Running with a Stop control on its first frame — the same\n * frame `runs: []` would render as \"ready\" with a Send button over a thread the\n * server is still mid-run on. Every other live-lifecycle lane normalizes to\n * resting: a seeded input request could collect a decision the server may have\n * already resolved, so an `input-required` entry seeds as no run at all.\n * `__interrupt__` is dropped for the same reason, and so are `ptc_subagents`\n * (the live in-eval dispatch lane — a seeded \"running\" dispatch card under a\n * resting thread would render active with no eval behind it) and\n * `outOfBandRunActive` (the host's out-of-band-run-in-progress flag — seeding a\n * finished run's `true` would hide the composer until the attach corrected\n * it). Durable thread properties (`runConfig`, `config`, `sessionPersisted`, …)\n * seed as captured; the attach snapshot then replaces the whole seed. The\n * protocol lane seeds as a seed's own copy (`withSeedProtocolLane`), so\n * `isDeepAgentHostState` never reads the seed, or a state folded over it, as\n * what the host holds now.\n */\nexport function toThreadSnapshotSeed(state: DeepAgentStreamValues): DeepAgentStreamValues {\n  const {\n    __interrupt__: _interrupt,\n    ptc_subagents: _ptcSubagents,\n    outOfBandRunActive: _outOfBandRunActive,\n    ...rest\n  } = state;\n  return withSeedProtocolLane({ ...rest, runs: seedRunsLane(state.runs) });\n}\n\n/**\n * The run entries a seed carries.\n *\n * Only a `running` entry survives, and only its replicated identity and its\n * durable lanes: `runId` (the target of a Stop sent during the attach\n * round-trip — the live run's id if it is still running, and a refused stop\n * if it finished meanwhile), `epoch` (rides that Stop so a replayed stop cannot\n * end a later leg) and the `queue`/`steerQueue` entries (server lanes the tray\n * renders). The in-flight records rest until the snapshot: `dispatching` and\n * `nextDispatch` are batches the materializer would re-apply onto messages\n * that already contain them, `stopping` is a rewind the host may have\n * finished, `inputRequests` is a parked decision, and `error` is a failure the\n * next user run clears. An entry in any other status — `stopped`, `error`,\n * `input-required` — seeds as no run.\n */\nfunction seedRunsLane(\n  runs: DeepAgentStreamValues['runs']\n): NonNullable<DeepAgentStreamValues['runs']> {\n  const live = runs?.[0];\n  if (live === undefined || live.status !== 'running') return [];\n  return [\n    {\n      runId: live.runId,\n      status: 'running',\n      queue: live.queue,\n      steerQueue: live.steerQueue,\n      ...(live.epoch !== undefined && { epoch: live.epoch }),\n    },\n  ];\n}\n"],"names":["withSeedProtocolLane"],"mappings":";;;AA0EA,MAAM,sBAAsB;AAC5B,MAAM,qBAAqB,KAAK,KAAK;AAE9B,SAAS,mCACd,UAA+C,IACV;AACrC,QAAM,aAAa,QAAQ,cAAc;AACzC,QAAM,WAAW,QAAQ,YAAY;AACrC,QAAM,MAAM,QAAQ,QAAQ,MAAM,KAAK,IAAA;AACvC,QAAM,SAAS,CAAC,WAAqD;;AACnE,QAAI;AACF,oBAAQ,aAAR,iCAAmB;AAAA,IACrB,QAAQ;AAAA,IAER;AAAA,EACF;AAGA,QAAM,8BAAc,IAAA;AACpB,QAAM,QAAQ,MAAY;AACxB,WAAO,QAAQ,OAAO,YAAY;AAChC,YAAM,SAAS,QAAQ,KAAA,EAAO,OAAO;AACrC,UAAI,WAAW,OAAW;AAC1B,cAAQ,OAAO,MAAM;AAAA,IACvB;AAAA,EACF;AACA,QAAM,QAAQ,CAAC,aAA+E;AAC5F,UAAM,QAAQ,QAAQ,IAAI,QAAQ;AAClC,QAAI,CAAC,MAAO,QAAO;AACnB,QAAI,IAAA,IAAQ,MAAM,KAAK,UAAU;AAC/B,cAAQ,OAAO,QAAQ;AACvB,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AACA,SAAO;AAAA,IACL,SAAS,UAAU,OAAO;AACxB,YAAM,KAAK,IAAA;AACX,cAAQ,OAAO,QAAQ;AACvB,cAAQ,IAAI,UAAU,EAAE,OAAO,IAAI;AACnC,YAAA;AACA,aAAO,EAAE,MAAM,YAAY,UAAU,OAAO,IAAI;AAAA,IAClD;AAAA,IACA,KAAK,UAAU;;AACb,cAAO,WAAM,QAAQ,MAAd,mBAAiB;AAAA,IAC1B;AAAA,IACA,KAAK,UAAU;AACb,aAAO,MAAM,QAAQ,MAAM;AAAA,IAC7B;AAAA,IACA,QAAQ,UAAU,OAAO,IAAI;AAC3B,UAAI,IAAA,IAAQ,KAAK,SAAU;AAC3B,YAAM,WAAW,QAAQ,IAAI,QAAQ;AACrC,UAAI,YAAY,SAAS,MAAM,GAAI;AACnC,cAAQ,OAAO,QAAQ;AACvB,cAAQ,IAAI,UAAU,EAAE,OAAO,IAAI;AACnC,YAAA;AAAA,IACF;AAAA,IACA,OAAO,UAAU;AACf,cAAQ,OAAO,QAAQ;AACvB,aAAO,EAAE,MAAM,UAAU,SAAA,CAAU;AAAA,IACrC;AAAA,IACA,QAAQ;AACN,cAAQ,MAAA;AACR,aAAO,EAAE,MAAM,SAAS;AAAA,IAC1B;AAAA,EAAA;AAEJ;AAwBO,SAAS,qBAAqB,OAAqD;AACxF,QAAM;AAAA,IACJ,eAAe;AAAA,IACf,eAAe;AAAA,IACf,oBAAoB;AAAA,IACpB,GAAG;AAAA,EAAA,IACD;AACJ,SAAOA,SAAAA,qBAAqB,EAAE,GAAG,MAAM,MAAM,aAAa,MAAM,IAAI,GAAG;AACzE;AAiBA,SAAS,aACP,MAC4C;AAC5C,QAAM,OAAO,6BAAO;AACpB,MAAI,SAAS,UAAa,KAAK,WAAW,kBAAkB,CAAA;AAC5D,SAAO;AAAA,IACL;AAAA,MACE,OAAO,KAAK;AAAA,MACZ,QAAQ;AAAA,MACR,OAAO,KAAK;AAAA,MACZ,YAAY,KAAK;AAAA,MACjB,GAAI,KAAK,UAAU,UAAa,EAAE,OAAO,KAAK,MAAA;AAAA,IAAM;AAAA,EACtD;AAEJ;;;"}

package/dist/agent-runtime/src/thread-snapshot-cache.js

@@ -1,3 +1,4 @@
+import { withSeedProtocolLane } from "./protocol.js";
 const DEFAULT_MAX_THREADS = 30;
 const DEFAULT_MAX_AGE_MS = 60 * 60 * 1e3;
 function createDeepAgentThreadSnapshotCache(options = {}) {
@@ -68,7 +69,7 @@ function toThreadSnapshotSeed(state) {
     outOfBandRunActive: _outOfBandRunActive,
     ...rest
   } = state;
-  return { ...rest, runs: seedRunsLane(state.runs) };
+  return withSeedProtocolLane({ ...rest, runs: seedRunsLane(state.runs) });
 }
 function seedRunsLane(runs) {
   const live = runs == null ? void 0 : runs[0];