@athenaintel/react 0.41.3 → 0.42.2

package/dist/agent-runtime/src/running-tool-placeholder.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The backend's running-tool placeholder: the ToolMessage a long-running tool's
+ * card shows until the tool returns — a `task` subagent's live transcript, a
+ * tool's preliminary result (Studio and Python execution progress, deep
+ * research, image descriptions, drive indexing, AOP progress), or a
+ * programmatic-tool-calling execution's sub-call log. Agora's
+ * `running_tool_placeholder` builds all three: id `tool-running-<tool_call_id>`
+ * and `additional_kwargs.streaming`. The tool's real ToolMessage replaces it by
+ * `tool_call_id`, with its own id and no such flag.
+ *
+ * A placeholder is a `tool` message, so its mere presence gives the call a
+ * defined `result`: read the flag before counting a call as done.
+ *
+ * Self-contained on purpose: the message converter imports it, so whatever it
+ * imports ships in every surface's startup bundle (the Office pane's startup
+ * budget has no room for `tool-result.ts`, which only tool cards need).
+ */
+/** Whether a raw wire message is a running tool's placeholder rather than its result. */
+export declare function isRunningToolPlaceholder(message: unknown): boolean;
+/**
+ * Whether a converted tool-call part's `artifact` comes from a running tool's
+ * placeholder: the converter lifts a ToolMessage's `additional_kwargs` into
+ * `artifact._tool_message_metadata`, the marker included.
+ */
+export declare function isRunningToolPlaceholderArtifact(artifact: unknown): boolean;

package/dist/agent-runtime/src/running-tool-placeholder.js

@@ -0,0 +1,11 @@
+const RUNNING_PLACEHOLDER_KWARG = "streaming";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function isRunningToolPlaceholderArtifact(artifact) {
+  if (!isRecord(artifact)) return false;
+  const metadata = artifact._tool_message_metadata;
+  return isRecord(metadata) && metadata[RUNNING_PLACEHOLDER_KWARG] === true;
+}
+export {
+  isRunningToolPlaceholderArtifact
+};
+//# sourceMappingURL=running-tool-placeholder.js.map

package/dist/agent-runtime/src/running-tool-placeholder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"running-tool-placeholder.js","sources":["../../../../agent-runtime/src/running-tool-placeholder.ts"],"sourcesContent":["/**\n * The backend's running-tool placeholder: the ToolMessage a long-running tool's\n * card shows until the tool returns — a `task` subagent's live transcript, a\n * tool's preliminary result (Studio and Python execution progress, deep\n * research, image descriptions, drive indexing, AOP progress), or a\n * programmatic-tool-calling execution's sub-call log. Agora's\n * `running_tool_placeholder` builds all three: id `tool-running-<tool_call_id>`\n * and `additional_kwargs.streaming`. The tool's real ToolMessage replaces it by\n * `tool_call_id`, with its own id and no such flag.\n *\n * A placeholder is a `tool` message, so its mere presence gives the call a\n * defined `result`: read the flag before counting a call as done.\n *\n * Self-contained on purpose: the message converter imports it, so whatever it\n * imports ships in every surface's startup bundle (the Office pane's startup\n * budget has no room for `tool-result.ts`, which only tool cards need).\n */\n\nconst RUNNING_PLACEHOLDER_KWARG = 'streaming';\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value);\n\n/** Whether a raw wire message is a running tool's placeholder rather than its result. */\nexport function isRunningToolPlaceholder(message: unknown): boolean {\n  if (!isRecord(message) || message.type !== 'tool') return false;\n  const kwargs = message.additional_kwargs;\n  return isRecord(kwargs) && kwargs[RUNNING_PLACEHOLDER_KWARG] === true;\n}\n\n/**\n * Whether a converted tool-call part's `artifact` comes from a running tool's\n * placeholder: the converter lifts a ToolMessage's `additional_kwargs` into\n * `artifact._tool_message_metadata`, the marker included.\n */\nexport function isRunningToolPlaceholderArtifact(artifact: unknown): boolean {\n  if (!isRecord(artifact)) return false;\n  const metadata = artifact._tool_message_metadata;\n  return isRecord(metadata) && metadata[RUNNING_PLACEHOLDER_KWARG] === true;\n}\n"],"names":[],"mappings":"AAkBA,MAAM,4BAA4B;AAElC,MAAM,WAAW,CAAC,UAChB,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAc9D,SAAS,iCAAiC,UAA4B;AAC3E,MAAI,CAAC,SAAS,QAAQ,EAAG,QAAO;AAChC,QAAM,WAAW,SAAS;AAC1B,SAAO,SAAS,QAAQ,KAAK,SAAS,yBAAyB,MAAM;AACvE;"}

package/dist/agent-runtime/src/runtime-messages.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Typed runtime messages — the one description of "the runtime ended this run"
+ * that every chat surface renders from.
+ *
+ * The deep-agent backend records how a run ended in two shapes that ride
+ * ordinary `ai` messages (a new LangChain message type would crash the shipped
+ * converter, whose convertible set is closed):
+ *
+ * - a **run-lifecycle marker** (`athena_run_marker`: `cancelled` / `failed`,
+ *   plus `athena_run_marker_source`) — see {@link readRunMarkerFromSourceMessages};
+ * - a **handoff message** (`athena_handoff: true`) — the closing summary the
+ *   runtime asked the model to write when a guard or the step budget ended the
+ *   run, instead of fabricating an internal sentence.
+ *
+ * Both now carry the canonical `athena_termination_reason`
+ * (`agora/graphs/athena_deep_agent/termination.py`). This module reads all of
+ * that into one {@link AthenaRuntimeMessage} so Olympus, mobile, the Chrome
+ * extension, and the Office add-in agree on kind, severity, copy, and the
+ * sole-vs-grouped distinction — the last of which is load-bearing: a marker
+ * appended after the assistant's own work is chunked into that message, and
+ * replacing the whole row would hide completed prose and tool cards.
+ */
+import { getExternalStoreMessages } from '@assistant-ui/core';
+/** The backend's canonical reason vocabulary (`KNOWN_TERMINATION_REASONS`). */
+export declare const TERMINATION_REASONS: readonly ['completed', 'user_stop', 'send_now', 'voice_steer', 'transport_cancel', 'pod_drain', 'fence_lost', 'instance_closed', 'unattributed_stop', 'recursion_limit', 'step_budget', 'duplicate_call_guard', 'synthetic_stop', 'ended_after_tools', 'error', 'model_refusal', 'abandoned'];
+export type AthenaTerminationReason = (typeof TERMINATION_REASONS)[number];
+/**
+ * How a runtime ending renders:
+ * - `stopped` — a cancellation the user (or a client action) asked for;
+ * - `paused` — a pod-drain pause; the run resumes from its checkpoint;
+ * - `failed` — the graph raised, hit the recursion limit, or was abandoned;
+ * - `handoff` — the runtime ended the run and the model wrote a closing
+ *   summary (the message text), which renders as prose under a banner.
+ */
+export type AthenaRuntimeMessageKind = 'stopped' | 'paused' | 'failed' | 'handoff';
+export type AthenaRuntimeMessageSeverity = 'info' | 'warning' | 'error';
+export interface TerminationDescription {
+    /** Short label for the banner / status row. */
+    title: string;
+    /** One sentence of reason-specific explanation, when it adds information. */
+    detail: string | undefined;
+}
+export interface AthenaRuntimeMessage {
+    kind: AthenaRuntimeMessageKind;
+    /** Canonical reason (may be a value newer than this client knows). */
+    reason: string | undefined;
+    severity: AthenaRuntimeMessageSeverity;
+    title: string;
+    detail: string | undefined;
+    /** The message's own text: a marker's backend copy, or the handoff summary. */
+    text: string | undefined;
+    /**
+     * A `send_now` promotion cancels the live run as plumbing, not as a
+     * user-visible stop: keep it in the data, paint nothing.
+     */
+    silent: boolean;
+    /**
+     * True when the runtime message is the ONLY source message behind this
+     * thread message (it owns the whole row). False when the chunk also holds
+     * the assistant's own work, which must keep rendering.
+     */
+    isSoleSourceMessage: boolean;
+}
+/**
+ * Copy for a runtime ending. Reasons this client does not know fall back to
+ * the kind's generic title, so a newer backend never renders as an empty row.
+ */
+export declare function describeTerminationReason(kind: AthenaRuntimeMessageKind, reason: string | undefined): TerminationDescription;
+type Kwargs = Record<string, unknown> | undefined;
+/** The termination reason stamped on `additional_kwargs` (top-level or mirror). */
+export declare function readTerminationReason(kwargs: Kwargs): string | undefined;
+/**
+ * Read the runtime ending behind a thread message, from its bound source
+ * messages first (a marker or handoff chunked after the assistant's own turn
+ * is never the first source, so the joined `metadata.custom` would miss it —
+ * see {@link readRunMarkerFromSourceMessages}), then from joined metadata for
+ * surfaces without bound sources.
+ */
+export declare function readRuntimeMessageFromSourceMessages(message: Parameters<typeof getExternalStoreMessages>[0] & {
+    metadata?: {
+        custom?: Record<string, unknown> | undefined;
+    } | undefined;
+    content?: unknown;
+}): AthenaRuntimeMessage | undefined;
+/**
+ * The backend marker copy worth showing under a runtime card, or `undefined`.
+ *
+ * A failure marker's text carries the specific error ("The run failed:
+ * provider returned 502"), so it is shown when no reason-specific detail
+ * exists. Stop/pause copy only restates the title, and a handoff's text is the
+ * message body itself, so neither is repeated. Marker copy leads with an emoji
+ * for raw-transcript readers; the card's icon plays that role, so it is
+ * stripped. Shared by every presenter so mobile and DOM cannot drift.
+ */
+export declare function runtimeMessageMarkerText(message: AthenaRuntimeMessage): string | undefined;
+/**
+ * The runtime message's kind when it owns the whole row, else `undefined`.
+ *
+ * Returns a primitive so it is safe as a `useAuiState` selector (the reader
+ * above builds a fresh object per call; an object snapshot would loop the
+ * render under `Object.is` comparison).
+ */
+export declare function readSoleRuntimeMessageKind(message: Parameters<typeof readRuntimeMessageFromSourceMessages>[0]): AthenaRuntimeMessageKind | undefined;
+export {};

package/dist/agent-runtime/src/screen-point.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Screen points: the agent's on-screen coordinates as structured, renderable
+ * data.
+ *
+ * Browser agents already speak in `[x, y]` pairs — the `coordinate` argument
+ * of `chrome_computer` / `device_computer` / `computer` is a pixel in the
+ * screenshot the model was shown. In prose those pairs arrive as free text
+ * ("Delete at ~(1038, 81)"), which no surface can render as anything but
+ * characters. A screen point is that same pair written as a markdown link
+ * whose destination carries the pair *and the dimensions of the screenshot it
+ * was read from*:
+ *
+ *   [Delete](athena-point://screenshot?x=1038&y=81&w=1280&h=720&tab=8811)
+ *
+ * The agent keeps its native vocabulary (the coordinate it already has, the
+ * screenshot size it was told) and does no arithmetic; every chat surface
+ * that understands the scheme renders the link as a chip and, because the
+ * basis dimensions travel with the point, can place a marker at the right
+ * relative spot on any later rendition of that screenshot however the
+ * transcript is laid out or the user's window is resized. Surfaces that do
+ * not understand the scheme show the label as plain text (a link with an
+ * unknown protocol), which is exactly the prose we have today — the format
+ * degrades to the status quo, never below it.
+ *
+ * Pure string and number work, UI-library-free, shared by every chat surface
+ * (Olympus, the React SDK hosts, the Chrome extension side panel) so a point
+ * that is valid on one surface is valid on all of them.
+ */
+/** URL scheme of a screen-point link. */
+export declare const SCREEN_POINT_PROTOCOL = "athena-point:";
+/** Host of a screen-point link: the coordinate space the pair lives in. */
+export declare const SCREEN_POINT_HOST = "screenshot";
+/** `href.startsWith(SCREEN_POINT_HREF_PREFIX)` is the cheap pre-check every renderer runs. */
+export declare const SCREEN_POINT_HREF_PREFIX = "athena-point://";
+/**
+ * The largest coordinate or dimension a point may carry. No screenshot the
+ * runtime delivers approaches this; anything larger is a typo or a unit mix-up.
+ */
+export declare const SCREEN_POINT_MAX_EXTENT = 32767;
+/**
+ * The model-facing CUA screenshot size the Chrome extension emits by default
+ * (`athena-in-chrome/extension/src/background.ts`, `CHROME_DEFAULT_WIDTH` /
+ * `CHROME_DEFAULT_HEIGHT` in `chrome_browser_tools.py`). Surfaces may offer
+ * it as the fallback basis for a point that omits `w`/`h`, clearly labelled
+ * as assumed.
+ */
+export declare const DEFAULT_CUA_SCREENSHOT_SIZE: {
+    readonly width: 1280;
+    readonly height: 720;
+};
+/** Width and height of a coordinate space, in that space's pixels. */
+export interface ScreenSize {
+    width: number;
+    height: number;
+}
+/**
+ * A point in screenshot space. `basis` is the size of the screenshot the pair
+ * was read from; `null` when the link omitted it, in which case the point can
+ * be shown but not placed. `tabId` is the Chrome tab the screenshot came from
+ * when the agent had one.
+ */
+export interface ScreenPoint {
+    x: number;
+    y: number;
+    basis: ScreenSize | null;
+    tabId: number | null;
+}
+/**
+ * Why a link that starts with the scheme could not become a point. Rendered
+ * surfaces show the label as text with the reason in a tooltip, so a broken
+ * link never becomes an interactive marker that points nowhere.
+ */
+export type ScreenPointParseError = "not-screen-point" | "missing-coordinate" | "non-finite-number" | "negative-number" | "degenerate-basis" | "out-of-bounds" | "extent-too-large";
+export type ScreenPointParseResult = {
+    ok: true;
+    point: ScreenPoint;
+} | {
+    ok: false;
+    error: ScreenPointParseError;
+};
+/** Whether `href` is a screen-point link at all (the cheap pre-check). */
+export declare function isScreenPointHref(href: string | null | undefined): href is string;
+/**
+ * Parse a screen-point link. Accepts the canonical form
+ * `athena-point://screenshot?x=…&y=…&w=…&h=…&tab=…` and tolerates what a
+ * model plausibly writes instead: `width`/`height` for `w`/`h`, `tab_id` for
+ * `tab`, decimals, a leading `~`, and an empty or different host. Rejects,
+ * with a reason, anything that would place a marker in the wrong spot:
+ * non-finite or negative numbers, a zero or negative basis, a point outside
+ * its basis, and absurd extents.
+ */
+export declare function parseScreenPointHref(href: string | null | undefined): ScreenPointParseResult;
+/** The canonical link for a point — what the prompt teaches the agent to write. */
+export declare function serializeScreenPointHref(point: ScreenPoint): string;
+/**
+ * Where the point sits as a fraction of its basis, `0..1` on each axis, or
+ * `null` when the point has no basis to be relative to. This is the only
+ * number a renderer needs: `left: ${fx * 100}%` places the marker on any
+ * rendition of the screenshot, whatever size it is drawn at.
+ */
+export declare function screenPointFraction(point: ScreenPoint): {
+    fx: number;
+    fy: number;
+} | null;
+/** Whether two sizes are the same to within the few-pixel jitter a resize or scrollbar introduces. */
+export declare function sameScreenSize({ a, b, tolerancePx, }: {
+    a: ScreenSize;
+    b: ScreenSize;
+    tolerancePx?: number;
+}): boolean;
+/**
+ * How a point's basis relates to the screenshot it is about to be drawn on.
+ * Mirrors the runtime's dispatch contract (`browser_coordinate_contract.json`):
+ * the same size or a few pixels of jitter is `identity`; a uniform ratio on
+ * both axes (browser zoom, a resized window at the same aspect) is
+ * `uniform-scale` and the fraction still lands on the same element; anything
+ * else is a `mismatch` — a different aspect ratio means the screenshot shows a
+ * different framing (chrome headroom, a rotated device, a different tab) and
+ * a fraction placed on it would point at the wrong thing.
+ */
+export type ScreenBasisFit = {
+    kind: "identity";
+} | {
+    kind: "uniform-scale";
+    scale: number;
+} | {
+    kind: "mismatch";
+    aspectDelta: number;
+};
+export declare function fitScreenBasis({ basis, target, aspectTolerance, }: {
+    basis: ScreenSize;
+    target: ScreenSize;
+    aspectTolerance?: number;
+}): ScreenBasisFit;
+/** Human-readable point for tooltips and accessible names: `(1038, 81) in a 1280×720 screenshot`. */
+export declare function formatScreenPoint(point: ScreenPoint): string;
+/** The sentence a surface shows for a link that failed to parse. */
+export declare function describeScreenPointError(error: ScreenPointParseError): string;
+/**
+ * Screen points written into a text block, in order. Used by surfaces that
+ * work on the raw markdown (the static message body's node parser, the
+ * extension's plain-text composer) and by tests. Only the link form is
+ * recognised — a bare `(1038, 81)` in prose is text, never a point, so a
+ * model that was not taught the scheme changes nothing.
+ */
+export declare function findScreenPointLinks(text: string): Array<{
+    start: number;
+    end: number;
+    label: string;
+    href: string;
+}>;

package/dist/agent-runtime/src/sealed-idb.cjs

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const idbGlobals = globalThis;
+const SEALED_IV_BYTES = 12;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+async function sha256Hex(value) {
+  const digest = await crypto.subtle.digest("SHA-256", encoder.encode(value));
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function sealJson({
+  key,
+  value,
+  aad
+}) {
+  const iv = crypto.getRandomValues(new Uint8Array(SEALED_IV_BYTES));
+  const ciphertext = new Uint8Array(
+    await crypto.subtle.encrypt(
+      { name: "AES-GCM", iv, additionalData: encoder.encode(aad) },
+      key,
+      encoder.encode(JSON.stringify(value))
+    )
+  );
+  const sealed = new Uint8Array(SEALED_IV_BYTES + ciphertext.byteLength);
+  sealed.set(iv, 0);
+  sealed.set(ciphertext, SEALED_IV_BYTES);
+  return sealed;
+}
+async function openJson({
+  key,
+  sealed,
+  aad
+}) {
+  const iv = sealed.subarray(0, SEALED_IV_BYTES);
+  const plaintext = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv, additionalData: encoder.encode(aad) },
+    key,
+    sealed.subarray(SEALED_IV_BYTES)
+  );
+  return JSON.parse(decoder.decode(plaintext));
+}
+function requestToPromise(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
+  });
+}
+function transactionDone(tx) {
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onabort = () => reject(tx.error ?? new Error("IndexedDB transaction aborted"));
+    tx.onerror = () => reject(tx.error ?? new Error("IndexedDB transaction failed"));
+  });
+}
+function openSealedDatabase({
+  factory,
+  name,
+  version,
+  upgrade
+}) {
+  return new Promise((resolve) => {
+    try {
+      const request = factory.open(name, version);
+      request.onupgradeneeded = () => upgrade(request.result);
+      request.onsuccess = () => {
+        const db = request.result;
+        db.onversionchange = () => db.close();
+        resolve(db);
+      };
+      request.onerror = () => resolve(null);
+      request.onblocked = () => resolve(null);
+    } catch {
+      resolve(null);
+    }
+  });
+}
+function lazySealedDatabase({
+  factory,
+  name,
+  version,
+  upgrade
+}) {
+  let databasePromise = null;
+  return () => {
+    if (!factory || typeof crypto === "undefined" || !crypto.subtle) return Promise.resolve(null);
+    databasePromise ?? (databasePromise = openSealedDatabase({ factory, name, version, upgrade }).then(
+      (db) => {
+        if (db) {
+          const forget = () => {
+            databasePromise = null;
+          };
+          db.addEventListener("versionchange", forget);
+          db.addEventListener("close", forget);
+        } else {
+          databasePromise = null;
+        }
+        return db;
+      }
+    ));
+    return databasePromise;
+  };
+}
+exports.SEALED_IV_BYTES = SEALED_IV_BYTES;
+exports.idbGlobals = idbGlobals;
+exports.lazySealedDatabase = lazySealedDatabase;
+exports.openJson = openJson;
+exports.openSealedDatabase = openSealedDatabase;
+exports.requestToPromise = requestToPromise;
+exports.sealJson = sealJson;
+exports.sha256Hex = sha256Hex;
+exports.transactionDone = transactionDone;
+//# sourceMappingURL=sealed-idb.cjs.map

package/dist/agent-runtime/src/sealed-idb.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sealed-idb.cjs","sources":["../../../../agent-runtime/src/sealed-idb.ts"],"sourcesContent":["/**\n * The sealed-record toolkit the device stores in this package share (the thread snapshot mirror,\n * the chat outbox): AES-GCM-256 sealing with a fresh IV and additional data that binds a record to\n * where it is stored, SHA-256 names so a database names no one, and the part of IndexedDB they use.\n *\n * This package compiles without the DOM lib (React Native honesty, `globals.d.ts`), so IndexedDB is\n * described structurally here; the stores run only where it exists and degrade to nothing where it\n * does not.\n */\n\nexport type IdbListener = ((event?: unknown) => void) | null;\n\nexport interface IdbRequest<T> {\n  readonly result: T;\n  readonly error: unknown;\n  onsuccess: IdbListener;\n  onerror: IdbListener;\n}\n\nexport interface IdbOpenRequest extends IdbRequest<IdbDatabase> {\n  onupgradeneeded: IdbListener;\n  onblocked: IdbListener;\n}\n\nexport interface IdbFactory {\n  open(name: string, version?: number): IdbOpenRequest;\n}\n\nexport interface IdbCursor {\n  readonly primaryKey: unknown;\n  continue(): void;\n}\n\nexport interface IdbIndex {\n  getAll(query?: unknown): IdbRequest<unknown[]>;\n  getAllKeys(query?: unknown): IdbRequest<unknown[]>;\n  openKeyCursor(range?: unknown, direction?: string): IdbRequest<IdbCursor | null>;\n}\n\nexport interface IdbObjectStore {\n  put(value: unknown): IdbRequest<unknown>;\n  get(key: unknown): IdbRequest<unknown>;\n  delete(key: unknown): IdbRequest<unknown>;\n  clear(): IdbRequest<unknown>;\n  index(name: string): IdbIndex;\n  createIndex(name: string, keyPath: string | string[], options?: { unique?: boolean }): unknown;\n}\n\nexport interface IdbTransaction {\n  objectStore(name: string): IdbObjectStore;\n  readonly error: unknown;\n  oncomplete: IdbListener;\n  onabort: IdbListener;\n  onerror: IdbListener;\n}\n\nexport interface IdbDatabase {\n  readonly objectStoreNames: { contains(name: string): boolean };\n  transaction(stores: string | string[], mode?: \"readonly\" | \"readwrite\"): IdbTransaction;\n  createObjectStore(name: string, options?: { keyPath: string }): IdbObjectStore;\n  onversionchange: IdbListener;\n  addEventListener(type: string, listener: () => void): void;\n  close(): void;\n}\n\nexport interface IdbKeyRangeStatic {\n  bound(lower: unknown, upper: unknown): unknown;\n}\n\nexport const idbGlobals = globalThis as { indexedDB?: object; IDBKeyRange?: IdbKeyRangeStatic };\n\n/** The AES-GCM IV length, prefixed to every sealed payload. */\nexport const SEALED_IV_BYTES = 12;\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\n\nexport async function sha256Hex(value: string): Promise<string> {\n  const digest = await crypto.subtle.digest(\"SHA-256\", encoder.encode(value));\n  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, \"0\")).join(\"\");\n}\n\n/** `value` as JSON, sealed under `key` with a fresh IV; `aad` binds it to where it is stored. */\nexport async function sealJson({\n  key,\n  value,\n  aad,\n}: {\n  key: CryptoKey;\n  value: unknown;\n  aad: string;\n}): Promise<Uint8Array> {\n  const iv = crypto.getRandomValues(new Uint8Array(SEALED_IV_BYTES));\n  const ciphertext = new Uint8Array(\n    await crypto.subtle.encrypt(\n      { name: \"AES-GCM\", iv, additionalData: encoder.encode(aad) },\n      key,\n      encoder.encode(JSON.stringify(value)),\n    ),\n  );\n  const sealed = new Uint8Array(SEALED_IV_BYTES + ciphertext.byteLength);\n  sealed.set(iv, 0);\n  sealed.set(ciphertext, SEALED_IV_BYTES);\n  return sealed;\n}\n\n/** Opens what {@link sealJson} sealed; throws for the wrong key, the wrong `aad`, or a damaged record. */\nexport async function openJson({\n  key,\n  sealed,\n  aad,\n}: {\n  key: CryptoKey;\n  sealed: Uint8Array;\n  aad: string;\n}): Promise<unknown> {\n  const iv = sealed.subarray(0, SEALED_IV_BYTES) as Uint8Array<ArrayBuffer>;\n  const plaintext = await crypto.subtle.decrypt(\n    { name: \"AES-GCM\", iv, additionalData: encoder.encode(aad) },\n    key,\n    sealed.subarray(SEALED_IV_BYTES) as Uint8Array<ArrayBuffer>,\n  );\n  return JSON.parse(decoder.decode(plaintext)) as unknown;\n}\n\nexport function requestToPromise<T>(request: IdbRequest<T>): Promise<T> {\n  return new Promise((resolve, reject) => {\n    request.onsuccess = () => resolve(request.result);\n    request.onerror = () => reject(request.error ?? new Error(\"IndexedDB request failed\"));\n  });\n}\n\nexport function transactionDone(tx: IdbTransaction): Promise<void> {\n  return new Promise((resolve, reject) => {\n    tx.oncomplete = () => resolve();\n    tx.onabort = () => reject(tx.error ?? new Error(\"IndexedDB transaction aborted\"));\n    tx.onerror = () => reject(tx.error ?? new Error(\"IndexedDB transaction failed\"));\n  });\n}\n\n/**\n * Opens `name` at `version`, creating what `upgrade` creates. Resolves `null` instead of failing:\n * a database a newer build upgraded past this version, a blocked open, or no IndexedDB at all\n * (private browsing, SSR) all mean \"no store here\".\n */\nexport function openSealedDatabase({\n  factory,\n  name,\n  version,\n  upgrade,\n}: {\n  factory: IdbFactory;\n  name: string;\n  version: number;\n  upgrade: (db: IdbDatabase) => void;\n}): Promise<IdbDatabase | null> {\n  return new Promise((resolve) => {\n    try {\n      const request = factory.open(name, version);\n      request.onupgradeneeded = () => upgrade(request.result);\n      request.onsuccess = () => {\n        const db = request.result;\n        // Another page deleting or upgrading the database: step aside.\n        db.onversionchange = () => db.close();\n        resolve(db);\n      };\n      request.onerror = () => resolve(null);\n      request.onblocked = () => resolve(null);\n    } catch {\n      resolve(null);\n    }\n  });\n}\n\n/**\n * A lazily opened database handle that reopens after the browser (or another page's upgrade or\n * delete) closes it. `null` while there is no IndexedDB or Web Crypto here.\n */\nexport function lazySealedDatabase({\n  factory,\n  name,\n  version,\n  upgrade,\n}: {\n  factory: object | undefined;\n  name: string;\n  version: number;\n  upgrade: (db: IdbDatabase) => void;\n}): () => Promise<IdbDatabase | null> {\n  let databasePromise: Promise<IdbDatabase | null> | null = null;\n  return () => {\n    if (!factory || typeof crypto === \"undefined\" || !crypto.subtle) return Promise.resolve(null);\n    databasePromise ??= openSealedDatabase({ factory: factory as IdbFactory, name, version, upgrade }).then(\n      (db) => {\n        if (db) {\n          const forget = () => {\n            databasePromise = null;\n          };\n          db.addEventListener(\"versionchange\", forget);\n          db.addEventListener(\"close\", forget);\n        } else {\n          databasePromise = null;\n        }\n        return db;\n      },\n    );\n    return databasePromise;\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/agent-runtime/src/sealed-idb.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The sealed-record toolkit the device stores in this package share (the thread snapshot mirror,
+ * the chat outbox): AES-GCM-256 sealing with a fresh IV and additional data that binds a record to
+ * where it is stored, SHA-256 names so a database names no one, and the part of IndexedDB they use.
+ *
+ * This package compiles without the DOM lib (React Native honesty, `globals.d.ts`), so IndexedDB is
+ * described structurally here; the stores run only where it exists and degrade to nothing where it
+ * does not.
+ */
+export type IdbListener = ((event?: unknown) => void) | null;
+export interface IdbRequest<T> {
+    readonly result: T;
+    readonly error: unknown;
+    onsuccess: IdbListener;
+    onerror: IdbListener;
+}
+export interface IdbOpenRequest extends IdbRequest<IdbDatabase> {
+    onupgradeneeded: IdbListener;
+    onblocked: IdbListener;
+}
+export interface IdbFactory {
+    open(name: string, version?: number): IdbOpenRequest;
+}
+export interface IdbCursor {
+    readonly primaryKey: unknown;
+    continue(): void;
+}
+export interface IdbIndex {
+    getAll(query?: unknown): IdbRequest<unknown[]>;
+    getAllKeys(query?: unknown): IdbRequest<unknown[]>;
+    openKeyCursor(range?: unknown, direction?: string): IdbRequest<IdbCursor | null>;
+}
+export interface IdbObjectStore {
+    put(value: unknown): IdbRequest<unknown>;
+    get(key: unknown): IdbRequest<unknown>;
+    delete(key: unknown): IdbRequest<unknown>;
+    clear(): IdbRequest<unknown>;
+    index(name: string): IdbIndex;
+    createIndex(name: string, keyPath: string | string[], options?: {
+        unique?: boolean;
+    }): unknown;
+}
+export interface IdbTransaction {
+    objectStore(name: string): IdbObjectStore;
+    readonly error: unknown;
+    oncomplete: IdbListener;
+    onabort: IdbListener;
+    onerror: IdbListener;
+}
+export interface IdbDatabase {
+    readonly objectStoreNames: {
+        contains(name: string): boolean;
+    };
+    transaction(stores: string | string[], mode?: "readonly" | "readwrite"): IdbTransaction;
+    createObjectStore(name: string, options?: {
+        keyPath: string;
+    }): IdbObjectStore;
+    onversionchange: IdbListener;
+    addEventListener(type: string, listener: () => void): void;
+    close(): void;
+}
+export interface IdbKeyRangeStatic {
+    bound(lower: unknown, upper: unknown): unknown;
+}
+export declare const idbGlobals: {
+    indexedDB?: object;
+    IDBKeyRange?: IdbKeyRangeStatic;
+};
+/** The AES-GCM IV length, prefixed to every sealed payload. */
+export declare const SEALED_IV_BYTES = 12;
+export declare function sha256Hex(value: string): Promise<string>;
+/** `value` as JSON, sealed under `key` with a fresh IV; `aad` binds it to where it is stored. */
+export declare function sealJson({ key, value, aad, }: {
+    key: CryptoKey;
+    value: unknown;
+    aad: string;
+}): Promise<Uint8Array>;
+/** Opens what {@link sealJson} sealed; throws for the wrong key, the wrong `aad`, or a damaged record. */
+export declare function openJson({ key, sealed, aad, }: {
+    key: CryptoKey;
+    sealed: Uint8Array;
+    aad: string;
+}): Promise<unknown>;
+export declare function requestToPromise<T>(request: IdbRequest<T>): Promise<T>;
+export declare function transactionDone(tx: IdbTransaction): Promise<void>;
+/**
+ * Opens `name` at `version`, creating what `upgrade` creates. Resolves `null` instead of failing:
+ * a database a newer build upgraded past this version, a blocked open, or no IndexedDB at all
+ * (private browsing, SSR) all mean "no store here".
+ */
+export declare function openSealedDatabase({ factory, name, version, upgrade, }: {
+    factory: IdbFactory;
+    name: string;
+    version: number;
+    upgrade: (db: IdbDatabase) => void;
+}): Promise<IdbDatabase | null>;
+/**
+ * A lazily opened database handle that reopens after the browser (or another page's upgrade or
+ * delete) closes it. `null` while there is no IndexedDB or Web Crypto here.
+ */
+export declare function lazySealedDatabase({ factory, name, version, upgrade, }: {
+    factory: object | undefined;
+    name: string;
+    version: number;
+    upgrade: (db: IdbDatabase) => void;
+}): () => Promise<IdbDatabase | null>;

package/dist/agent-runtime/src/sealed-idb.js

@@ -0,0 +1,112 @@
+const idbGlobals = globalThis;
+const SEALED_IV_BYTES = 12;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+async function sha256Hex(value) {
+  const digest = await crypto.subtle.digest("SHA-256", encoder.encode(value));
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function sealJson({
+  key,
+  value,
+  aad
+}) {
+  const iv = crypto.getRandomValues(new Uint8Array(SEALED_IV_BYTES));
+  const ciphertext = new Uint8Array(
+    await crypto.subtle.encrypt(
+      { name: "AES-GCM", iv, additionalData: encoder.encode(aad) },
+      key,
+      encoder.encode(JSON.stringify(value))
+    )
+  );
+  const sealed = new Uint8Array(SEALED_IV_BYTES + ciphertext.byteLength);
+  sealed.set(iv, 0);
+  sealed.set(ciphertext, SEALED_IV_BYTES);
+  return sealed;
+}
+async function openJson({
+  key,
+  sealed,
+  aad
+}) {
+  const iv = sealed.subarray(0, SEALED_IV_BYTES);
+  const plaintext = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv, additionalData: encoder.encode(aad) },
+    key,
+    sealed.subarray(SEALED_IV_BYTES)
+  );
+  return JSON.parse(decoder.decode(plaintext));
+}
+function requestToPromise(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
+  });
+}
+function transactionDone(tx) {
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onabort = () => reject(tx.error ?? new Error("IndexedDB transaction aborted"));
+    tx.onerror = () => reject(tx.error ?? new Error("IndexedDB transaction failed"));
+  });
+}
+function openSealedDatabase({
+  factory,
+  name,
+  version,
+  upgrade
+}) {
+  return new Promise((resolve) => {
+    try {
+      const request = factory.open(name, version);
+      request.onupgradeneeded = () => upgrade(request.result);
+      request.onsuccess = () => {
+        const db = request.result;
+        db.onversionchange = () => db.close();
+        resolve(db);
+      };
+      request.onerror = () => resolve(null);
+      request.onblocked = () => resolve(null);
+    } catch {
+      resolve(null);
+    }
+  });
+}
+function lazySealedDatabase({
+  factory,
+  name,
+  version,
+  upgrade
+}) {
+  let databasePromise = null;
+  return () => {
+    if (!factory || typeof crypto === "undefined" || !crypto.subtle) return Promise.resolve(null);
+    databasePromise ?? (databasePromise = openSealedDatabase({ factory, name, version, upgrade }).then(
+      (db) => {
+        if (db) {
+          const forget = () => {
+            databasePromise = null;
+          };
+          db.addEventListener("versionchange", forget);
+          db.addEventListener("close", forget);
+        } else {
+          databasePromise = null;
+        }
+        return db;
+      }
+    ));
+    return databasePromise;
+  };
+}
+export {
+  SEALED_IV_BYTES,
+  idbGlobals,
+  lazySealedDatabase,
+  openJson,
+  openSealedDatabase,
+  requestToPromise,
+  sealJson,
+  sha256Hex,
+  transactionDone
+};
+//# sourceMappingURL=sealed-idb.js.map