@athenaintel/react 0.19.0 → 0.21.0

package/dist/packages/agent-runtime/src/optimistic-content.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const buildOptimisticHumanContent = (parts) => {
+  const imageParts = parts.filter(
+    (part) => part.type === "image"
+  );
+  const text = parts.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+  if (imageParts.length === 0) {
+    return text;
+  }
+  return [
+    { type: "text", text },
+    ...imageParts.map((part) => ({ type: "image_url", image_url: { url: part.image } }))
+  ];
+};
+exports.buildOptimisticHumanContent = buildOptimisticHumanContent;
+//# sourceMappingURL=optimistic-content.cjs.map

package/dist/packages/agent-runtime/src/optimistic-content.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimistic-content.cjs","sources":["../../../../../agent-runtime/src/optimistic-content.ts"],"sourcesContent":["import type { LangChainMessage } from '@assistant-ui/react-langgraph';\n\n/** Parts of a pending user message the optimistic bubble can render. */\nexport type OptimisticContentPart =\n  | { type: 'text'; text: string }\n  | { type: 'image'; image: string };\n\ntype HumanMessageContent = Extract<LangChainMessage, { type: 'human' }>['content'];\n\n/**\n * Content for the optimistic human bubble built from a pending send. Image\n * attachment parts become LangChain `image_url` blocks so the just-sent\n * message renders its images immediately instead of waiting for the backend\n * echo (which only carries images after server-side mention extraction).\n * Text-only sends keep the plain joined string.\n */\nexport const buildOptimisticHumanContent = (\n  parts: readonly OptimisticContentPart[]\n): HumanMessageContent => {\n  const imageParts = parts.filter(\n    (part): part is Extract<OptimisticContentPart, { type: 'image' }> => part.type === 'image'\n  );\n  const text = parts\n    .filter((part): part is Extract<OptimisticContentPart, { type: 'text' }> => part.type === 'text')\n    .map((part) => part.text)\n    .join('\\n');\n  if (imageParts.length === 0) {\n    return text;\n  }\n  return [\n    { type: 'text' as const, text },\n    ...imageParts.map((part) => ({ type: 'image_url' as const, image_url: { url: part.image } })),\n  ];\n};\n"],"names":[],"mappings":";;AAgBO,MAAM,8BAA8B,CACzC,UACwB;AACxB,QAAM,aAAa,MAAM;AAAA,IACvB,CAAC,SAAoE,KAAK,SAAS;AAAA,EAAA;AAErF,QAAM,OAAO,MACV,OAAO,CAAC,SAAmE,KAAK,SAAS,MAAM,EAC/F,IAAI,CAAC,SAAS,KAAK,IAAI,EACvB,KAAK,IAAI;AACZ,MAAI,WAAW,WAAW,GAAG;AAC3B,WAAO;AAAA,EACT;AACA,SAAO;AAAA,IACL,EAAE,MAAM,QAAiB,KAAA;AAAA,IACzB,GAAG,WAAW,IAAI,CAAC,UAAU,EAAE,MAAM,aAAsB,WAAW,EAAE,KAAK,KAAK,MAAA,IAAU;AAAA,EAAA;AAEhG;;"}

package/dist/packages/agent-runtime/src/optimistic-content.js

@@ -0,0 +1,17 @@
+const buildOptimisticHumanContent = (parts) => {
+  const imageParts = parts.filter(
+    (part) => part.type === "image"
+  );
+  const text = parts.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+  if (imageParts.length === 0) {
+    return text;
+  }
+  return [
+    { type: "text", text },
+    ...imageParts.map((part) => ({ type: "image_url", image_url: { url: part.image } }))
+  ];
+};
+export {
+  buildOptimisticHumanContent
+};
+//# sourceMappingURL=optimistic-content.js.map

package/dist/packages/agent-runtime/src/optimistic-content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimistic-content.js","sources":["../../../../../agent-runtime/src/optimistic-content.ts"],"sourcesContent":["import type { LangChainMessage } from '@assistant-ui/react-langgraph';\n\n/** Parts of a pending user message the optimistic bubble can render. */\nexport type OptimisticContentPart =\n  | { type: 'text'; text: string }\n  | { type: 'image'; image: string };\n\ntype HumanMessageContent = Extract<LangChainMessage, { type: 'human' }>['content'];\n\n/**\n * Content for the optimistic human bubble built from a pending send. Image\n * attachment parts become LangChain `image_url` blocks so the just-sent\n * message renders its images immediately instead of waiting for the backend\n * echo (which only carries images after server-side mention extraction).\n * Text-only sends keep the plain joined string.\n */\nexport const buildOptimisticHumanContent = (\n  parts: readonly OptimisticContentPart[]\n): HumanMessageContent => {\n  const imageParts = parts.filter(\n    (part): part is Extract<OptimisticContentPart, { type: 'image' }> => part.type === 'image'\n  );\n  const text = parts\n    .filter((part): part is Extract<OptimisticContentPart, { type: 'text' }> => part.type === 'text')\n    .map((part) => part.text)\n    .join('\\n');\n  if (imageParts.length === 0) {\n    return text;\n  }\n  return [\n    { type: 'text' as const, text },\n    ...imageParts.map((part) => ({ type: 'image_url' as const, image_url: { url: part.image } })),\n  ];\n};\n"],"names":[],"mappings":"AAgBO,MAAM,8BAA8B,CACzC,UACwB;AACxB,QAAM,aAAa,MAAM;AAAA,IACvB,CAAC,SAAoE,KAAK,SAAS;AAAA,EAAA;AAErF,QAAM,OAAO,MACV,OAAO,CAAC,SAAmE,KAAK,SAAS,MAAM,EAC/F,IAAI,CAAC,SAAS,KAAK,IAAI,EACvB,KAAK,IAAI;AACZ,MAAI,WAAW,WAAW,GAAG;AAC3B,WAAO;AAAA,EACT;AACA,SAAO;AAAA,IACL,EAAE,MAAM,QAAiB,KAAA;AAAA,IACzB,GAAG,WAAW,IAAI,CAAC,UAAU,EAAE,MAAM,aAAsB,WAAW,EAAE,KAAK,KAAK,MAAA,IAAU;AAAA,EAAA;AAEhG;"}

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const runconfigContract = require("./generated/runconfig-contract.cjs");
+const isContractVersion = (value) => typeof value === "number" && Number.isInteger(value) && value >= 1;
+function readDeepAgentProtocol(state) {
+  if (typeof state !== "object" || state === null) return null;
+  const lane = state[runconfigContract.DEEP_AGENT_PROTOCOL_STATE_KEY];
+  if (typeof lane !== "object" || lane === null) return null;
+  const { version } = lane;
+  if (!isContractVersion(version)) return null;
+  return { version };
+}
+function projectDeepAgentProtocol(state) {
+  const lane = readDeepAgentProtocol(state);
+  if (lane === null) return null;
+  return {
+    protocolVersion: lane.version,
+    clientVersion: runconfigContract.DEEP_AGENT_PROTOCOL_VERSION
+  };
+}
+function withDeclaredProtocolVersion(headers) {
+  if (runconfigContract.DEEP_AGENT_PROTOCOL_VERSION_HEADER in headers) return headers;
+  return {
+    ...headers,
+    [runconfigContract.DEEP_AGENT_PROTOCOL_VERSION_HEADER]: String(runconfigContract.DEEP_AGENT_PROTOCOL_VERSION)
+  };
+}
+exports.projectDeepAgentProtocol = projectDeepAgentProtocol;
+exports.readDeepAgentProtocol = readDeepAgentProtocol;
+exports.withDeclaredProtocolVersion = withDeclaredProtocolVersion;
+//# sourceMappingURL=protocol.cjs.map

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

@@ -0,0 +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;;;;"}

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

@@ -0,0 +1,31 @@
+import { DEEP_AGENT_PROTOCOL_VERSION, DEEP_AGENT_PROTOCOL_STATE_KEY, DEEP_AGENT_PROTOCOL_VERSION_HEADER } from "./generated/runconfig-contract.js";
+const isContractVersion = (value) => typeof value === "number" && Number.isInteger(value) && value >= 1;
+function readDeepAgentProtocol(state) {
+  if (typeof state !== "object" || state === null) return null;
+  const lane = state[DEEP_AGENT_PROTOCOL_STATE_KEY];
+  if (typeof lane !== "object" || lane === null) return null;
+  const { version } = lane;
+  if (!isContractVersion(version)) return null;
+  return { version };
+}
+function projectDeepAgentProtocol(state) {
+  const lane = readDeepAgentProtocol(state);
+  if (lane === null) return null;
+  return {
+    protocolVersion: lane.version,
+    clientVersion: DEEP_AGENT_PROTOCOL_VERSION
+  };
+}
+function withDeclaredProtocolVersion(headers) {
+  if (DEEP_AGENT_PROTOCOL_VERSION_HEADER in headers) return headers;
+  return {
+    ...headers,
+    [DEEP_AGENT_PROTOCOL_VERSION_HEADER]: String(DEEP_AGENT_PROTOCOL_VERSION)
+  };
+}
+export {
+  projectDeepAgentProtocol,
+  readDeepAgentProtocol,
+  withDeclaredProtocolVersion
+};
+//# sourceMappingURL=protocol.js.map

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

@@ -0,0 +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;"}

package/dist/packages/agent-runtime/src/queue.cjs

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const messages = require("./messages.cjs");
+function queueEntryText(parts) {
+  return parts.flatMap(
+    (part) => part.type === "text" && typeof part.text === "string" ? [part.text] : []
+  ).join("\n\n");
+}
+function isQueueEntryUnsettled(entry) {
+  return entry.meta === void 0;
+}
+function readPrioritizedQueueIds(raw) {
+  return Array.isArray(raw) ? raw.filter((id) => typeof id === "string") : [];
+}
+function queueLaneFlags(status) {
+  return {
+    isRunning: status === "running",
+    isContinuable: status === "stopped" || status === "error"
+  };
+}
+function buildStatewireQueueRows(options) {
+  const { queue, steerQueue, isContinuable } = options;
+  return [
+    ...isContinuable ? steerQueue.map((item) => ({ item, lane: "steer" })) : [],
+    ...queue.map((item) => ({ item, lane: "queue" }))
+  ];
+}
+function showQueueRowSendNow(options) {
+  const { lane, index, isRunning, isContinuable } = options;
+  return lane === "queue" && (isContinuable || isRunning && index === 0);
+}
+function buildQueueEditCommand(options) {
+  const { item, lane, runId, text } = options;
+  if (!text.trim() || text === queueEntryText(item.parts) || runId === null) {
+    return null;
+  }
+  const message = {
+    id: item.id,
+    role: "user",
+    parts: [{ type: "text", text }, ...item.parts.filter((part) => part.type !== "text")],
+    ...item.metadata === void 0 ? {} : { metadata: item.metadata }
+  };
+  return lane === "steer" ? { type: "run/steer", runId, message } : { type: "run/enqueue", runId, message };
+}
+const QUEUE_AUTO_CONTINUE_DELAY_MS = 2e3;
+function userStopBlocksQueueAutoContinue(options) {
+  return options.marker === messages.ATHENA_RUN_MARKER_CANCELLED && !messages.isServerUpdateStopSource(options.source);
+}
+function describeQueueSendFailure(failure) {
+  const message = "message" in failure && failure.message !== void 0 ? `: ${failure.message}` : "";
+  return `${failure.fate} (${failure.cause})${message}`;
+}
+function isFailedSendEntryRace(error) {
+  return error instanceof Error && error.message.startsWith("statewire: unknown failed");
+}
+exports.QUEUE_AUTO_CONTINUE_DELAY_MS = QUEUE_AUTO_CONTINUE_DELAY_MS;
+exports.buildQueueEditCommand = buildQueueEditCommand;
+exports.buildStatewireQueueRows = buildStatewireQueueRows;
+exports.describeQueueSendFailure = describeQueueSendFailure;
+exports.isFailedSendEntryRace = isFailedSendEntryRace;
+exports.isQueueEntryUnsettled = isQueueEntryUnsettled;
+exports.queueEntryText = queueEntryText;
+exports.queueLaneFlags = queueLaneFlags;
+exports.readPrioritizedQueueIds = readPrioritizedQueueIds;
+exports.showQueueRowSendNow = showQueueRowSendNow;
+exports.userStopBlocksQueueAutoContinue = userStopBlocksQueueAutoContinue;
+//# sourceMappingURL=queue.cjs.map

package/dist/packages/agent-runtime/src/queue.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.cjs","sources":["../../../../../agent-runtime/src/queue.ts"],"sourcesContent":["/**\n * Derivations for the server-owned statewire queue and steer lanes, shared by\n * every queued-messages tray (Olympus, the React SDK, the Chrome extension).\n *\n * The queue is SERVER-owned: statewire surfaces it on the runs projection.\n * \"Send now\" moves an item into the steer lane (`run/steer` — the host stops\n * the run and dispatches it once the run settles; on a stopped/errored thread\n * the same move dispatches immediately as a stop-/error-continue run) and\n * remove issues `run/dequeue`. While the thread rests stopped/errored,\n * stranded steer-lane entries list ahead of the queue — they dispatch first,\n * as one batch, so they carry Remove but no per-row Send now.\n *\n * Pure helpers only: the host component reads `useStatewireRuns()` and\n * `useDeepAgentThreadStatus()` itself (both mockable per surface) and passes\n * the values in.\n */\n\nimport type { StatewireThread } from '@assistant-ui/react-statewire';\nimport { ATHENA_RUN_MARKER_CANCELLED, isServerUpdateStopSource } from './messages';\nimport type { DeepAgentThreadStatus } from './thread-status';\n\n/** The text content of a queued entry (non-text parts render as fallbacks). */\nexport function queueEntryText(\n  parts: readonly { type: string; text?: string }[],\n): string {\n  return parts\n    .flatMap((part) =>\n      part.type === 'text' && typeof part.text === 'string' ? [part.text] : [],\n    )\n    .join('\\n\\n');\n}\n\n/**\n * Whether a lane entry is still awaiting its send's settle: the host stamps\n * `meta` on every entry it admits (`_op_meta` — submitter and contextSync\n * snapshot), so a meta-less entry is this client's own optimistic fold. The\n * send is still in flight and can still be refused (billing gate, auth,\n * reconnect), which the tray must not render as an accepted queue position.\n */\nexport function isQueueEntryUnsettled(entry: StatewireThread.RunsQueueEntry): boolean {\n  return entry.meta === undefined;\n}\n\n/**\n * The ids of queued entries the user prioritized (⚡ — `run/prioritize`), as\n * the host records them in its durable `prioritizedQueueIds` state. A\n * prioritized entry heads the queue lane and the live run ends at its next\n * model-call boundary to deliver it, so trays render these rows lit and offer\n * \"Remove priority\" instead of \"Prioritize\". Tolerates the key being absent\n * (a thread that never prioritized, a pre-feature host) and ignores anything\n * that is not a string id.\n */\nexport function readPrioritizedQueueIds(raw: unknown): readonly string[] {\n  return Array.isArray(raw)\n    ? raw.filter((id): id is string => typeof id === 'string')\n    : [];\n}\n\nexport interface QueueLaneFlags {\n  isRunning: boolean;\n  /** A stopped/errored thread can continue with its queued work. */\n  isContinuable: boolean;\n}\n\n/** The thread-status split every queue tray keys its affordances on. */\nexport function queueLaneFlags(status: DeepAgentThreadStatus): QueueLaneFlags {\n  return {\n    isRunning: status === 'running',\n    isContinuable: status === 'stopped' || status === 'error',\n  };\n}\n\nexport interface StatewireQueueRow {\n  item: StatewireThread.RunsQueueEntry;\n  lane: 'queue' | 'steer';\n}\n\n/**\n * The rows a queue tray renders, in dispatch order: stranded steer-lane\n * entries first (only while the thread rests continuable — during a run they\n * already render in the message list), then the queue lane.\n */\nexport function buildStatewireQueueRows(options: {\n  queue: readonly StatewireThread.RunsQueueEntry[];\n  steerQueue: readonly StatewireThread.RunsQueueEntry[];\n  isContinuable: boolean;\n}): StatewireQueueRow[] {\n  const { queue, steerQueue, isContinuable } = options;\n  return [\n    ...(isContinuable\n      ? steerQueue.map((item) => ({ item, lane: 'steer' as const }))\n      : []),\n    ...queue.map((item) => ({ item, lane: 'queue' as const })),\n  ];\n}\n\n/**\n * Whether a row offers \"Send now\": queue-lane rows only (steer entries already\n * dispatch first), every row while the thread rests continuable, and only the\n * head row while a run is live (later rows would jump the queue order).\n */\nexport function showQueueRowSendNow(options: {\n  lane: 'queue' | 'steer';\n  index: number;\n  isRunning: boolean;\n  isContinuable: boolean;\n}): boolean {\n  const { lane, index, isRunning, isContinuable } = options;\n  return lane === 'queue' && (isContinuable || (isRunning && index === 0));\n}\n\nexport type QueueEditCommand =\n  | { type: 'run/steer'; runId: string; message: StatewireThread.UserMessage }\n  | { type: 'run/enqueue'; runId: string; message: StatewireThread.UserMessage };\n\n/**\n * Re-send a queued entry under its own id on its own lane with edited text:\n * the host replaces the queued message's content in place, leaving its queue\n * position and lane untouched (a same-id send never dispatches). The built-in\n * queue client has no update command, so this goes straight to the runs\n * protocol. Returns `null` when there is nothing to send — blank or unchanged\n * text, or no live run entry to address.\n */\nexport function buildQueueEditCommand(options: {\n  item: StatewireThread.RunsQueueEntry;\n  lane: 'queue' | 'steer';\n  runId: string | null;\n  text: string;\n}): QueueEditCommand | null {\n  const { item, lane, runId, text } = options;\n  if (!text.trim() || text === queueEntryText(item.parts) || runId === null) {\n    return null;\n  }\n  const message: StatewireThread.UserMessage = {\n    id: item.id,\n    role: 'user',\n    parts: [{ type: 'text', text }, ...item.parts.filter((part) => part.type !== 'text')],\n    ...(item.metadata === undefined ? {} : { metadata: item.metadata }),\n  };\n  return lane === 'steer'\n    ? { type: 'run/steer', runId, message }\n    : { type: 'run/enqueue', runId, message };\n}\n\n/**\n * Grace between observing a stranded settle and auto-promoting the queue\n * head — long enough for the host's own settle bookkeeping (or a status flap\n * during reconnect) to resolve first, short enough to read as \"it just\n * continued\" rather than \"it hung\".\n */\nexport const QUEUE_AUTO_CONTINUE_DELAY_MS = 2_000;\n\n/** Whether the last cancellation marker records a user or client stop. */\nexport function userStopBlocksQueueAutoContinue(options: {\n  marker: string | undefined;\n  source: string | undefined;\n}): boolean {\n  return (\n    options.marker === ATHENA_RUN_MARKER_CANCELLED && !isServerUpdateStopSource(options.source)\n  );\n}\n\n/** `fate (cause)[: message]` — the detail a failed-send row carries. */\nexport function describeQueueSendFailure(\n  failure: StatewireThread.RunsFailedEntry['sendFailure'],\n): string {\n  const message =\n    'message' in failure && failure.message !== undefined ? `: ${failure.message}` : '';\n  return `${failure.fate} (${failure.cause})${message}`;\n}\n\n/**\n * Whether a `retryFailed` / `discardFailed` throw is the covered drop race:\n * statewire drops a failed entry on its own as soon as a canonical update\n * shows the message landed, and acting on a just-dropped entry throws. Both\n * the session record (\"unknown failed command\") and the adapter's projection\n * (\"unknown failed entry\") use this prefix. Nothing is lost in that race — the\n * message already made it and the row is about to disappear — so a tray\n * swallows it (keeping telemetry) instead of crashing the click handler.\n */\nexport function isFailedSendEntryRace(error: unknown): boolean {\n  return error instanceof Error && error.message.startsWith('statewire: unknown failed');\n}\n"],"names":["ATHENA_RUN_MARKER_CANCELLED","isServerUpdateStopSource"],"mappings":";;;AAsBO,SAAS,eACd,OACQ;AACR,SAAO,MACJ;AAAA,IAAQ,CAAC,SACR,KAAK,SAAS,UAAU,OAAO,KAAK,SAAS,WAAW,CAAC,KAAK,IAAI,IAAI,CAAA;AAAA,EAAC,EAExE,KAAK,MAAM;AAChB;AASO,SAAS,sBAAsB,OAAgD;AACpF,SAAO,MAAM,SAAS;AACxB;AAWO,SAAS,wBAAwB,KAAiC;AACvE,SAAO,MAAM,QAAQ,GAAG,IACpB,IAAI,OAAO,CAAC,OAAqB,OAAO,OAAO,QAAQ,IACvD,CAAA;AACN;AASO,SAAS,eAAe,QAA+C;AAC5E,SAAO;AAAA,IACL,WAAW,WAAW;AAAA,IACtB,eAAe,WAAW,aAAa,WAAW;AAAA,EAAA;AAEtD;AAYO,SAAS,wBAAwB,SAIhB;AACtB,QAAM,EAAE,OAAO,YAAY,cAAA,IAAkB;AAC7C,SAAO;AAAA,IACL,GAAI,gBACA,WAAW,IAAI,CAAC,UAAU,EAAE,MAAM,MAAM,UAAmB,IAC3D,CAAA;AAAA,IACJ,GAAG,MAAM,IAAI,CAAC,UAAU,EAAE,MAAM,MAAM,UAAmB;AAAA,EAAA;AAE7D;AAOO,SAAS,oBAAoB,SAKxB;AACV,QAAM,EAAE,MAAM,OAAO,WAAW,kBAAkB;AAClD,SAAO,SAAS,YAAY,iBAAkB,aAAa,UAAU;AACvE;AAcO,SAAS,sBAAsB,SAKV;AAC1B,QAAM,EAAE,MAAM,MAAM,OAAO,SAAS;AACpC,MAAI,CAAC,KAAK,KAAA,KAAU,SAAS,eAAe,KAAK,KAAK,KAAK,UAAU,MAAM;AACzE,WAAO;AAAA,EACT;AACA,QAAM,UAAuC;AAAA,IAC3C,IAAI,KAAK;AAAA,IACT,MAAM;AAAA,IACN,OAAO,CAAC,EAAE,MAAM,QAAQ,QAAQ,GAAG,KAAK,MAAM,OAAO,CAAC,SAAS,KAAK,SAAS,MAAM,CAAC;AAAA,IACpF,GAAI,KAAK,aAAa,SAAY,CAAA,IAAK,EAAE,UAAU,KAAK,SAAA;AAAA,EAAS;AAEnE,SAAO,SAAS,UACZ,EAAE,MAAM,aAAa,OAAO,QAAA,IAC5B,EAAE,MAAM,eAAe,OAAO,QAAA;AACpC;AAQO,MAAM,+BAA+B;AAGrC,SAAS,gCAAgC,SAGpC;AACV,SACE,QAAQ,WAAWA,SAAAA,+BAA+B,CAACC,SAAAA,yBAAyB,QAAQ,MAAM;AAE9F;AAGO,SAAS,yBACd,SACQ;AACR,QAAM,UACJ,aAAa,WAAW,QAAQ,YAAY,SAAY,KAAK,QAAQ,OAAO,KAAK;AACnF,SAAO,GAAG,QAAQ,IAAI,KAAK,QAAQ,KAAK,IAAI,OAAO;AACrD;AAWO,SAAS,sBAAsB,OAAyB;AAC7D,SAAO,iBAAiB,SAAS,MAAM,QAAQ,WAAW,2BAA2B;AACvF;;;;;;;;;;;;"}

package/dist/packages/agent-runtime/src/queue.js

@@ -0,0 +1,67 @@
+import { ATHENA_RUN_MARKER_CANCELLED, isServerUpdateStopSource } from "./messages.js";
+function queueEntryText(parts) {
+  return parts.flatMap(
+    (part) => part.type === "text" && typeof part.text === "string" ? [part.text] : []
+  ).join("\n\n");
+}
+function isQueueEntryUnsettled(entry) {
+  return entry.meta === void 0;
+}
+function readPrioritizedQueueIds(raw) {
+  return Array.isArray(raw) ? raw.filter((id) => typeof id === "string") : [];
+}
+function queueLaneFlags(status) {
+  return {
+    isRunning: status === "running",
+    isContinuable: status === "stopped" || status === "error"
+  };
+}
+function buildStatewireQueueRows(options) {
+  const { queue, steerQueue, isContinuable } = options;
+  return [
+    ...isContinuable ? steerQueue.map((item) => ({ item, lane: "steer" })) : [],
+    ...queue.map((item) => ({ item, lane: "queue" }))
+  ];
+}
+function showQueueRowSendNow(options) {
+  const { lane, index, isRunning, isContinuable } = options;
+  return lane === "queue" && (isContinuable || isRunning && index === 0);
+}
+function buildQueueEditCommand(options) {
+  const { item, lane, runId, text } = options;
+  if (!text.trim() || text === queueEntryText(item.parts) || runId === null) {
+    return null;
+  }
+  const message = {
+    id: item.id,
+    role: "user",
+    parts: [{ type: "text", text }, ...item.parts.filter((part) => part.type !== "text")],
+    ...item.metadata === void 0 ? {} : { metadata: item.metadata }
+  };
+  return lane === "steer" ? { type: "run/steer", runId, message } : { type: "run/enqueue", runId, message };
+}
+const QUEUE_AUTO_CONTINUE_DELAY_MS = 2e3;
+function userStopBlocksQueueAutoContinue(options) {
+  return options.marker === ATHENA_RUN_MARKER_CANCELLED && !isServerUpdateStopSource(options.source);
+}
+function describeQueueSendFailure(failure) {
+  const message = "message" in failure && failure.message !== void 0 ? `: ${failure.message}` : "";
+  return `${failure.fate} (${failure.cause})${message}`;
+}
+function isFailedSendEntryRace(error) {
+  return error instanceof Error && error.message.startsWith("statewire: unknown failed");
+}
+export {
+  QUEUE_AUTO_CONTINUE_DELAY_MS,
+  buildQueueEditCommand,
+  buildStatewireQueueRows,
+  describeQueueSendFailure,
+  isFailedSendEntryRace,
+  isQueueEntryUnsettled,
+  queueEntryText,
+  queueLaneFlags,
+  readPrioritizedQueueIds,
+  showQueueRowSendNow,
+  userStopBlocksQueueAutoContinue
+};
+//# sourceMappingURL=queue.js.map

package/dist/packages/agent-runtime/src/queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.js","sources":["../../../../../agent-runtime/src/queue.ts"],"sourcesContent":["/**\n * Derivations for the server-owned statewire queue and steer lanes, shared by\n * every queued-messages tray (Olympus, the React SDK, the Chrome extension).\n *\n * The queue is SERVER-owned: statewire surfaces it on the runs projection.\n * \"Send now\" moves an item into the steer lane (`run/steer` — the host stops\n * the run and dispatches it once the run settles; on a stopped/errored thread\n * the same move dispatches immediately as a stop-/error-continue run) and\n * remove issues `run/dequeue`. While the thread rests stopped/errored,\n * stranded steer-lane entries list ahead of the queue — they dispatch first,\n * as one batch, so they carry Remove but no per-row Send now.\n *\n * Pure helpers only: the host component reads `useStatewireRuns()` and\n * `useDeepAgentThreadStatus()` itself (both mockable per surface) and passes\n * the values in.\n */\n\nimport type { StatewireThread } from '@assistant-ui/react-statewire';\nimport { ATHENA_RUN_MARKER_CANCELLED, isServerUpdateStopSource } from './messages';\nimport type { DeepAgentThreadStatus } from './thread-status';\n\n/** The text content of a queued entry (non-text parts render as fallbacks). */\nexport function queueEntryText(\n  parts: readonly { type: string; text?: string }[],\n): string {\n  return parts\n    .flatMap((part) =>\n      part.type === 'text' && typeof part.text === 'string' ? [part.text] : [],\n    )\n    .join('\\n\\n');\n}\n\n/**\n * Whether a lane entry is still awaiting its send's settle: the host stamps\n * `meta` on every entry it admits (`_op_meta` — submitter and contextSync\n * snapshot), so a meta-less entry is this client's own optimistic fold. The\n * send is still in flight and can still be refused (billing gate, auth,\n * reconnect), which the tray must not render as an accepted queue position.\n */\nexport function isQueueEntryUnsettled(entry: StatewireThread.RunsQueueEntry): boolean {\n  return entry.meta === undefined;\n}\n\n/**\n * The ids of queued entries the user prioritized (⚡ — `run/prioritize`), as\n * the host records them in its durable `prioritizedQueueIds` state. A\n * prioritized entry heads the queue lane and the live run ends at its next\n * model-call boundary to deliver it, so trays render these rows lit and offer\n * \"Remove priority\" instead of \"Prioritize\". Tolerates the key being absent\n * (a thread that never prioritized, a pre-feature host) and ignores anything\n * that is not a string id.\n */\nexport function readPrioritizedQueueIds(raw: unknown): readonly string[] {\n  return Array.isArray(raw)\n    ? raw.filter((id): id is string => typeof id === 'string')\n    : [];\n}\n\nexport interface QueueLaneFlags {\n  isRunning: boolean;\n  /** A stopped/errored thread can continue with its queued work. */\n  isContinuable: boolean;\n}\n\n/** The thread-status split every queue tray keys its affordances on. */\nexport function queueLaneFlags(status: DeepAgentThreadStatus): QueueLaneFlags {\n  return {\n    isRunning: status === 'running',\n    isContinuable: status === 'stopped' || status === 'error',\n  };\n}\n\nexport interface StatewireQueueRow {\n  item: StatewireThread.RunsQueueEntry;\n  lane: 'queue' | 'steer';\n}\n\n/**\n * The rows a queue tray renders, in dispatch order: stranded steer-lane\n * entries first (only while the thread rests continuable — during a run they\n * already render in the message list), then the queue lane.\n */\nexport function buildStatewireQueueRows(options: {\n  queue: readonly StatewireThread.RunsQueueEntry[];\n  steerQueue: readonly StatewireThread.RunsQueueEntry[];\n  isContinuable: boolean;\n}): StatewireQueueRow[] {\n  const { queue, steerQueue, isContinuable } = options;\n  return [\n    ...(isContinuable\n      ? steerQueue.map((item) => ({ item, lane: 'steer' as const }))\n      : []),\n    ...queue.map((item) => ({ item, lane: 'queue' as const })),\n  ];\n}\n\n/**\n * Whether a row offers \"Send now\": queue-lane rows only (steer entries already\n * dispatch first), every row while the thread rests continuable, and only the\n * head row while a run is live (later rows would jump the queue order).\n */\nexport function showQueueRowSendNow(options: {\n  lane: 'queue' | 'steer';\n  index: number;\n  isRunning: boolean;\n  isContinuable: boolean;\n}): boolean {\n  const { lane, index, isRunning, isContinuable } = options;\n  return lane === 'queue' && (isContinuable || (isRunning && index === 0));\n}\n\nexport type QueueEditCommand =\n  | { type: 'run/steer'; runId: string; message: StatewireThread.UserMessage }\n  | { type: 'run/enqueue'; runId: string; message: StatewireThread.UserMessage };\n\n/**\n * Re-send a queued entry under its own id on its own lane with edited text:\n * the host replaces the queued message's content in place, leaving its queue\n * position and lane untouched (a same-id send never dispatches). The built-in\n * queue client has no update command, so this goes straight to the runs\n * protocol. Returns `null` when there is nothing to send — blank or unchanged\n * text, or no live run entry to address.\n */\nexport function buildQueueEditCommand(options: {\n  item: StatewireThread.RunsQueueEntry;\n  lane: 'queue' | 'steer';\n  runId: string | null;\n  text: string;\n}): QueueEditCommand | null {\n  const { item, lane, runId, text } = options;\n  if (!text.trim() || text === queueEntryText(item.parts) || runId === null) {\n    return null;\n  }\n  const message: StatewireThread.UserMessage = {\n    id: item.id,\n    role: 'user',\n    parts: [{ type: 'text', text }, ...item.parts.filter((part) => part.type !== 'text')],\n    ...(item.metadata === undefined ? {} : { metadata: item.metadata }),\n  };\n  return lane === 'steer'\n    ? { type: 'run/steer', runId, message }\n    : { type: 'run/enqueue', runId, message };\n}\n\n/**\n * Grace between observing a stranded settle and auto-promoting the queue\n * head — long enough for the host's own settle bookkeeping (or a status flap\n * during reconnect) to resolve first, short enough to read as \"it just\n * continued\" rather than \"it hung\".\n */\nexport const QUEUE_AUTO_CONTINUE_DELAY_MS = 2_000;\n\n/** Whether the last cancellation marker records a user or client stop. */\nexport function userStopBlocksQueueAutoContinue(options: {\n  marker: string | undefined;\n  source: string | undefined;\n}): boolean {\n  return (\n    options.marker === ATHENA_RUN_MARKER_CANCELLED && !isServerUpdateStopSource(options.source)\n  );\n}\n\n/** `fate (cause)[: message]` — the detail a failed-send row carries. */\nexport function describeQueueSendFailure(\n  failure: StatewireThread.RunsFailedEntry['sendFailure'],\n): string {\n  const message =\n    'message' in failure && failure.message !== undefined ? `: ${failure.message}` : '';\n  return `${failure.fate} (${failure.cause})${message}`;\n}\n\n/**\n * Whether a `retryFailed` / `discardFailed` throw is the covered drop race:\n * statewire drops a failed entry on its own as soon as a canonical update\n * shows the message landed, and acting on a just-dropped entry throws. Both\n * the session record (\"unknown failed command\") and the adapter's projection\n * (\"unknown failed entry\") use this prefix. Nothing is lost in that race — the\n * message already made it and the row is about to disappear — so a tray\n * swallows it (keeping telemetry) instead of crashing the click handler.\n */\nexport function isFailedSendEntryRace(error: unknown): boolean {\n  return error instanceof Error && error.message.startsWith('statewire: unknown failed');\n}\n"],"names":[],"mappings":";AAsBO,SAAS,eACd,OACQ;AACR,SAAO,MACJ;AAAA,IAAQ,CAAC,SACR,KAAK,SAAS,UAAU,OAAO,KAAK,SAAS,WAAW,CAAC,KAAK,IAAI,IAAI,CAAA;AAAA,EAAC,EAExE,KAAK,MAAM;AAChB;AASO,SAAS,sBAAsB,OAAgD;AACpF,SAAO,MAAM,SAAS;AACxB;AAWO,SAAS,wBAAwB,KAAiC;AACvE,SAAO,MAAM,QAAQ,GAAG,IACpB,IAAI,OAAO,CAAC,OAAqB,OAAO,OAAO,QAAQ,IACvD,CAAA;AACN;AASO,SAAS,eAAe,QAA+C;AAC5E,SAAO;AAAA,IACL,WAAW,WAAW;AAAA,IACtB,eAAe,WAAW,aAAa,WAAW;AAAA,EAAA;AAEtD;AAYO,SAAS,wBAAwB,SAIhB;AACtB,QAAM,EAAE,OAAO,YAAY,cAAA,IAAkB;AAC7C,SAAO;AAAA,IACL,GAAI,gBACA,WAAW,IAAI,CAAC,UAAU,EAAE,MAAM,MAAM,UAAmB,IAC3D,CAAA;AAAA,IACJ,GAAG,MAAM,IAAI,CAAC,UAAU,EAAE,MAAM,MAAM,UAAmB;AAAA,EAAA;AAE7D;AAOO,SAAS,oBAAoB,SAKxB;AACV,QAAM,EAAE,MAAM,OAAO,WAAW,kBAAkB;AAClD,SAAO,SAAS,YAAY,iBAAkB,aAAa,UAAU;AACvE;AAcO,SAAS,sBAAsB,SAKV;AAC1B,QAAM,EAAE,MAAM,MAAM,OAAO,SAAS;AACpC,MAAI,CAAC,KAAK,KAAA,KAAU,SAAS,eAAe,KAAK,KAAK,KAAK,UAAU,MAAM;AACzE,WAAO;AAAA,EACT;AACA,QAAM,UAAuC;AAAA,IAC3C,IAAI,KAAK;AAAA,IACT,MAAM;AAAA,IACN,OAAO,CAAC,EAAE,MAAM,QAAQ,QAAQ,GAAG,KAAK,MAAM,OAAO,CAAC,SAAS,KAAK,SAAS,MAAM,CAAC;AAAA,IACpF,GAAI,KAAK,aAAa,SAAY,CAAA,IAAK,EAAE,UAAU,KAAK,SAAA;AAAA,EAAS;AAEnE,SAAO,SAAS,UACZ,EAAE,MAAM,aAAa,OAAO,QAAA,IAC5B,EAAE,MAAM,eAAe,OAAO,QAAA;AACpC;AAQO,MAAM,+BAA+B;AAGrC,SAAS,gCAAgC,SAGpC;AACV,SACE,QAAQ,WAAW,+BAA+B,CAAC,yBAAyB,QAAQ,MAAM;AAE9F;AAGO,SAAS,yBACd,SACQ;AACR,QAAM,UACJ,aAAa,WAAW,QAAQ,YAAY,SAAY,KAAK,QAAQ,OAAO,KAAK;AACnF,SAAO,GAAG,QAAQ,IAAI,KAAK,QAAQ,KAAK,IAAI,OAAO;AACrD;AAWO,SAAS,sBAAsB,OAAyB;AAC7D,SAAO,iBAAiB,SAAS,MAAM,QAAQ,WAAW,2BAA2B;AACvF;"}

package/dist/packages/agent-runtime/src/quota-safe-local-storage-session.cjs

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const tap = require("@assistant-ui/tap");
+const storage = require("statewire/storage");
+const react = require("react");
+const SESSION_PREFIX = "aui:statewire-session:";
+const SESSION_LOCK_PREFIX = "aui:statewire-session-lock:";
+const SESSION_ACTIVE_PREFIX = "aui:statewire-session-active:";
+const LEGACY_PROTOCOL = { name: "athena", version: "2026-09-07" };
+const DAY_MS = 24 * 60 * 60 * 1e3;
+const READABLE_STORAGE_VERSIONS = /* @__PURE__ */ new Set([1, 2]);
+const browserGlobals = globalThis;
+function readPersistedFailedSendStamps(sessionKey) {
+  const storage2 = browserGlobals.localStorage;
+  if (!storage2) return null;
+  let record;
+  try {
+    const raw = storage2.getItem(SESSION_PREFIX + sessionKey);
+    record = raw === null ? null : JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  return readFailedSendStampsFromRecord(record);
+}
+function readFailedSendStampsFromRecord(record) {
+  var _a, _b, _c;
+  if (!record || typeof record !== "object") return null;
+  const stamps = /* @__PURE__ */ new Map();
+  if (!Array.isArray(record.failed)) return stamps;
+  for (const entry of record.failed) {
+    const failed = entry;
+    const messageId = (_c = (_b = (_a = failed == null ? void 0 : failed.params) == null ? void 0 : _a[0]) == null ? void 0 : _b.message) == null ? void 0 : _c.id;
+    if (typeof messageId === "string" && typeof (failed == null ? void 0 : failed.ts) === "number") {
+      stamps.set(messageId, failed.ts);
+    }
+  }
+  return stamps;
+}
+function isStorageQuotaError(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const { name, code, message } = error;
+  return name === "QuotaExceededError" || name === "NS_ERROR_DOM_QUOTA_REACHED" || code === 22 || code === 1014 || typeof message === "string" && /exceeded the quota|quotaexceedederror|ns_error_dom_quota_reached/i.test(
+    message
+  );
+}
+function asStatewireQuotaError(error) {
+  if (error instanceof Error && error.name === "QuotaExceededError")
+    return error;
+  const normalized = new Error(
+    error instanceof Error ? error.message : "storage quota exceeded"
+  );
+  normalized.name = "QuotaExceededError";
+  return normalized;
+}
+function unreadableRecord(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    return error instanceof Error ? error : new Error("stored session record is not JSON");
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return new Error("stored session record is not an object");
+  }
+  const version = parsed.statewireStorageVersion;
+  if (version !== void 0 && !READABLE_STORAGE_VERSIONS.has(version)) {
+    return new Error(
+      `stored session record uses storage version ${String(version)}`
+    );
+  }
+  return void 0;
+}
+function browserBackend({
+  storage: storage2,
+  locks
+}) {
+  return {
+    getItem: (key) => storage2.getItem(key),
+    setItem: (key, value) => storage2.setItem(key, value),
+    removeItem: (key) => storage2.removeItem(key),
+    getAllKeys: () => Array.from(
+      { length: storage2.length },
+      (_, index) => storage2.key(index)
+    ).filter((key) => key !== null),
+    withUnused: async (key, action) => {
+      await locks.request(
+        SESSION_ACTIVE_PREFIX + key,
+        { ifAvailable: true },
+        async (active) => {
+          if (active === null) return;
+          await locks.request(
+            SESSION_LOCK_PREFIX + key.slice(SESSION_PREFIX.length),
+            { ifAvailable: true },
+            async (lock) => {
+              if (lock === null) return;
+              await action();
+            }
+          );
+        }
+      );
+    }
+  };
+}
+function quotaTolerantBackend({
+  inner,
+  onDegraded
+}) {
+  const quotaSurfaced = /* @__PURE__ */ new Set();
+  const overlay = /* @__PURE__ */ new Map();
+  const shielded = /* @__PURE__ */ new Set();
+  const checked = /* @__PURE__ */ new Map();
+  const readable = (key, raw) => {
+    const previous = checked.get(key);
+    if (previous !== void 0 && previous.raw === raw) return previous.verdict;
+    const verdict = unreadableRecord(raw);
+    checked.set(key, { raw, verdict });
+    return verdict;
+  };
+  return {
+    getItem: (key) => {
+      const shadowed = overlay.get(key);
+      if (shadowed !== void 0) return shadowed;
+      if (shielded.has(key)) return null;
+      let raw;
+      try {
+        raw = inner.getItem(key);
+      } catch (error) {
+        shielded.add(key);
+        onDegraded({ operation: "getItem", key, error });
+        return null;
+      }
+      if (raw === null) return null;
+      const unreadable = readable(key, raw);
+      if (unreadable === void 0) return raw;
+      shielded.add(key);
+      onDegraded({ operation: "record", key, error: unreadable });
+      return null;
+    },
+    setItem: (key, value) => {
+      if (shielded.has(key)) {
+        overlay.set(key, value);
+        return;
+      }
+      try {
+        inner.setItem(key, value);
+        overlay.delete(key);
+        quotaSurfaced.delete(key);
+      } catch (error) {
+        if (isStorageQuotaError(error) && !quotaSurfaced.has(key)) {
+          quotaSurfaced.add(key);
+          throw asStatewireQuotaError(error);
+        }
+        overlay.set(key, value);
+        onDegraded({ operation: "setItem", key, error });
+      }
+    },
+    removeItem: (key) => {
+      overlay.delete(key);
+      if (shielded.has(key)) return;
+      try {
+        inner.removeItem(key);
+      } catch (error) {
+        onDegraded({ operation: "removeItem", key, error });
+      }
+    },
+    getAllKeys: () => {
+      const keys = new Set(overlay.keys());
+      try {
+        for (const key of inner.getAllKeys()) keys.add(key);
+      } catch (error) {
+        onDegraded({ operation: "getAllKeys", key: "", error });
+      }
+      return [...keys];
+    },
+    withUnused: async (key, action) => {
+      try {
+        await inner.withUnused(key, action);
+      } catch (error) {
+        onDegraded({ operation: "withUnused", key, error });
+      }
+    }
+  };
+}
+const sharedBackends = /* @__PURE__ */ new WeakMap();
+function sharedBackend({
+  storage: storage2,
+  locks
+}) {
+  let shared = sharedBackends.get(storage2);
+  if (shared === void 0) {
+    const listeners = /* @__PURE__ */ new Set();
+    shared = {
+      listeners,
+      backend: quotaTolerantBackend({
+        inner: browserBackend({ storage: storage2, locks }),
+        onDegraded: (degradation) => {
+          for (const listener of listeners) listener(degradation);
+        }
+      })
+    };
+    sharedBackends.set(storage2, shared);
+  }
+  return shared;
+}
+const useQuotaSafeLocalStorageSession = ({
+  threadId,
+  key = (id) => id,
+  ttl = 7 * DAY_MS,
+  max = 50,
+  onStorageDegraded
+}) => {
+  var _a;
+  const storage$1 = browserGlobals.localStorage;
+  const locks = (_a = browserGlobals.navigator) == null ? void 0 : _a.locks;
+  if (!storage$1)
+    throw new Error(
+      "statewire: QuotaSafeLocalStorageSession requires localStorage"
+    );
+  if (!locks)
+    throw new Error(
+      "statewire: QuotaSafeLocalStorageSession requires the Web Locks API (navigator.locks)"
+    );
+  const sessionKey = key(threadId);
+  const storageKey = SESSION_PREFIX + sessionKey;
+  const lockName = SESSION_LOCK_PREFIX + sessionKey;
+  const latestOnDegraded = react.useRef(onStorageDegraded);
+  latestOnDegraded.current = onStorageDegraded;
+  const reportDegradation = react.useMemo(() => {
+    const reported = /* @__PURE__ */ new Set();
+    return (degradation) => {
+      const handler = latestOnDegraded.current;
+      if (handler) {
+        try {
+          handler(degradation);
+        } catch {
+        }
+        return;
+      }
+      const dedupeKey = `${degradation.operation}:${degradation.key}`;
+      if (reported.has(dedupeKey)) return;
+      reported.add(dedupeKey);
+      console.warn(
+        `[statewire] session storage degraded to memory only (${degradation.operation} ${degradation.key})`,
+        degradation.error
+      );
+    };
+  }, []);
+  const shared = sharedBackend({ storage: storage$1, locks });
+  shared.listeners.add(reportDegradation);
+  react.useEffect(() => {
+    shared.listeners.add(reportDegradation);
+    return () => {
+      shared.listeners.delete(reportDegradation);
+    };
+  }, [shared, reportDegradation]);
+  react.useEffect(() => {
+    let release;
+    let disposed = false;
+    Promise.resolve(
+      locks.request(
+        SESSION_ACTIVE_PREFIX + storageKey,
+        { mode: "shared" },
+        () => {
+          if (disposed) return;
+          return new Promise((resolve) => {
+            release = resolve;
+          });
+        }
+      )
+    ).catch(
+      (error) => reportDegradation({ operation: "lock", key: storageKey, error })
+    );
+    return () => {
+      disposed = true;
+      release == null ? void 0 : release();
+    };
+  }, [locks, storageKey, reportDegradation]);
+  const sessionStorage = tap.useResource(
+    storage.KeyValueSessionStorage({
+      backend: shared.backend,
+      key: sessionKey,
+      namespace: SESSION_PREFIX,
+      legacyProtocol: LEGACY_PROTOCOL,
+      retention: { maxAgeMs: ttl, maxEntries: max },
+      // A failure statewire raises itself (a structurally invalid stored
+      // record) still stops the session; it is at least reported the same way.
+      onError: (error) => reportDegradation({ operation: "session", key: storageKey, error })
+    })
+  );
+  return react.useMemo(
+    () => ({
+      ...sessionStorage,
+      lock: async (fn) => {
+        let granted = false;
+        try {
+          return await locks.request(lockName, async () => {
+            granted = true;
+            return fn();
+          });
+        } catch (error) {
+          if (granted) throw error;
+          reportDegradation({ operation: "lock", key: storageKey, error });
+          return fn();
+        }
+      },
+      subscribe: (listener) => {
+        var _a2;
+        const onStorage = (event) => {
+          if (event.key === storageKey) listener();
+        };
+        (_a2 = browserGlobals.addEventListener) == null ? void 0 : _a2.call(browserGlobals, "storage", onStorage);
+        return () => {
+          var _a3;
+          return (_a3 = browserGlobals.removeEventListener) == null ? void 0 : _a3.call(browserGlobals, "storage", onStorage);
+        };
+      }
+    }),
+    [sessionStorage, locks, storageKey, lockName, reportDegradation]
+  );
+};
+const QuotaSafeLocalStorageSession = tap.resource(
+  useQuotaSafeLocalStorageSession
+);
+exports.QuotaSafeLocalStorageSession = QuotaSafeLocalStorageSession;
+exports.isStorageQuotaError = isStorageQuotaError;
+exports.quotaTolerantBackend = quotaTolerantBackend;
+exports.readFailedSendStampsFromRecord = readFailedSendStampsFromRecord;
+exports.readPersistedFailedSendStamps = readPersistedFailedSendStamps;
+//# sourceMappingURL=quota-safe-local-storage-session.cjs.map