@athenaintel/react 0.41.1 → 0.41.2

package/README.md

@@ -807,6 +807,12 @@ 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.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/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];

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

@@ -1 +1 @@
-{"version":3,"file":"thread-snapshot-cache.js","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;AATvE;AAUI,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;AA3CnB;AA4CM,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.js","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":[],"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,SAAO,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/react/package.json.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const version = "0.41.1";
+const version = "0.41.2";
 const packageJson = {
   version
 };

package/dist/react/package.json.js

@@ -1,4 +1,4 @@
-const version = "0.41.1";
+const version = "0.41.2";
 const packageJson = {
   version
 };

package/dist/runtime/useAthenaStatewireRuntime.cjs

@@ -11,7 +11,7 @@ const statewireRunConfig = require("./statewire-run-config.cjs");
 const runconfigContract = require("../agent-runtime/src/generated/runconfig-contract.cjs");
 const useDeepAgentRuntime = require("../agent-runtime/src/use-deep-agent-runtime.cjs");
 const errors = require("../agent-runtime/src/errors.cjs");
-const statewireState = require("../agent-runtime/src/statewire-state.cjs");
+const protocol = require("../agent-runtime/src/protocol.cjs");
 const composerMarkdown = require("../agent-runtime/src/composer-markdown.cjs");
 const ATHENA_SDK_MESSAGE_WINDOW = {
   size: runconfigContract.DEEP_AGENT_DEFAULT_MESSAGE_WINDOW
@@ -83,8 +83,6 @@ function useAthenaStatewireRuntime(config) {
     clientTools: statewireClientTools.statewireClientToolWireEntries(clientTools)
   });
   const runConfigKey = JSON.stringify(runConfigValue);
-  const lastStateRef = react.useRef(null);
-  const helloLandedRef = react.useRef(false);
   const auiTools = react.useMemo(() => react$1.Tools({ toolkit: frontendToolkit }), [frontendToolkit]);
   const useSdkClient = (thread) => react$1.useAui({ thread, tools: auiTools });
   return useDeepAgentRuntime.useDeepAgentRuntime({
@@ -123,14 +121,13 @@ function useAthenaStatewireRuntime(config) {
     getMessageMetadata: composerMarkdown.withStagedComposerMarkdown({ threadId }),
     useClient: useSdkClient,
     onStateChange: (state) => {
+      if (!protocol.isDeepAgentHostState(state)) return;
       const endSpan = attachSpanRef.current;
       if (endSpan) {
         attachSpanRef.current = null;
         endSpan("statewire.snapshot", { data: { thread_id: threadId } });
       }
-      if (!statewireState.isDeepAgentStateHydrated(state)) return;
-      lastStateRef.current = state;
-      if (helloLandedRef.current) onServerState == null ? void 0 : onServerState(state);
+      onServerState == null ? void 0 : onServerState(state);
     },
     onConnectionChange: (connection) => {
       athenaDiagnostics.athenaDiagnostics.gauge("statewire.connection", (connection == null ? void 0 : connection.status) ?? null);
@@ -146,14 +143,7 @@ function useAthenaStatewireRuntime(config) {
       }
       onConnectionChange == null ? void 0 : onConnectionChange(connection);
     },
-    onRawConnectionChange: (connection) => {
-      if (connection.status === "connected" && !helloLandedRef.current) {
-        helloLandedRef.current = true;
-        const helloState = lastStateRef.current;
-        if (helloState) onServerState == null ? void 0 : onServerState(helloState);
-      }
-      onRawConnectionChange == null ? void 0 : onRawConnectionChange(connection);
-    },
+    onRawConnectionChange,
     onRunningChange,
     // Each model-context notification pulls the latest getter through the
     // core's per-render ref; the value-stable key re-registers (and so

package/dist/runtime/useAthenaStatewireRuntime.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useAthenaStatewireRuntime.cjs","sources":["../../src/runtime/useAthenaStatewireRuntime.ts"],"sourcesContent":["import type { AssistantClient, Toolkit } from '@assistant-ui/react';\nimport { Tools, useAui } from '@assistant-ui/react';\nimport {\n  DEEP_AGENT_DEFAULT_MESSAGE_WINDOW,\n  type DeepAgentMessageWindowDeclaration,\n  type DeepAgentStreamValues,\n  type DeepAgentThreadElement,\n  type DeepAgentThreadSnapshotCache,\n  type DeepAgentToolOutputStore,\n  isDeepAgentStateHydrated,\n  isStatewireChannelTeardown,\n  logUnhandledStatewireError,\n  type RegisteredClientTool,\n  useDeepAgentRuntime,\n  type UseDeepAgentThreadOptions,\n  withStagedComposerMarkdown,\n} from '@athenaintel/agent-runtime';\nimport { useContext, useMemo, useRef } from 'react';\nimport { AthenaAuthContext } from '../auth/AthenaAuthContext';\nimport {\n  collectStatewireClientTools,\n  statewireClientToolWireEntries,\n} from '../chat/statewire-client-tools';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport {\n  type AthenaStatewireTokenGetter,\n  resolveStatewireAuthHeaders,\n} from './statewire-auth-headers';\nimport { statewireSessionKey } from './statewire-session-key';\n\ntype AthenaDiagnosticsSpanStarter = typeof athenaDiagnostics.span;\nimport {\n  buildStatewireRunConfig,\n  DEFAULT_STATEWIRE_MODEL,\n  resolveAgentProp,\n} from './statewire-run-config';\n\nexport { DEFAULT_STATEWIRE_MODEL };\n\n/**\n * The head interest every SDK attach states (`athena/interest`): the host\n * mounts the transcript's tail as message documents instead of every message\n * — megabytes on long threads, over the 1 MiB frame limit of stock websocket\n * clients. Older pages load from the `StatewireHistoryEdge` row the chat UI\n * mounts above the messages, and cut tool outputs are fetched back for the\n * cards that show them.\n */\nexport const ATHENA_SDK_MESSAGE_WINDOW: DeepAgentMessageWindowDeclaration = {\n  size: DEEP_AGENT_DEFAULT_MESSAGE_WINDOW,\n};\n\nexport interface AthenaStatewireRuntimeConfig {\n  /** Base URL of the statewire sync host (the `…/v2/threads` mount). */\n  syncUrl: string;\n  /** Thread ID the statewire session attaches to. */\n  threadId: string;\n  /** True only for a never-started local chat. Existing (or pre-assigned)\n   *  threads load until their server snapshot arrives. */\n  isNewChat?: boolean;\n  /** API key for authentication. Used when no auth token is provided. */\n  apiKey?: string;\n  /** Auth token. Takes priority over apiKey. */\n  token?: string | null;\n  /** Resolve the latest token immediately before a request (for expiring\n   *  clients). Called with `{ force: true }` right after the host refused the\n   *  previous credential (the transport's `staleAuth`), so a caching getter\n   *  mints a fresh token instead of returning the refused one. */\n  getToken?: AthenaStatewireTokenGetter;\n  /**\n   * Per-provider LRU of each thread's last wire state. A switch back to a\n   * remembered thread mounts with that snapshot and projects ready on the\n   * first frame instead of a loading treatment; the attach snapshot then\n   * replaces it. Owned above the per-thread mount so it survives switches.\n   */\n  snapshotCache?: DeepAgentThreadSnapshotCache;\n  /** The head interest stated on the attach (see {@link ATHENA_SDK_MESSAGE_WINDOW}, the default). */\n  messageWindow?: DeepAgentMessageWindowDeclaration;\n  /**\n   * Full tool outputs fetched back for a windowed wire's cut tool messages;\n   * the thread re-converts when one lands. `AthenaProvider` owns one per\n   * provider and hands the same store to `StatewireHistoryEdge`.\n   */\n  toolOutputs?: DeepAgentToolOutputStore;\n  /** LLM model identifier. Defaults to the deep-agent default model. */\n  model?: string;\n  /** Agent selector: only `collab_agent:<asset_id>` refs are accepted (the run\n   *  executes AS that published collab agent). Any other non-empty value\n   *  throws — see `resolveAgentProp`. */\n  agent?: string;\n  /** Collab-agent channel id selecting that channel's overrides. */\n  channel?: string;\n  /** The agent's mode picked for this thread (`AthenaProvider` `modes`). */\n  mode?: string;\n  /** Backend toolkit IDs to enable. */\n  tools?: string[];\n  /** Frontend tool IDs to include in enabled_tools. */\n  frontendToolIds?: string[];\n  /** Frontend tools registered on the assistant client. Tools with a local\n   *  `execute` are also declared as `client_tools` and executed through the\n   *  statewire client-tool bridge. */\n  frontendToolkit?: Toolkit;\n  /** Asset IDs to include in the workbench. */\n  workbench?: string[];\n  /** Knowledge base IDs for RAG context. */\n  knowledgeBase?: string[];\n  /** System prompt override. */\n  systemPrompt?: string;\n  /** Client app identifier for session filtering. Sent as app_id in runConfig.custom. */\n  appId?: string;\n  /** Additional fields merged into runConfig.custom. */\n  extraRunConfig?: Record<string, unknown>;\n  /** Called on statewire transport errors (send rejections, stream failures). */\n  onError?: (error: Error) => void;\n  /** Projected connection status changes (deduped; null on unmount). */\n  onConnectionChange?: UseDeepAgentThreadOptions['onConnectionChange'];\n  /** Raw connection observer — carries the transport's reconnect handle. */\n  onRawConnectionChange?: UseDeepAgentThreadOptions['onRawConnectionChange'];\n  /** Notified when a run starts/stops. */\n  onRunningChange?: UseDeepAgentThreadOptions['onRunningChange'];\n  /**\n   * Observes the host's own state: called once the attach's hello has landed\n   * (with the snapshot it carried) and then on every later frame — never with\n   * the placeholder or remembered snapshot a thread renders before its hello.\n   * Called per streamed token, so keep it cheap.\n   */\n  onServerState?: (state: DeepAgentStreamValues) => void;\n}\n\nconst EMPTY_TOOLKIT: Toolkit = {};\nconst EMPTY_TOOL_IDS: string[] = [];\n\n/** The client tools derived from the runtime's frontend toolkit — exposed so\n *  the provider can mount the client-tool bridge with the same set. */\nexport function useStatewireClientTools(\n  frontendToolkit: Toolkit | undefined,\n): RegisteredClientTool[] {\n  return useMemo(\n    () => collectStatewireClientTools(frontendToolkit ?? EMPTY_TOOLKIT),\n    [frontendToolkit],\n  );\n}\n\n/**\n * Statewire runtime for the Athena SDK — a thin shim over the shared\n * `@athenaintel/agent-runtime` `useDeepAgentRuntime`: it attaches to the\n * agora-hosted deep-agent thread at `${syncUrl}/${threadId}` and returns the\n * `AssistantClient` to mount via `AuiProvider` — the same integration shape as\n * the Olympus, Chrome extension, Office, and mobile statewire hosts.\n *\n * Auth: a token (resolved live through `getToken` when provided) rides\n * `Authorization: Bearer`, and an API key falls back to `X-API-KEY` — both\n * accepted by the statewire host.\n */\nexport function useAthenaStatewireRuntime(\n  config: AthenaStatewireRuntimeConfig,\n): AssistantClient {\n  const {\n    syncUrl,\n    threadId,\n    isNewChat = false,\n    apiKey,\n    token,\n    getToken,\n    model,\n    agent,\n    channel,\n    mode,\n    tools = EMPTY_TOOL_IDS,\n    frontendToolIds = EMPTY_TOOL_IDS,\n    frontendToolkit = EMPTY_TOOLKIT,\n    workbench,\n    knowledgeBase,\n    systemPrompt,\n    appId,\n    extraRunConfig,\n    snapshotCache,\n    messageWindow = ATHENA_SDK_MESSAGE_WINDOW,\n    toolOutputs,\n    onError,\n    onConnectionChange,\n    onRawConnectionChange,\n    onRunningChange,\n    onServerState,\n  } = config;\n\n  // Fail loud at mount, not at first send: the statewire host always runs the\n  // Athena deep agent, so an `agent` outside the collab_agent namespace can\n  // never apply. Throwing here (render time) is what makes a misconfigured\n  // integration visible instead of quietly answering as the wrong agent.\n  resolveAgentProp({ agent });\n\n  const clientTools = useStatewireClientTools(frontendToolkit);\n\n  // The persisted command lane is keyed by WHO is signed in as well as by host\n  // and thread (see `statewireSessionKey`).\n  const authContext = useContext(AthenaAuthContext);\n  const principal = authContext?.user?.userId ?? '';\n\n  // Attach → first server snapshot span, keyed per thread attach.\n  const attachSpanRef = useRef<ReturnType<AthenaDiagnosticsSpanStarter> | null>(null);\n  const attachThreadRef = useRef<string | null>(null);\n  if (attachThreadRef.current !== threadId) {\n    attachThreadRef.current = threadId;\n    attachSpanRef.current = athenaDiagnostics.span(\n      `statewire.attach:${threadId}`,\n      'statewire.attach.start',\n      { thread_id: threadId, is_new_chat: isNewChat },\n    );\n  }\n\n  // Built every render so its JSON signature can key the model-context\n  // registration below: consumers commonly pass fresh array literals per\n  // render, which must not thrash registration, while a changed value (a new\n  // `model`, channel, tool list, system prompt, …) must re-sync the context\n  // before the next send. The core pulls this value only on model-context\n  // notifications, which a key change triggers.\n  const runConfigValue = buildStatewireRunConfig({\n    model,\n    agent,\n    channel,\n    mode,\n    tools,\n    frontendToolIds,\n    workbench,\n    knowledgeBase,\n    systemPrompt,\n    appId,\n    extraRunConfig,\n    clientTools: statewireClientToolWireEntries(clientTools),\n  });\n  const runConfigKey = JSON.stringify(runConfigValue);\n\n  // The host's state, told apart from what the thread renders before its\n  // hello: statewire publishes the initial (placeholder or remembered) state\n  // through `onStateChange` too, and reports `connected` in the same flush\n  // right after publishing the state the hello carried. So the latest state\n  // seen when the connection first turns `connected` is the hello's, and every\n  // state after it is the host's. Refs are per attach: the runtime is mounted\n  // per thread.\n  const lastStateRef = useRef<DeepAgentStreamValues | null>(null);\n  const helloLandedRef = useRef(false);\n\n  const auiTools = useMemo(() => Tools({ toolkit: frontendToolkit }), [frontendToolkit]);\n  // Web client for the shared runtime core (a `use*` name so the\n  // rules-of-hooks lint sees the `useAui` call inside a custom hook; the core\n  // invokes it unconditionally every render).\n  const useSdkClient = (thread: DeepAgentThreadElement) => useAui({ thread, tools: auiTools });\n\n  return useDeepAgentRuntime({\n    surface: 'AthenaSDK',\n    threadId,\n    baseUrl: syncUrl,\n    // Option closures are re-read per render by the core, so credential\n    // rotation (new `token`/`getToken`/`apiKey` props) reaches the next\n    // request without remounting the thread. The transport's `staleAuth`\n    // (true right after a refused credential) is forwarded as `force`.\n    headers: (ctx) => resolveStatewireAuthHeaders({ apiKey, token, getToken }, ctx),\n    isNewChat,\n    // Queued entries render in the SDK's queue panel, so only the steer lane\n    // projects into the message tail.\n    laneProjection: 'steer-only',\n    // Durable session: a reload resumes the lane and resends whatever the\n    // server has not marked durable. Scoped by host AND principal — a thread\n    // id is only meaningful against the backend that minted it, and a stored\n    // lane must never resend against another signed-in user. (Consumers\n    // server-render this SDK; the core's availability probe keeps those\n    // sessions process-local, as before the seam existed.)\n    session: {\n      kind: 'local-storage',\n      key: (id) => statewireSessionKey({ syncUrl, principal, threadId: id }),\n    },\n    snapshotCache,\n    // Head interest (see `ATHENA_SDK_MESSAGE_WINDOW`): the tail of the\n    // transcript instead of every message; the chat UI's history edge pages\n    // older ranges in and fetches cut tool outputs into `toolOutputs`.\n    messageWindow,\n    toolOutputs,\n    capabilities: { edit: true, reload: true, continue: true },\n    // The composer stages the draft each send came from right before it\n    // sends; the message carries it as its composer markdown, so its bubble\n    // shows the text exactly as typed (`UserMessageText`).\n    getMessageMetadata: withStagedComposerMarkdown({ threadId }),\n    useClient: useSdkClient,\n    onStateChange: (state) => {\n      // First snapshot for this attach ends the attach span (time-to-history).\n      const endSpan = attachSpanRef.current;\n      if (endSpan) {\n        attachSpanRef.current = null;\n        endSpan('statewire.snapshot', { data: { thread_id: threadId } });\n      }\n      // A replay boundary republishes the pre-stream default: not host state.\n      if (!isDeepAgentStateHydrated(state)) return;\n      lastStateRef.current = state;\n      if (helloLandedRef.current) onServerState?.(state);\n    },\n    onConnectionChange: (connection) => {\n      athenaDiagnostics.gauge('statewire.connection', connection?.status ?? null);\n      if (connection?.status === 'stopped') {\n        athenaDiagnostics.emit('statewire.connection', {\n          level: 'warn',\n          data: {\n            status: connection.status,\n            reason: connection.reason,\n            message: connection.message,\n          },\n        });\n      }\n      onConnectionChange?.(connection);\n    },\n    onRawConnectionChange: (connection) => {\n      if (connection.status === 'connected' && !helloLandedRef.current) {\n        helloLandedRef.current = true;\n        const helloState = lastStateRef.current;\n        if (helloState) onServerState?.(helloState);\n      }\n      onRawConnectionChange?.(connection);\n    },\n    onRunningChange,\n    // Each model-context notification pulls the latest getter through the\n    // core's per-render ref; the value-stable key re-registers (and so\n    // notifies) only when the built runConfig actually changed. On a thread\n    // with a server config lane, agora keeps only the per-send keys of what\n    // this carries; `StatewireThreadConfigLaneSync` writes a changed model,\n    // system prompt, tool list, workbench or knowledge base to the lane itself.\n    runConfig: {\n      get: () => runConfigValue,\n      key: runConfigKey,\n    },\n    onError: (error) => {\n      if (!isStatewireChannelTeardown(error)) {\n        athenaDiagnostics.error(\n          'statewire.error',\n          error,\n          {\n            code: 'statewire_rejected',\n            message: 'The statewire host rejected a command',\n            hint: 'Inspect error.detail — agora rejections carry a structured {code, message}.',\n          },\n          { thread_id: threadId },\n        );\n      }\n      if (onError) {\n        onError(error);\n        return;\n      }\n      logUnhandledStatewireError('AthenaSDK', error);\n    },\n  });\n}\n"],"names":["DEEP_AGENT_DEFAULT_MESSAGE_WINDOW","useMemo","collectStatewireClientTools","resolveAgentProp","useContext","AthenaAuthContext","useRef","athenaDiagnostics","buildStatewireRunConfig","statewireClientToolWireEntries","Tools","useAui","useDeepAgentRuntime","resolveStatewireAuthHeaders","statewireSessionKey","withStagedComposerMarkdown","isDeepAgentStateHydrated","isStatewireChannelTeardown","logUnhandledStatewireError"],"mappings":"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"}
+{"version":3,"file":"useAthenaStatewireRuntime.cjs","sources":["../../src/runtime/useAthenaStatewireRuntime.ts"],"sourcesContent":["import type { AssistantClient, Toolkit } from '@assistant-ui/react';\nimport { Tools, useAui } from '@assistant-ui/react';\nimport {\n  DEEP_AGENT_DEFAULT_MESSAGE_WINDOW,\n  type DeepAgentMessageWindowDeclaration,\n  type DeepAgentStreamValues,\n  type DeepAgentThreadElement,\n  type DeepAgentThreadSnapshotCache,\n  type DeepAgentToolOutputStore,\n  isDeepAgentHostState,\n  isStatewireChannelTeardown,\n  logUnhandledStatewireError,\n  type RegisteredClientTool,\n  useDeepAgentRuntime,\n  type UseDeepAgentThreadOptions,\n  withStagedComposerMarkdown,\n} from '@athenaintel/agent-runtime';\nimport { useContext, useMemo, useRef } from 'react';\nimport { AthenaAuthContext } from '../auth/AthenaAuthContext';\nimport {\n  collectStatewireClientTools,\n  statewireClientToolWireEntries,\n} from '../chat/statewire-client-tools';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport {\n  type AthenaStatewireTokenGetter,\n  resolveStatewireAuthHeaders,\n} from './statewire-auth-headers';\nimport { statewireSessionKey } from './statewire-session-key';\n\ntype AthenaDiagnosticsSpanStarter = typeof athenaDiagnostics.span;\nimport {\n  buildStatewireRunConfig,\n  DEFAULT_STATEWIRE_MODEL,\n  resolveAgentProp,\n} from './statewire-run-config';\n\nexport { DEFAULT_STATEWIRE_MODEL };\n\n/**\n * The head interest every SDK attach states (`athena/interest`): the host\n * mounts the transcript's tail as message documents instead of every message\n * — megabytes on long threads, over the 1 MiB frame limit of stock websocket\n * clients. Older pages load from the `StatewireHistoryEdge` row the chat UI\n * mounts above the messages, and cut tool outputs are fetched back for the\n * cards that show them.\n */\nexport const ATHENA_SDK_MESSAGE_WINDOW: DeepAgentMessageWindowDeclaration = {\n  size: DEEP_AGENT_DEFAULT_MESSAGE_WINDOW,\n};\n\nexport interface AthenaStatewireRuntimeConfig {\n  /** Base URL of the statewire sync host (the `…/v2/threads` mount). */\n  syncUrl: string;\n  /** Thread ID the statewire session attaches to. */\n  threadId: string;\n  /** True only for a never-started local chat. Existing (or pre-assigned)\n   *  threads load until their server snapshot arrives. */\n  isNewChat?: boolean;\n  /** API key for authentication. Used when no auth token is provided. */\n  apiKey?: string;\n  /** Auth token. Takes priority over apiKey. */\n  token?: string | null;\n  /** Resolve the latest token immediately before a request (for expiring\n   *  clients). Called with `{ force: true }` right after the host refused the\n   *  previous credential (the transport's `staleAuth`), so a caching getter\n   *  mints a fresh token instead of returning the refused one. */\n  getToken?: AthenaStatewireTokenGetter;\n  /**\n   * Per-provider LRU of each thread's last wire state. A switch back to a\n   * remembered thread mounts with that snapshot and projects ready on the\n   * first frame instead of a loading treatment; the attach snapshot then\n   * replaces it. Owned above the per-thread mount so it survives switches.\n   */\n  snapshotCache?: DeepAgentThreadSnapshotCache;\n  /** The head interest stated on the attach (see {@link ATHENA_SDK_MESSAGE_WINDOW}, the default). */\n  messageWindow?: DeepAgentMessageWindowDeclaration;\n  /**\n   * Full tool outputs fetched back for a windowed wire's cut tool messages;\n   * the thread re-converts when one lands. `AthenaProvider` owns one per\n   * provider and hands the same store to `StatewireHistoryEdge`.\n   */\n  toolOutputs?: DeepAgentToolOutputStore;\n  /** LLM model identifier. Defaults to the deep-agent default model. */\n  model?: string;\n  /** Agent selector: only `collab_agent:<asset_id>` refs are accepted (the run\n   *  executes AS that published collab agent). Any other non-empty value\n   *  throws — see `resolveAgentProp`. */\n  agent?: string;\n  /** Collab-agent channel id selecting that channel's overrides. */\n  channel?: string;\n  /** The agent's mode picked for this thread (`AthenaProvider` `modes`). */\n  mode?: string;\n  /** Backend toolkit IDs to enable. */\n  tools?: string[];\n  /** Frontend tool IDs to include in enabled_tools. */\n  frontendToolIds?: string[];\n  /** Frontend tools registered on the assistant client. Tools with a local\n   *  `execute` are also declared as `client_tools` and executed through the\n   *  statewire client-tool bridge. */\n  frontendToolkit?: Toolkit;\n  /** Asset IDs to include in the workbench. */\n  workbench?: string[];\n  /** Knowledge base IDs for RAG context. */\n  knowledgeBase?: string[];\n  /** System prompt override. */\n  systemPrompt?: string;\n  /** Client app identifier for session filtering. Sent as app_id in runConfig.custom. */\n  appId?: string;\n  /** Additional fields merged into runConfig.custom. */\n  extraRunConfig?: Record<string, unknown>;\n  /** Called on statewire transport errors (send rejections, stream failures). */\n  onError?: (error: Error) => void;\n  /** Projected connection status changes (deduped; null on unmount). */\n  onConnectionChange?: UseDeepAgentThreadOptions['onConnectionChange'];\n  /** Raw connection observer — carries the transport's reconnect handle. */\n  onRawConnectionChange?: UseDeepAgentThreadOptions['onRawConnectionChange'];\n  /** Notified when a run starts/stops. */\n  onRunningChange?: UseDeepAgentThreadOptions['onRunningChange'];\n  /**\n   * Observes the host's own state: called with the attach snapshot and then on\n   * every later frame (`isDeepAgentHostState`) — never with the placeholder or\n   * remembered snapshot a thread renders before its snapshot applies, which\n   * can be after the connection reports `connected`. Called per streamed\n   * token, so keep it cheap.\n   */\n  onServerState?: (state: DeepAgentStreamValues) => void;\n}\n\nconst EMPTY_TOOLKIT: Toolkit = {};\nconst EMPTY_TOOL_IDS: string[] = [];\n\n/** The client tools derived from the runtime's frontend toolkit — exposed so\n *  the provider can mount the client-tool bridge with the same set. */\nexport function useStatewireClientTools(\n  frontendToolkit: Toolkit | undefined,\n): RegisteredClientTool[] {\n  return useMemo(\n    () => collectStatewireClientTools(frontendToolkit ?? EMPTY_TOOLKIT),\n    [frontendToolkit],\n  );\n}\n\n/**\n * Statewire runtime for the Athena SDK — a thin shim over the shared\n * `@athenaintel/agent-runtime` `useDeepAgentRuntime`: it attaches to the\n * agora-hosted deep-agent thread at `${syncUrl}/${threadId}` and returns the\n * `AssistantClient` to mount via `AuiProvider` — the same integration shape as\n * the Olympus, Chrome extension, Office, and mobile statewire hosts.\n *\n * Auth: a token (resolved live through `getToken` when provided) rides\n * `Authorization: Bearer`, and an API key falls back to `X-API-KEY` — both\n * accepted by the statewire host.\n */\nexport function useAthenaStatewireRuntime(\n  config: AthenaStatewireRuntimeConfig,\n): AssistantClient {\n  const {\n    syncUrl,\n    threadId,\n    isNewChat = false,\n    apiKey,\n    token,\n    getToken,\n    model,\n    agent,\n    channel,\n    mode,\n    tools = EMPTY_TOOL_IDS,\n    frontendToolIds = EMPTY_TOOL_IDS,\n    frontendToolkit = EMPTY_TOOLKIT,\n    workbench,\n    knowledgeBase,\n    systemPrompt,\n    appId,\n    extraRunConfig,\n    snapshotCache,\n    messageWindow = ATHENA_SDK_MESSAGE_WINDOW,\n    toolOutputs,\n    onError,\n    onConnectionChange,\n    onRawConnectionChange,\n    onRunningChange,\n    onServerState,\n  } = config;\n\n  // Fail loud at mount, not at first send: the statewire host always runs the\n  // Athena deep agent, so an `agent` outside the collab_agent namespace can\n  // never apply. Throwing here (render time) is what makes a misconfigured\n  // integration visible instead of quietly answering as the wrong agent.\n  resolveAgentProp({ agent });\n\n  const clientTools = useStatewireClientTools(frontendToolkit);\n\n  // The persisted command lane is keyed by WHO is signed in as well as by host\n  // and thread (see `statewireSessionKey`).\n  const authContext = useContext(AthenaAuthContext);\n  const principal = authContext?.user?.userId ?? '';\n\n  // Attach → first server snapshot span, keyed per thread attach.\n  const attachSpanRef = useRef<ReturnType<AthenaDiagnosticsSpanStarter> | null>(null);\n  const attachThreadRef = useRef<string | null>(null);\n  if (attachThreadRef.current !== threadId) {\n    attachThreadRef.current = threadId;\n    attachSpanRef.current = athenaDiagnostics.span(\n      `statewire.attach:${threadId}`,\n      'statewire.attach.start',\n      { thread_id: threadId, is_new_chat: isNewChat },\n    );\n  }\n\n  // Built every render so its JSON signature can key the model-context\n  // registration below: consumers commonly pass fresh array literals per\n  // render, which must not thrash registration, while a changed value (a new\n  // `model`, channel, tool list, system prompt, …) must re-sync the context\n  // before the next send. The core pulls this value only on model-context\n  // notifications, which a key change triggers.\n  const runConfigValue = buildStatewireRunConfig({\n    model,\n    agent,\n    channel,\n    mode,\n    tools,\n    frontendToolIds,\n    workbench,\n    knowledgeBase,\n    systemPrompt,\n    appId,\n    extraRunConfig,\n    clientTools: statewireClientToolWireEntries(clientTools),\n  });\n  const runConfigKey = JSON.stringify(runConfigValue);\n\n  const auiTools = useMemo(() => Tools({ toolkit: frontendToolkit }), [frontendToolkit]);\n  // Web client for the shared runtime core (a `use*` name so the\n  // rules-of-hooks lint sees the `useAui` call inside a custom hook; the core\n  // invokes it unconditionally every render).\n  const useSdkClient = (thread: DeepAgentThreadElement) => useAui({ thread, tools: auiTools });\n\n  return useDeepAgentRuntime({\n    surface: 'AthenaSDK',\n    threadId,\n    baseUrl: syncUrl,\n    // Option closures are re-read per render by the core, so credential\n    // rotation (new `token`/`getToken`/`apiKey` props) reaches the next\n    // request without remounting the thread. The transport's `staleAuth`\n    // (true right after a refused credential) is forwarded as `force`.\n    headers: (ctx) => resolveStatewireAuthHeaders({ apiKey, token, getToken }, ctx),\n    isNewChat,\n    // Queued entries render in the SDK's queue panel, so only the steer lane\n    // projects into the message tail.\n    laneProjection: 'steer-only',\n    // Durable session: a reload resumes the lane and resends whatever the\n    // server has not marked durable. Scoped by host AND principal — a thread\n    // id is only meaningful against the backend that minted it, and a stored\n    // lane must never resend against another signed-in user. (Consumers\n    // server-render this SDK; the core's availability probe keeps those\n    // sessions process-local, as before the seam existed.)\n    session: {\n      kind: 'local-storage',\n      key: (id) => statewireSessionKey({ syncUrl, principal, threadId: id }),\n    },\n    snapshotCache,\n    // Head interest (see `ATHENA_SDK_MESSAGE_WINDOW`): the tail of the\n    // transcript instead of every message; the chat UI's history edge pages\n    // older ranges in and fetches cut tool outputs into `toolOutputs`.\n    messageWindow,\n    toolOutputs,\n    capabilities: { edit: true, reload: true, continue: true },\n    // The composer stages the draft each send came from right before it\n    // sends; the message carries it as its composer markdown, so its bubble\n    // shows the text exactly as typed (`UserMessageText`).\n    getMessageMetadata: withStagedComposerMarkdown({ threadId }),\n    useClient: useSdkClient,\n    onStateChange: (state) => {\n      // Statewire publishes what the thread renders before its attach snapshot\n      // through here too (the placeholder, a remembered snapshot, and a replay\n      // boundary's pre-stream default), and on a thread mid-run it reports\n      // `connected` before the snapshot applies: only a state the host sent\n      // counts, whatever the connection says.\n      if (!isDeepAgentHostState(state)) return;\n      // The attach's first one ends the attach span (time-to-history).\n      const endSpan = attachSpanRef.current;\n      if (endSpan) {\n        attachSpanRef.current = null;\n        endSpan('statewire.snapshot', { data: { thread_id: threadId } });\n      }\n      onServerState?.(state);\n    },\n    onConnectionChange: (connection) => {\n      athenaDiagnostics.gauge('statewire.connection', connection?.status ?? null);\n      if (connection?.status === 'stopped') {\n        athenaDiagnostics.emit('statewire.connection', {\n          level: 'warn',\n          data: {\n            status: connection.status,\n            reason: connection.reason,\n            message: connection.message,\n          },\n        });\n      }\n      onConnectionChange?.(connection);\n    },\n    onRawConnectionChange,\n    onRunningChange,\n    // Each model-context notification pulls the latest getter through the\n    // core's per-render ref; the value-stable key re-registers (and so\n    // notifies) only when the built runConfig actually changed. On a thread\n    // with a server config lane, agora keeps only the per-send keys of what\n    // this carries; `StatewireThreadConfigLaneSync` writes a changed model,\n    // system prompt, tool list, workbench or knowledge base to the lane itself.\n    runConfig: {\n      get: () => runConfigValue,\n      key: runConfigKey,\n    },\n    onError: (error) => {\n      if (!isStatewireChannelTeardown(error)) {\n        athenaDiagnostics.error(\n          'statewire.error',\n          error,\n          {\n            code: 'statewire_rejected',\n            message: 'The statewire host rejected a command',\n            hint: 'Inspect error.detail — agora rejections carry a structured {code, message}.',\n          },\n          { thread_id: threadId },\n        );\n      }\n      if (onError) {\n        onError(error);\n        return;\n      }\n      logUnhandledStatewireError('AthenaSDK', error);\n    },\n  });\n}\n"],"names":["DEEP_AGENT_DEFAULT_MESSAGE_WINDOW","useMemo","collectStatewireClientTools","resolveAgentProp","useContext","AthenaAuthContext","useRef","athenaDiagnostics","buildStatewireRunConfig","statewireClientToolWireEntries","Tools","useAui","useDeepAgentRuntime","resolveStatewireAuthHeaders","statewireSessionKey","withStagedComposerMarkdown","isDeepAgentHostState","isStatewireChannelTeardown","logUnhandledStatewireError"],"mappings":";;;;;;;;;;;;;;;AA+CO,MAAM,4BAA+D;AAAA,EAC1E,MAAMA,kBAAAA;AACR;AAgFA,MAAM,gBAAyB,CAAA;AAC/B,MAAM,iBAA2B,CAAA;AAI1B,SAAS,wBACd,iBACwB;AACxB,SAAOC,MAAAA;AAAAA,IACL,MAAMC,qBAAAA,4BAA4B,mBAAmB,aAAa;AAAA,IAClE,CAAC,eAAe;AAAA,EAAA;AAEpB;AAaO,SAAS,0BACd,QACiB;;AACjB,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA,YAAY;AAAA,IACZ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,QAAQ;AAAA,IACR,kBAAkB;AAAA,IAClB,kBAAkB;AAAA,IAClB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,gBAAgB;AAAA,IAChB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA,IACE;AAMJC,qBAAAA,iBAAiB,EAAE,OAAO;AAE1B,QAAM,cAAc,wBAAwB,eAAe;AAI3D,QAAM,cAAcC,MAAAA,WAAWC,mCAAiB;AAChD,QAAM,cAAY,gDAAa,SAAb,mBAAmB,WAAU;AAG/C,QAAM,gBAAgBC,MAAAA,OAAwD,IAAI;AAClF,QAAM,kBAAkBA,MAAAA,OAAsB,IAAI;AAClD,MAAI,gBAAgB,YAAY,UAAU;AACxC,oBAAgB,UAAU;AAC1B,kBAAc,UAAUC,kBAAAA,kBAAkB;AAAA,MACxC,oBAAoB,QAAQ;AAAA,MAC5B;AAAA,MACA,EAAE,WAAW,UAAU,aAAa,UAAA;AAAA,IAAU;AAAA,EAElD;AAQA,QAAM,iBAAiBC,mBAAAA,wBAAwB;AAAA,IAC7C;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,aAAaC,qBAAAA,+BAA+B,WAAW;AAAA,EAAA,CACxD;AACD,QAAM,eAAe,KAAK,UAAU,cAAc;AAElD,QAAM,WAAWR,cAAQ,MAAMS,cAAM,EAAE,SAAS,gBAAA,CAAiB,GAAG,CAAC,eAAe,CAAC;AAIrF,QAAM,eAAe,CAAC,WAAmCC,QAAAA,OAAO,EAAE,QAAQ,OAAO,UAAU;AAE3F,SAAOC,wCAAoB;AAAA,IACzB,SAAS;AAAA,IACT;AAAA,IACA,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA,IAKT,SAAS,CAAC,QAAQC,iDAA4B,EAAE,QAAQ,OAAO,SAAA,GAAY,GAAG;AAAA,IAC9E;AAAA;AAAA;AAAA,IAGA,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOhB,SAAS;AAAA,MACP,MAAM;AAAA,MACN,KAAK,CAAC,OAAOC,oBAAAA,oBAAoB,EAAE,SAAS,WAAW,UAAU,GAAA,CAAI;AAAA,IAAA;AAAA,IAEvE;AAAA;AAAA;AAAA;AAAA,IAIA;AAAA,IACA;AAAA,IACA,cAAc,EAAE,MAAM,MAAM,QAAQ,MAAM,UAAU,KAAA;AAAA;AAAA;AAAA;AAAA,IAIpD,oBAAoBC,iBAAAA,2BAA2B,EAAE,UAAU;AAAA,IAC3D,WAAW;AAAA,IACX,eAAe,CAAC,UAAU;AAMxB,UAAI,CAACC,SAAAA,qBAAqB,KAAK,EAAG;AAElC,YAAM,UAAU,cAAc;AAC9B,UAAI,SAAS;AACX,sBAAc,UAAU;AACxB,gBAAQ,sBAAsB,EAAE,MAAM,EAAE,WAAW,SAAA,GAAY;AAAA,MACjE;AACA,qDAAgB;AAAA,IAClB;AAAA,IACA,oBAAoB,CAAC,eAAe;AAClCT,wBAAAA,kBAAkB,MAAM,yBAAwB,yCAAY,WAAU,IAAI;AAC1E,WAAI,yCAAY,YAAW,WAAW;AACpCA,0BAAAA,kBAAkB,KAAK,wBAAwB;AAAA,UAC7C,OAAO;AAAA,UACP,MAAM;AAAA,YACJ,QAAQ,WAAW;AAAA,YACnB,QAAQ,WAAW;AAAA,YACnB,SAAS,WAAW;AAAA,UAAA;AAAA,QACtB,CACD;AAAA,MACH;AACA,+DAAqB;AAAA,IACvB;AAAA,IACA;AAAA,IACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOA,WAAW;AAAA,MACT,KAAK,MAAM;AAAA,MACX,KAAK;AAAA,IAAA;AAAA,IAEP,SAAS,CAAC,UAAU;AAClB,UAAI,CAACU,OAAAA,2BAA2B,KAAK,GAAG;AACtCV,0BAAAA,kBAAkB;AAAA,UAChB;AAAA,UACA;AAAA,UACA;AAAA,YACE,MAAM;AAAA,YACN,SAAS;AAAA,YACT,MAAM;AAAA,UAAA;AAAA,UAER,EAAE,WAAW,SAAA;AAAA,QAAS;AAAA,MAE1B;AACA,UAAI,SAAS;AACX,gBAAQ,KAAK;AACb;AAAA,MACF;AACAW,0BAAAA,2BAA2B,aAAa,KAAK;AAAA,IAC/C;AAAA,EAAA,CACD;AACH;;;;;"}

package/dist/runtime/useAthenaStatewireRuntime.d.ts

@@ -81,10 +81,11 @@ export interface AthenaStatewireRuntimeConfig {
     /** Notified when a run starts/stops. */
     onRunningChange?: UseDeepAgentThreadOptions['onRunningChange'];
     /**
-     * Observes the host's own state: called once the attach's hello has landed
-     * (with the snapshot it carried) and then on every later frame — never with
-     * the placeholder or remembered snapshot a thread renders before its hello.
-     * Called per streamed token, so keep it cheap.
+     * Observes the host's own state: called with the attach snapshot and then on
+     * every later frame (`isDeepAgentHostState`) — never with the placeholder or
+     * remembered snapshot a thread renders before its snapshot applies, which
+     * can be after the connection reports `connected`. Called per streamed
+     * token, so keep it cheap.
      */
     onServerState?: (state: DeepAgentStreamValues) => void;
 }

package/dist/runtime/useAthenaStatewireRuntime.js

@@ -10,7 +10,7 @@ import { DEFAULT_STATEWIRE_MODEL } from "./statewire-run-config.js";
 import { DEEP_AGENT_DEFAULT_MESSAGE_WINDOW } from "../agent-runtime/src/generated/runconfig-contract.js";
 import { useDeepAgentRuntime, logUnhandledStatewireError } from "../agent-runtime/src/use-deep-agent-runtime.js";
 import { isStatewireChannelTeardown } from "../agent-runtime/src/errors.js";
-import { isDeepAgentStateHydrated } from "../agent-runtime/src/statewire-state.js";
+import { isDeepAgentHostState } from "../agent-runtime/src/protocol.js";
 import { withStagedComposerMarkdown } from "../agent-runtime/src/composer-markdown.js";
 const ATHENA_SDK_MESSAGE_WINDOW = {
   size: DEEP_AGENT_DEFAULT_MESSAGE_WINDOW
@@ -82,8 +82,6 @@ function useAthenaStatewireRuntime(config) {
     clientTools: statewireClientToolWireEntries(clientTools)
   });
   const runConfigKey = JSON.stringify(runConfigValue);
-  const lastStateRef = useRef(null);
-  const helloLandedRef = useRef(false);
   const auiTools = useMemo(() => Tools({ toolkit: frontendToolkit }), [frontendToolkit]);
   const useSdkClient = (thread) => useAui({ thread, tools: auiTools });
   return useDeepAgentRuntime({
@@ -122,14 +120,13 @@ function useAthenaStatewireRuntime(config) {
     getMessageMetadata: withStagedComposerMarkdown({ threadId }),
     useClient: useSdkClient,
     onStateChange: (state) => {
+      if (!isDeepAgentHostState(state)) return;
       const endSpan = attachSpanRef.current;
       if (endSpan) {
         attachSpanRef.current = null;
         endSpan("statewire.snapshot", { data: { thread_id: threadId } });
       }
-      if (!isDeepAgentStateHydrated(state)) return;
-      lastStateRef.current = state;
-      if (helloLandedRef.current) onServerState == null ? void 0 : onServerState(state);
+      onServerState == null ? void 0 : onServerState(state);
     },
     onConnectionChange: (connection) => {
       athenaDiagnostics.gauge("statewire.connection", (connection == null ? void 0 : connection.status) ?? null);
@@ -145,14 +142,7 @@ function useAthenaStatewireRuntime(config) {
       }
       onConnectionChange == null ? void 0 : onConnectionChange(connection);
     },
-    onRawConnectionChange: (connection) => {
-      if (connection.status === "connected" && !helloLandedRef.current) {
-        helloLandedRef.current = true;
-        const helloState = lastStateRef.current;
-        if (helloState) onServerState == null ? void 0 : onServerState(helloState);
-      }
-      onRawConnectionChange == null ? void 0 : onRawConnectionChange(connection);
-    },
+    onRawConnectionChange,
     onRunningChange,
     // Each model-context notification pulls the latest getter through the
     // core's per-render ref; the value-stable key re-registers (and so

package/dist/runtime/useAthenaStatewireRuntime.js.map

@@ -1 +1 @@
-{"version":3,"file":"useAthenaStatewireRuntime.js","sources":["../../src/runtime/useAthenaStatewireRuntime.ts"],"sourcesContent":["import type { AssistantClient, Toolkit } from '@assistant-ui/react';\nimport { Tools, useAui } from '@assistant-ui/react';\nimport {\n  DEEP_AGENT_DEFAULT_MESSAGE_WINDOW,\n  type DeepAgentMessageWindowDeclaration,\n  type DeepAgentStreamValues,\n  type DeepAgentThreadElement,\n  type DeepAgentThreadSnapshotCache,\n  type DeepAgentToolOutputStore,\n  isDeepAgentStateHydrated,\n  isStatewireChannelTeardown,\n  logUnhandledStatewireError,\n  type RegisteredClientTool,\n  useDeepAgentRuntime,\n  type UseDeepAgentThreadOptions,\n  withStagedComposerMarkdown,\n} from '@athenaintel/agent-runtime';\nimport { useContext, useMemo, useRef } from 'react';\nimport { AthenaAuthContext } from '../auth/AthenaAuthContext';\nimport {\n  collectStatewireClientTools,\n  statewireClientToolWireEntries,\n} from '../chat/statewire-client-tools';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport {\n  type AthenaStatewireTokenGetter,\n  resolveStatewireAuthHeaders,\n} from './statewire-auth-headers';\nimport { statewireSessionKey } from './statewire-session-key';\n\ntype AthenaDiagnosticsSpanStarter = typeof athenaDiagnostics.span;\nimport {\n  buildStatewireRunConfig,\n  DEFAULT_STATEWIRE_MODEL,\n  resolveAgentProp,\n} from './statewire-run-config';\n\nexport { DEFAULT_STATEWIRE_MODEL };\n\n/**\n * The head interest every SDK attach states (`athena/interest`): the host\n * mounts the transcript's tail as message documents instead of every message\n * — megabytes on long threads, over the 1 MiB frame limit of stock websocket\n * clients. Older pages load from the `StatewireHistoryEdge` row the chat UI\n * mounts above the messages, and cut tool outputs are fetched back for the\n * cards that show them.\n */\nexport const ATHENA_SDK_MESSAGE_WINDOW: DeepAgentMessageWindowDeclaration = {\n  size: DEEP_AGENT_DEFAULT_MESSAGE_WINDOW,\n};\n\nexport interface AthenaStatewireRuntimeConfig {\n  /** Base URL of the statewire sync host (the `…/v2/threads` mount). */\n  syncUrl: string;\n  /** Thread ID the statewire session attaches to. */\n  threadId: string;\n  /** True only for a never-started local chat. Existing (or pre-assigned)\n   *  threads load until their server snapshot arrives. */\n  isNewChat?: boolean;\n  /** API key for authentication. Used when no auth token is provided. */\n  apiKey?: string;\n  /** Auth token. Takes priority over apiKey. */\n  token?: string | null;\n  /** Resolve the latest token immediately before a request (for expiring\n   *  clients). Called with `{ force: true }` right after the host refused the\n   *  previous credential (the transport's `staleAuth`), so a caching getter\n   *  mints a fresh token instead of returning the refused one. */\n  getToken?: AthenaStatewireTokenGetter;\n  /**\n   * Per-provider LRU of each thread's last wire state. A switch back to a\n   * remembered thread mounts with that snapshot and projects ready on the\n   * first frame instead of a loading treatment; the attach snapshot then\n   * replaces it. Owned above the per-thread mount so it survives switches.\n   */\n  snapshotCache?: DeepAgentThreadSnapshotCache;\n  /** The head interest stated on the attach (see {@link ATHENA_SDK_MESSAGE_WINDOW}, the default). */\n  messageWindow?: DeepAgentMessageWindowDeclaration;\n  /**\n   * Full tool outputs fetched back for a windowed wire's cut tool messages;\n   * the thread re-converts when one lands. `AthenaProvider` owns one per\n   * provider and hands the same store to `StatewireHistoryEdge`.\n   */\n  toolOutputs?: DeepAgentToolOutputStore;\n  /** LLM model identifier. Defaults to the deep-agent default model. */\n  model?: string;\n  /** Agent selector: only `collab_agent:<asset_id>` refs are accepted (the run\n   *  executes AS that published collab agent). Any other non-empty value\n   *  throws — see `resolveAgentProp`. */\n  agent?: string;\n  /** Collab-agent channel id selecting that channel's overrides. */\n  channel?: string;\n  /** The agent's mode picked for this thread (`AthenaProvider` `modes`). */\n  mode?: string;\n  /** Backend toolkit IDs to enable. */\n  tools?: string[];\n  /** Frontend tool IDs to include in enabled_tools. */\n  frontendToolIds?: string[];\n  /** Frontend tools registered on the assistant client. Tools with a local\n   *  `execute` are also declared as `client_tools` and executed through the\n   *  statewire client-tool bridge. */\n  frontendToolkit?: Toolkit;\n  /** Asset IDs to include in the workbench. */\n  workbench?: string[];\n  /** Knowledge base IDs for RAG context. */\n  knowledgeBase?: string[];\n  /** System prompt override. */\n  systemPrompt?: string;\n  /** Client app identifier for session filtering. Sent as app_id in runConfig.custom. */\n  appId?: string;\n  /** Additional fields merged into runConfig.custom. */\n  extraRunConfig?: Record<string, unknown>;\n  /** Called on statewire transport errors (send rejections, stream failures). */\n  onError?: (error: Error) => void;\n  /** Projected connection status changes (deduped; null on unmount). */\n  onConnectionChange?: UseDeepAgentThreadOptions['onConnectionChange'];\n  /** Raw connection observer — carries the transport's reconnect handle. */\n  onRawConnectionChange?: UseDeepAgentThreadOptions['onRawConnectionChange'];\n  /** Notified when a run starts/stops. */\n  onRunningChange?: UseDeepAgentThreadOptions['onRunningChange'];\n  /**\n   * Observes the host's own state: called once the attach's hello has landed\n   * (with the snapshot it carried) and then on every later frame — never with\n   * the placeholder or remembered snapshot a thread renders before its hello.\n   * Called per streamed token, so keep it cheap.\n   */\n  onServerState?: (state: DeepAgentStreamValues) => void;\n}\n\nconst EMPTY_TOOLKIT: Toolkit = {};\nconst EMPTY_TOOL_IDS: string[] = [];\n\n/** The client tools derived from the runtime's frontend toolkit — exposed so\n *  the provider can mount the client-tool bridge with the same set. */\nexport function useStatewireClientTools(\n  frontendToolkit: Toolkit | undefined,\n): RegisteredClientTool[] {\n  return useMemo(\n    () => collectStatewireClientTools(frontendToolkit ?? EMPTY_TOOLKIT),\n    [frontendToolkit],\n  );\n}\n\n/**\n * Statewire runtime for the Athena SDK — a thin shim over the shared\n * `@athenaintel/agent-runtime` `useDeepAgentRuntime`: it attaches to the\n * agora-hosted deep-agent thread at `${syncUrl}/${threadId}` and returns the\n * `AssistantClient` to mount via `AuiProvider` — the same integration shape as\n * the Olympus, Chrome extension, Office, and mobile statewire hosts.\n *\n * Auth: a token (resolved live through `getToken` when provided) rides\n * `Authorization: Bearer`, and an API key falls back to `X-API-KEY` — both\n * accepted by the statewire host.\n */\nexport function useAthenaStatewireRuntime(\n  config: AthenaStatewireRuntimeConfig,\n): AssistantClient {\n  const {\n    syncUrl,\n    threadId,\n    isNewChat = false,\n    apiKey,\n    token,\n    getToken,\n    model,\n    agent,\n    channel,\n    mode,\n    tools = EMPTY_TOOL_IDS,\n    frontendToolIds = EMPTY_TOOL_IDS,\n    frontendToolkit = EMPTY_TOOLKIT,\n    workbench,\n    knowledgeBase,\n    systemPrompt,\n    appId,\n    extraRunConfig,\n    snapshotCache,\n    messageWindow = ATHENA_SDK_MESSAGE_WINDOW,\n    toolOutputs,\n    onError,\n    onConnectionChange,\n    onRawConnectionChange,\n    onRunningChange,\n    onServerState,\n  } = config;\n\n  // Fail loud at mount, not at first send: the statewire host always runs the\n  // Athena deep agent, so an `agent` outside the collab_agent namespace can\n  // never apply. Throwing here (render time) is what makes a misconfigured\n  // integration visible instead of quietly answering as the wrong agent.\n  resolveAgentProp({ agent });\n\n  const clientTools = useStatewireClientTools(frontendToolkit);\n\n  // The persisted command lane is keyed by WHO is signed in as well as by host\n  // and thread (see `statewireSessionKey`).\n  const authContext = useContext(AthenaAuthContext);\n  const principal = authContext?.user?.userId ?? '';\n\n  // Attach → first server snapshot span, keyed per thread attach.\n  const attachSpanRef = useRef<ReturnType<AthenaDiagnosticsSpanStarter> | null>(null);\n  const attachThreadRef = useRef<string | null>(null);\n  if (attachThreadRef.current !== threadId) {\n    attachThreadRef.current = threadId;\n    attachSpanRef.current = athenaDiagnostics.span(\n      `statewire.attach:${threadId}`,\n      'statewire.attach.start',\n      { thread_id: threadId, is_new_chat: isNewChat },\n    );\n  }\n\n  // Built every render so its JSON signature can key the model-context\n  // registration below: consumers commonly pass fresh array literals per\n  // render, which must not thrash registration, while a changed value (a new\n  // `model`, channel, tool list, system prompt, …) must re-sync the context\n  // before the next send. The core pulls this value only on model-context\n  // notifications, which a key change triggers.\n  const runConfigValue = buildStatewireRunConfig({\n    model,\n    agent,\n    channel,\n    mode,\n    tools,\n    frontendToolIds,\n    workbench,\n    knowledgeBase,\n    systemPrompt,\n    appId,\n    extraRunConfig,\n    clientTools: statewireClientToolWireEntries(clientTools),\n  });\n  const runConfigKey = JSON.stringify(runConfigValue);\n\n  // The host's state, told apart from what the thread renders before its\n  // hello: statewire publishes the initial (placeholder or remembered) state\n  // through `onStateChange` too, and reports `connected` in the same flush\n  // right after publishing the state the hello carried. So the latest state\n  // seen when the connection first turns `connected` is the hello's, and every\n  // state after it is the host's. Refs are per attach: the runtime is mounted\n  // per thread.\n  const lastStateRef = useRef<DeepAgentStreamValues | null>(null);\n  const helloLandedRef = useRef(false);\n\n  const auiTools = useMemo(() => Tools({ toolkit: frontendToolkit }), [frontendToolkit]);\n  // Web client for the shared runtime core (a `use*` name so the\n  // rules-of-hooks lint sees the `useAui` call inside a custom hook; the core\n  // invokes it unconditionally every render).\n  const useSdkClient = (thread: DeepAgentThreadElement) => useAui({ thread, tools: auiTools });\n\n  return useDeepAgentRuntime({\n    surface: 'AthenaSDK',\n    threadId,\n    baseUrl: syncUrl,\n    // Option closures are re-read per render by the core, so credential\n    // rotation (new `token`/`getToken`/`apiKey` props) reaches the next\n    // request without remounting the thread. The transport's `staleAuth`\n    // (true right after a refused credential) is forwarded as `force`.\n    headers: (ctx) => resolveStatewireAuthHeaders({ apiKey, token, getToken }, ctx),\n    isNewChat,\n    // Queued entries render in the SDK's queue panel, so only the steer lane\n    // projects into the message tail.\n    laneProjection: 'steer-only',\n    // Durable session: a reload resumes the lane and resends whatever the\n    // server has not marked durable. Scoped by host AND principal — a thread\n    // id is only meaningful against the backend that minted it, and a stored\n    // lane must never resend against another signed-in user. (Consumers\n    // server-render this SDK; the core's availability probe keeps those\n    // sessions process-local, as before the seam existed.)\n    session: {\n      kind: 'local-storage',\n      key: (id) => statewireSessionKey({ syncUrl, principal, threadId: id }),\n    },\n    snapshotCache,\n    // Head interest (see `ATHENA_SDK_MESSAGE_WINDOW`): the tail of the\n    // transcript instead of every message; the chat UI's history edge pages\n    // older ranges in and fetches cut tool outputs into `toolOutputs`.\n    messageWindow,\n    toolOutputs,\n    capabilities: { edit: true, reload: true, continue: true },\n    // The composer stages the draft each send came from right before it\n    // sends; the message carries it as its composer markdown, so its bubble\n    // shows the text exactly as typed (`UserMessageText`).\n    getMessageMetadata: withStagedComposerMarkdown({ threadId }),\n    useClient: useSdkClient,\n    onStateChange: (state) => {\n      // First snapshot for this attach ends the attach span (time-to-history).\n      const endSpan = attachSpanRef.current;\n      if (endSpan) {\n        attachSpanRef.current = null;\n        endSpan('statewire.snapshot', { data: { thread_id: threadId } });\n      }\n      // A replay boundary republishes the pre-stream default: not host state.\n      if (!isDeepAgentStateHydrated(state)) return;\n      lastStateRef.current = state;\n      if (helloLandedRef.current) onServerState?.(state);\n    },\n    onConnectionChange: (connection) => {\n      athenaDiagnostics.gauge('statewire.connection', connection?.status ?? null);\n      if (connection?.status === 'stopped') {\n        athenaDiagnostics.emit('statewire.connection', {\n          level: 'warn',\n          data: {\n            status: connection.status,\n            reason: connection.reason,\n            message: connection.message,\n          },\n        });\n      }\n      onConnectionChange?.(connection);\n    },\n    onRawConnectionChange: (connection) => {\n      if (connection.status === 'connected' && !helloLandedRef.current) {\n        helloLandedRef.current = true;\n        const helloState = lastStateRef.current;\n        if (helloState) onServerState?.(helloState);\n      }\n      onRawConnectionChange?.(connection);\n    },\n    onRunningChange,\n    // Each model-context notification pulls the latest getter through the\n    // core's per-render ref; the value-stable key re-registers (and so\n    // notifies) only when the built runConfig actually changed. On a thread\n    // with a server config lane, agora keeps only the per-send keys of what\n    // this carries; `StatewireThreadConfigLaneSync` writes a changed model,\n    // system prompt, tool list, workbench or knowledge base to the lane itself.\n    runConfig: {\n      get: () => runConfigValue,\n      key: runConfigKey,\n    },\n    onError: (error) => {\n      if (!isStatewireChannelTeardown(error)) {\n        athenaDiagnostics.error(\n          'statewire.error',\n          error,\n          {\n            code: 'statewire_rejected',\n            message: 'The statewire host rejected a command',\n            hint: 'Inspect error.detail — agora rejections carry a structured {code, message}.',\n          },\n          { thread_id: threadId },\n        );\n      }\n      if (onError) {\n        onError(error);\n        return;\n      }\n      logUnhandledStatewireError('AthenaSDK', error);\n    },\n  });\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"useAthenaStatewireRuntime.js","sources":["../../src/runtime/useAthenaStatewireRuntime.ts"],"sourcesContent":["import type { AssistantClient, Toolkit } from '@assistant-ui/react';\nimport { Tools, useAui } from '@assistant-ui/react';\nimport {\n  DEEP_AGENT_DEFAULT_MESSAGE_WINDOW,\n  type DeepAgentMessageWindowDeclaration,\n  type DeepAgentStreamValues,\n  type DeepAgentThreadElement,\n  type DeepAgentThreadSnapshotCache,\n  type DeepAgentToolOutputStore,\n  isDeepAgentHostState,\n  isStatewireChannelTeardown,\n  logUnhandledStatewireError,\n  type RegisteredClientTool,\n  useDeepAgentRuntime,\n  type UseDeepAgentThreadOptions,\n  withStagedComposerMarkdown,\n} from '@athenaintel/agent-runtime';\nimport { useContext, useMemo, useRef } from 'react';\nimport { AthenaAuthContext } from '../auth/AthenaAuthContext';\nimport {\n  collectStatewireClientTools,\n  statewireClientToolWireEntries,\n} from '../chat/statewire-client-tools';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport {\n  type AthenaStatewireTokenGetter,\n  resolveStatewireAuthHeaders,\n} from './statewire-auth-headers';\nimport { statewireSessionKey } from './statewire-session-key';\n\ntype AthenaDiagnosticsSpanStarter = typeof athenaDiagnostics.span;\nimport {\n  buildStatewireRunConfig,\n  DEFAULT_STATEWIRE_MODEL,\n  resolveAgentProp,\n} from './statewire-run-config';\n\nexport { DEFAULT_STATEWIRE_MODEL };\n\n/**\n * The head interest every SDK attach states (`athena/interest`): the host\n * mounts the transcript's tail as message documents instead of every message\n * — megabytes on long threads, over the 1 MiB frame limit of stock websocket\n * clients. Older pages load from the `StatewireHistoryEdge` row the chat UI\n * mounts above the messages, and cut tool outputs are fetched back for the\n * cards that show them.\n */\nexport const ATHENA_SDK_MESSAGE_WINDOW: DeepAgentMessageWindowDeclaration = {\n  size: DEEP_AGENT_DEFAULT_MESSAGE_WINDOW,\n};\n\nexport interface AthenaStatewireRuntimeConfig {\n  /** Base URL of the statewire sync host (the `…/v2/threads` mount). */\n  syncUrl: string;\n  /** Thread ID the statewire session attaches to. */\n  threadId: string;\n  /** True only for a never-started local chat. Existing (or pre-assigned)\n   *  threads load until their server snapshot arrives. */\n  isNewChat?: boolean;\n  /** API key for authentication. Used when no auth token is provided. */\n  apiKey?: string;\n  /** Auth token. Takes priority over apiKey. */\n  token?: string | null;\n  /** Resolve the latest token immediately before a request (for expiring\n   *  clients). Called with `{ force: true }` right after the host refused the\n   *  previous credential (the transport's `staleAuth`), so a caching getter\n   *  mints a fresh token instead of returning the refused one. */\n  getToken?: AthenaStatewireTokenGetter;\n  /**\n   * Per-provider LRU of each thread's last wire state. A switch back to a\n   * remembered thread mounts with that snapshot and projects ready on the\n   * first frame instead of a loading treatment; the attach snapshot then\n   * replaces it. Owned above the per-thread mount so it survives switches.\n   */\n  snapshotCache?: DeepAgentThreadSnapshotCache;\n  /** The head interest stated on the attach (see {@link ATHENA_SDK_MESSAGE_WINDOW}, the default). */\n  messageWindow?: DeepAgentMessageWindowDeclaration;\n  /**\n   * Full tool outputs fetched back for a windowed wire's cut tool messages;\n   * the thread re-converts when one lands. `AthenaProvider` owns one per\n   * provider and hands the same store to `StatewireHistoryEdge`.\n   */\n  toolOutputs?: DeepAgentToolOutputStore;\n  /** LLM model identifier. Defaults to the deep-agent default model. */\n  model?: string;\n  /** Agent selector: only `collab_agent:<asset_id>` refs are accepted (the run\n   *  executes AS that published collab agent). Any other non-empty value\n   *  throws — see `resolveAgentProp`. */\n  agent?: string;\n  /** Collab-agent channel id selecting that channel's overrides. */\n  channel?: string;\n  /** The agent's mode picked for this thread (`AthenaProvider` `modes`). */\n  mode?: string;\n  /** Backend toolkit IDs to enable. */\n  tools?: string[];\n  /** Frontend tool IDs to include in enabled_tools. */\n  frontendToolIds?: string[];\n  /** Frontend tools registered on the assistant client. Tools with a local\n   *  `execute` are also declared as `client_tools` and executed through the\n   *  statewire client-tool bridge. */\n  frontendToolkit?: Toolkit;\n  /** Asset IDs to include in the workbench. */\n  workbench?: string[];\n  /** Knowledge base IDs for RAG context. */\n  knowledgeBase?: string[];\n  /** System prompt override. */\n  systemPrompt?: string;\n  /** Client app identifier for session filtering. Sent as app_id in runConfig.custom. */\n  appId?: string;\n  /** Additional fields merged into runConfig.custom. */\n  extraRunConfig?: Record<string, unknown>;\n  /** Called on statewire transport errors (send rejections, stream failures). */\n  onError?: (error: Error) => void;\n  /** Projected connection status changes (deduped; null on unmount). */\n  onConnectionChange?: UseDeepAgentThreadOptions['onConnectionChange'];\n  /** Raw connection observer — carries the transport's reconnect handle. */\n  onRawConnectionChange?: UseDeepAgentThreadOptions['onRawConnectionChange'];\n  /** Notified when a run starts/stops. */\n  onRunningChange?: UseDeepAgentThreadOptions['onRunningChange'];\n  /**\n   * Observes the host's own state: called with the attach snapshot and then on\n   * every later frame (`isDeepAgentHostState`) — never with the placeholder or\n   * remembered snapshot a thread renders before its snapshot applies, which\n   * can be after the connection reports `connected`. Called per streamed\n   * token, so keep it cheap.\n   */\n  onServerState?: (state: DeepAgentStreamValues) => void;\n}\n\nconst EMPTY_TOOLKIT: Toolkit = {};\nconst EMPTY_TOOL_IDS: string[] = [];\n\n/** The client tools derived from the runtime's frontend toolkit — exposed so\n *  the provider can mount the client-tool bridge with the same set. */\nexport function useStatewireClientTools(\n  frontendToolkit: Toolkit | undefined,\n): RegisteredClientTool[] {\n  return useMemo(\n    () => collectStatewireClientTools(frontendToolkit ?? EMPTY_TOOLKIT),\n    [frontendToolkit],\n  );\n}\n\n/**\n * Statewire runtime for the Athena SDK — a thin shim over the shared\n * `@athenaintel/agent-runtime` `useDeepAgentRuntime`: it attaches to the\n * agora-hosted deep-agent thread at `${syncUrl}/${threadId}` and returns the\n * `AssistantClient` to mount via `AuiProvider` — the same integration shape as\n * the Olympus, Chrome extension, Office, and mobile statewire hosts.\n *\n * Auth: a token (resolved live through `getToken` when provided) rides\n * `Authorization: Bearer`, and an API key falls back to `X-API-KEY` — both\n * accepted by the statewire host.\n */\nexport function useAthenaStatewireRuntime(\n  config: AthenaStatewireRuntimeConfig,\n): AssistantClient {\n  const {\n    syncUrl,\n    threadId,\n    isNewChat = false,\n    apiKey,\n    token,\n    getToken,\n    model,\n    agent,\n    channel,\n    mode,\n    tools = EMPTY_TOOL_IDS,\n    frontendToolIds = EMPTY_TOOL_IDS,\n    frontendToolkit = EMPTY_TOOLKIT,\n    workbench,\n    knowledgeBase,\n    systemPrompt,\n    appId,\n    extraRunConfig,\n    snapshotCache,\n    messageWindow = ATHENA_SDK_MESSAGE_WINDOW,\n    toolOutputs,\n    onError,\n    onConnectionChange,\n    onRawConnectionChange,\n    onRunningChange,\n    onServerState,\n  } = config;\n\n  // Fail loud at mount, not at first send: the statewire host always runs the\n  // Athena deep agent, so an `agent` outside the collab_agent namespace can\n  // never apply. Throwing here (render time) is what makes a misconfigured\n  // integration visible instead of quietly answering as the wrong agent.\n  resolveAgentProp({ agent });\n\n  const clientTools = useStatewireClientTools(frontendToolkit);\n\n  // The persisted command lane is keyed by WHO is signed in as well as by host\n  // and thread (see `statewireSessionKey`).\n  const authContext = useContext(AthenaAuthContext);\n  const principal = authContext?.user?.userId ?? '';\n\n  // Attach → first server snapshot span, keyed per thread attach.\n  const attachSpanRef = useRef<ReturnType<AthenaDiagnosticsSpanStarter> | null>(null);\n  const attachThreadRef = useRef<string | null>(null);\n  if (attachThreadRef.current !== threadId) {\n    attachThreadRef.current = threadId;\n    attachSpanRef.current = athenaDiagnostics.span(\n      `statewire.attach:${threadId}`,\n      'statewire.attach.start',\n      { thread_id: threadId, is_new_chat: isNewChat },\n    );\n  }\n\n  // Built every render so its JSON signature can key the model-context\n  // registration below: consumers commonly pass fresh array literals per\n  // render, which must not thrash registration, while a changed value (a new\n  // `model`, channel, tool list, system prompt, …) must re-sync the context\n  // before the next send. The core pulls this value only on model-context\n  // notifications, which a key change triggers.\n  const runConfigValue = buildStatewireRunConfig({\n    model,\n    agent,\n    channel,\n    mode,\n    tools,\n    frontendToolIds,\n    workbench,\n    knowledgeBase,\n    systemPrompt,\n    appId,\n    extraRunConfig,\n    clientTools: statewireClientToolWireEntries(clientTools),\n  });\n  const runConfigKey = JSON.stringify(runConfigValue);\n\n  const auiTools = useMemo(() => Tools({ toolkit: frontendToolkit }), [frontendToolkit]);\n  // Web client for the shared runtime core (a `use*` name so the\n  // rules-of-hooks lint sees the `useAui` call inside a custom hook; the core\n  // invokes it unconditionally every render).\n  const useSdkClient = (thread: DeepAgentThreadElement) => useAui({ thread, tools: auiTools });\n\n  return useDeepAgentRuntime({\n    surface: 'AthenaSDK',\n    threadId,\n    baseUrl: syncUrl,\n    // Option closures are re-read per render by the core, so credential\n    // rotation (new `token`/`getToken`/`apiKey` props) reaches the next\n    // request without remounting the thread. The transport's `staleAuth`\n    // (true right after a refused credential) is forwarded as `force`.\n    headers: (ctx) => resolveStatewireAuthHeaders({ apiKey, token, getToken }, ctx),\n    isNewChat,\n    // Queued entries render in the SDK's queue panel, so only the steer lane\n    // projects into the message tail.\n    laneProjection: 'steer-only',\n    // Durable session: a reload resumes the lane and resends whatever the\n    // server has not marked durable. Scoped by host AND principal — a thread\n    // id is only meaningful against the backend that minted it, and a stored\n    // lane must never resend against another signed-in user. (Consumers\n    // server-render this SDK; the core's availability probe keeps those\n    // sessions process-local, as before the seam existed.)\n    session: {\n      kind: 'local-storage',\n      key: (id) => statewireSessionKey({ syncUrl, principal, threadId: id }),\n    },\n    snapshotCache,\n    // Head interest (see `ATHENA_SDK_MESSAGE_WINDOW`): the tail of the\n    // transcript instead of every message; the chat UI's history edge pages\n    // older ranges in and fetches cut tool outputs into `toolOutputs`.\n    messageWindow,\n    toolOutputs,\n    capabilities: { edit: true, reload: true, continue: true },\n    // The composer stages the draft each send came from right before it\n    // sends; the message carries it as its composer markdown, so its bubble\n    // shows the text exactly as typed (`UserMessageText`).\n    getMessageMetadata: withStagedComposerMarkdown({ threadId }),\n    useClient: useSdkClient,\n    onStateChange: (state) => {\n      // Statewire publishes what the thread renders before its attach snapshot\n      // through here too (the placeholder, a remembered snapshot, and a replay\n      // boundary's pre-stream default), and on a thread mid-run it reports\n      // `connected` before the snapshot applies: only a state the host sent\n      // counts, whatever the connection says.\n      if (!isDeepAgentHostState(state)) return;\n      // The attach's first one ends the attach span (time-to-history).\n      const endSpan = attachSpanRef.current;\n      if (endSpan) {\n        attachSpanRef.current = null;\n        endSpan('statewire.snapshot', { data: { thread_id: threadId } });\n      }\n      onServerState?.(state);\n    },\n    onConnectionChange: (connection) => {\n      athenaDiagnostics.gauge('statewire.connection', connection?.status ?? null);\n      if (connection?.status === 'stopped') {\n        athenaDiagnostics.emit('statewire.connection', {\n          level: 'warn',\n          data: {\n            status: connection.status,\n            reason: connection.reason,\n            message: connection.message,\n          },\n        });\n      }\n      onConnectionChange?.(connection);\n    },\n    onRawConnectionChange,\n    onRunningChange,\n    // Each model-context notification pulls the latest getter through the\n    // core's per-render ref; the value-stable key re-registers (and so\n    // notifies) only when the built runConfig actually changed. On a thread\n    // with a server config lane, agora keeps only the per-send keys of what\n    // this carries; `StatewireThreadConfigLaneSync` writes a changed model,\n    // system prompt, tool list, workbench or knowledge base to the lane itself.\n    runConfig: {\n      get: () => runConfigValue,\n      key: runConfigKey,\n    },\n    onError: (error) => {\n      if (!isStatewireChannelTeardown(error)) {\n        athenaDiagnostics.error(\n          'statewire.error',\n          error,\n          {\n            code: 'statewire_rejected',\n            message: 'The statewire host rejected a command',\n            hint: 'Inspect error.detail — agora rejections carry a structured {code, message}.',\n          },\n          { thread_id: threadId },\n        );\n      }\n      if (onError) {\n        onError(error);\n        return;\n      }\n      logUnhandledStatewireError('AthenaSDK', error);\n    },\n  });\n}\n"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenaintel/react",
-  "version": "0.41.1",
+  "version": "0.41.2",
   "description": "Athena React SDK — Build AI-powered chat applications with the Athena platform",
   "type": "module",
   "main": "./dist/index.cjs",