@arbidocs/react 0.5.111 → 0.5.112

package/dist/chat/thread-document.js

@@ -0,0 +1,53 @@
+const UNBOUND = { documentId: null, unavailable: false };
+function bindingOfRow(row) {
+  if (!row) return UNBOUND;
+  const documentId = row.bound_document_ext_id ?? null;
+  return { documentId, unavailable: !documentId && row.bound_document_unavailable === true };
+}
+function latestThreadOfDocument(conversations, documentId) {
+  let latest = null;
+  for (const row of conversations ?? []) {
+    if (row.bound_document_ext_id !== documentId) continue;
+    if (!latest || (row.updated_at ?? "") > (latest.updated_at ?? "")) latest = row;
+  }
+  return latest?.external_id ?? null;
+}
+const LEGACY_THREAD_DOCUMENTS_KEY = "arbi-thread-documents";
+function storage() {
+  try {
+    return typeof localStorage === "undefined" ? void 0 : localStorage;
+  } catch {
+    return void 0;
+  }
+}
+function readLegacyThreadDocuments() {
+  const out = {};
+  try {
+    const parsed = JSON.parse(storage()?.getItem(LEGACY_THREAD_DOCUMENTS_KEY) ?? "null");
+    if (parsed && typeof parsed === "object") {
+      for (const [conversationId, documentId] of Object.entries(parsed))
+        if (typeof documentId === "string") out[conversationId] = documentId;
+    }
+  } catch {
+  }
+  return out;
+}
+function forgetLegacyThreadDocuments(conversationIds) {
+  if (conversationIds.length === 0) return;
+  const rest = readLegacyThreadDocuments();
+  conversationIds.forEach((id) => delete rest[id]);
+  try {
+    if (Object.keys(rest).length === 0) storage()?.removeItem(LEGACY_THREAD_DOCUMENTS_KEY);
+    else storage()?.setItem(LEGACY_THREAD_DOCUMENTS_KEY, JSON.stringify(rest));
+  } catch {
+  }
+}
+export {
+  LEGACY_THREAD_DOCUMENTS_KEY,
+  UNBOUND,
+  bindingOfRow,
+  forgetLegacyThreadDocuments,
+  latestThreadOfDocument,
+  readLegacyThreadDocuments
+};
+//# sourceMappingURL=thread-document.js.map

package/dist/chat/thread-document.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/chat/thread-document.ts"],
+  "sourcesContent": ["/**\n * A thread's document: the one document a conversation drafts in, part of the conversation.\n *\n * A thread is bound to a document only when it was started from it (\"Chat about this document\" in\n * the viewer) or the person attached it in that thread. Only that thread names it on its turns\n * (`active_artifact_ext_id`), on every turn and after a reload. A document merely open or docked\n * beside the chat binds nothing: a new chat (the ask bar, the new-chat button, the thread\n * launcher, home) starts unbound, so a question there never becomes an edit of whatever is open.\n *\n * The binding is the server's: the conversation's `bound_document_ext_id`, set by the first turn\n * (`bound_document_ext_id` on the turn that starts it) or by a PATCH, and read under each reader's\n * access (`bound_document_unavailable`: bound to a document this reader cannot open). It follows\n * the person to every device, and a shared thread's members all see it. The query cache holds it\n * (`./thread-binding`); a new chat's binding is the session's `newChatDocumentId` until its first\n * turn creates the conversation.\n *\n * This module is the light half (no query client, no SDK), so the shell entry can carry it.\n */\n\n/** What a conversation row says about its binding. */\nexport interface ThreadBindingRow {\n  external_id: string\n  bound_document_ext_id?: string | null\n  bound_document_unavailable?: boolean | null\n  updated_at?: string | null\n}\n\n/** A conversation's binding as this reader sees it. */\nexport interface ThreadBinding {\n  /** The bound document, or null (unbound, or bound to one this reader cannot open). */\n  documentId: string | null\n  /** Bound to a document this reader cannot open (another member's private document, or deleted). */\n  unavailable: boolean\n}\n\nexport const UNBOUND: ThreadBinding = { documentId: null, unavailable: false }\n\n/** A row's binding. */\nexport function bindingOfRow(row: ThreadBindingRow | null | undefined): ThreadBinding {\n  if (!row) return UNBOUND\n  const documentId = row.bound_document_ext_id ?? null\n  return { documentId, unavailable: !documentId && row.bound_document_unavailable === true }\n}\n\n/** The most recently active conversation bound to a document, among `conversations`, or null. */\nexport function latestThreadOfDocument(\n  conversations: readonly ThreadBindingRow[] | null | undefined,\n  documentId: string\n): string | null {\n  let latest: ThreadBindingRow | null = null\n  for (const row of conversations ?? []) {\n    if (row.bound_document_ext_id !== documentId) continue\n    if (!latest || (row.updated_at ?? '') > (latest.updated_at ?? '')) latest = row\n  }\n  return latest?.external_id ?? null\n}\n\n// --------------------------------------------------------------------------------------------- //\n// Bindings this browser kept before the server held them (`localStorage`), moved to the server\n// once (`migrateLegacyThreadDocuments` in `./thread-binding`) and then forgotten.\n// --------------------------------------------------------------------------------------------- //\n\nexport const LEGACY_THREAD_DOCUMENTS_KEY = 'arbi-thread-documents'\n\nfunction storage(): Storage | undefined {\n  try {\n    return typeof localStorage === 'undefined' ? undefined : localStorage\n  } catch {\n    return undefined\n  }\n}\n\n/** The bindings this browser kept locally (conversation id \u2192 document id); empty when none. */\nexport function readLegacyThreadDocuments(): Record<string, string> {\n  const out: Record<string, string> = {}\n  try {\n    const parsed = JSON.parse(storage()?.getItem(LEGACY_THREAD_DOCUMENTS_KEY) ?? 'null') as unknown\n    if (parsed && typeof parsed === 'object')\n      for (const [conversationId, documentId] of Object.entries(parsed))\n        if (typeof documentId === 'string') out[conversationId] = documentId\n  } catch {\n    // Damaged or blocked: nothing to move.\n  }\n  return out\n}\n\n/** Forget locally kept bindings (moved to the server); the key goes with the last of them. */\nexport function forgetLegacyThreadDocuments(conversationIds: readonly string[]): void {\n  if (conversationIds.length === 0) return\n  const rest = readLegacyThreadDocuments()\n  conversationIds.forEach((id) => delete rest[id])\n  try {\n    if (Object.keys(rest).length === 0) storage()?.removeItem(LEGACY_THREAD_DOCUMENTS_KEY)\n    else storage()?.setItem(LEGACY_THREAD_DOCUMENTS_KEY, JSON.stringify(rest))\n  } catch {\n    // Blocked: nothing more to do.\n  }\n}\n"],
+  "mappings": "AAmCO,MAAM,UAAyB,EAAE,YAAY,MAAM,aAAa,MAAM;AAGtE,SAAS,aAAa,KAAyD;AACpF,MAAI,CAAC,IAAK,QAAO;AACjB,QAAM,aAAa,IAAI,yBAAyB;AAChD,SAAO,EAAE,YAAY,aAAa,CAAC,cAAc,IAAI,+BAA+B,KAAK;AAC3F;AAGO,SAAS,uBACd,eACA,YACe;AACf,MAAI,SAAkC;AACtC,aAAW,OAAO,iBAAiB,CAAC,GAAG;AACrC,QAAI,IAAI,0BAA0B,WAAY;AAC9C,QAAI,CAAC,WAAW,IAAI,cAAc,OAAO,OAAO,cAAc,IAAK,UAAS;AAAA,EAC9E;AACA,SAAO,QAAQ,eAAe;AAChC;AAOO,MAAM,8BAA8B;AAE3C,SAAS,UAA+B;AACtC,MAAI;AACF,WAAO,OAAO,iBAAiB,cAAc,SAAY;AAAA,EAC3D,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAGO,SAAS,4BAAoD;AAClE,QAAM,MAA8B,CAAC;AACrC,MAAI;AACF,UAAM,SAAS,KAAK,MAAM,QAAQ,GAAG,QAAQ,2BAA2B,KAAK,MAAM;AACnF,QAAI,UAAU,OAAO,WAAW;AAC9B,iBAAW,CAAC,gBAAgB,UAAU,KAAK,OAAO,QAAQ,MAAM;AAC9D,YAAI,OAAO,eAAe,SAAU,KAAI,cAAc,IAAI;AAAA;AAAA,EAChE,QAAQ;AAAA,EAER;AACA,SAAO;AACT;AAGO,SAAS,4BAA4B,iBAA0C;AACpF,MAAI,gBAAgB,WAAW,EAAG;AAClC,QAAM,OAAO,0BAA0B;AACvC,kBAAgB,QAAQ,CAAC,OAAO,OAAO,KAAK,EAAE,CAAC;AAC/C,MAAI;AACF,QAAI,OAAO,KAAK,IAAI,EAAE,WAAW,EAAG,SAAQ,GAAG,WAAW,2BAA2B;AAAA,QAChF,SAAQ,GAAG,QAAQ,6BAA6B,KAAK,UAAU,IAAI,CAAC;AAAA,EAC3E,QAAQ;AAAA,EAER;AACF;",
+  "names": []
+}

package/dist/chat/turn-control.js

@@ -0,0 +1,79 @@
+import { onlineManager } from "@tanstack/react-query";
+import { STOP_ID_WAIT_MS } from "@arbidocs/sdk/browser";
+import { notify } from "../shell/index.js";
+import { arbiQueryKeys } from "../hooks.js";
+const AGENT_CONTROL_COMMANDS = {
+  pause: "/pause",
+  resume: "/resume",
+  report: "/report"
+};
+function refuseChatWhenOffline() {
+  if (onlineManager.isOnline()) return false;
+  notify.warning("You're offline \u2014 your message is still in the box. Reconnect to send it.");
+  return true;
+}
+function findStream(session, controller) {
+  const generating = session.getState().generating;
+  const keys = Object.keys(generating).filter((k) => generating[k]?.abortController === controller);
+  const key = keys.find((k) => generating[k].isGenerating) ?? keys[0];
+  return key ? { conversationKey: key, state: generating[key] } : null;
+}
+function waitForResponseId(session, controller, timeoutMs = STOP_ID_WAIT_MS) {
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = (result) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      unsubscribe();
+      resolve(result);
+    };
+    const check = () => {
+      const stream = findStream(session, controller);
+      if (stream?.state.streamingAssistantId) {
+        finish({
+          conversationKey: stream.conversationKey,
+          responseId: stream.state.streamingAssistantId
+        });
+      } else if (!stream || !stream.state.isGenerating || controller.signal.aborted) {
+        finish(null);
+      }
+    };
+    const timer = setTimeout(() => finish(null), timeoutMs);
+    const unsubscribe = session.subscribe(check);
+    check();
+  });
+}
+const attachedRunStops = /* @__PURE__ */ new Map();
+function registerAttachedRun(conversationId, responseId, stop) {
+  attachedRunStops.set(conversationId, { responseId, stop });
+  return () => {
+    if (attachedRunStops.get(conversationId)?.stop === stop) attachedRunStops.delete(conversationId);
+  };
+}
+function disconnectAttachedRun(conversationId, responseId) {
+  const attached = attachedRunStops.get(conversationId);
+  if (attached?.responseId === responseId) attached.stop();
+}
+function cachedQuotaUsedUp(queryClient, workspaceId) {
+  if (!workspaceId) return null;
+  const workspaces = queryClient.getQueryData(arbiQueryKeys.workspaces());
+  const projectExtId = workspaces?.find((w) => w.external_id === workspaceId)?.project_ext_id;
+  if (!projectExtId) return null;
+  const projects = queryClient.getQueryData(arbiQueryKeys.projects());
+  const project = projects?.find((p) => p.external_id === projectExtId);
+  if (!project) return null;
+  const used = project.quotas?.ai_usage?.used ?? 0;
+  const limit = project.quotas?.ai_usage?.limit ?? 0;
+  if (limit <= 0 || used < limit) return null;
+  return { spend: used, budget: limit, projectExtId };
+}
+export {
+  AGENT_CONTROL_COMMANDS,
+  cachedQuotaUsedUp,
+  disconnectAttachedRun,
+  refuseChatWhenOffline,
+  registerAttachedRun,
+  waitForResponseId
+};
+//# sourceMappingURL=turn-control.js.map

package/dist/chat/turn-control.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/chat/turn-control.ts"],
+  "sourcesContent": ["/**\n * What the chat engine checks and coordinates around a turn: whether a send can go out (online),\n * the run a Stop waits for, the attached runs a Stop closes, the run-control commands, and whether\n * a failed turn ran out of AI usage.\n */\n\nimport { onlineManager, type QueryClient } from '@tanstack/react-query'\nimport { STOP_ID_WAIT_MS, type QuotaExceeded } from '@arbidocs/sdk/browser'\nimport { notify } from '../shell'\nimport { arbiQueryKeys } from '../hooks'\nimport type { ArbiSessionStore } from '../session/store'\n\n/**\n * The slash-command text of each run-control action: the composer (typed) and the agent bar's\n * menu (clicked) send the same text, interjected into the running turn.\n */\nexport const AGENT_CONTROL_COMMANDS = {\n  pause: '/pause',\n  resume: '/resume',\n  report: '/report',\n} as const\n\n/**\n * Chat runs against the server-side AI, so nothing can be sent offline. Call before any chat send:\n * when offline it tells the person the text is still in the box, and returns true so the caller\n * leaves the draft untouched.\n */\nexport function refuseChatWhenOffline(): boolean {\n  if (onlineManager.isOnline()) return false\n  notify.warning(\"You're offline \u2014 your message is still in the box. Reconnect to send it.\")\n  return true\n}\n\nfunction findStream(session: ArbiSessionStore, controller: AbortController) {\n  const generating = session.getState().generating\n  // The stream keeps its controller where it ended (a stopped `new` entry still holds it), so\n  // prefer the entry that is still generating with it.\n  const keys = Object.keys(generating).filter((k) => generating[k]?.abortController === controller)\n  const key = keys.find((k) => generating[k].isGenerating) ?? keys[0]\n  return key ? { conversationKey: key, state: generating[key] } : null\n}\n\n/**\n * Wait for the local stream started with `controller` to report its response id. Resolves with the\n * id and the conversation it now belongs to, or null once that stream ends or `timeoutMs` passes.\n */\nexport function waitForResponseId(\n  session: ArbiSessionStore,\n  controller: AbortController,\n  timeoutMs = STOP_ID_WAIT_MS\n): Promise<{ conversationKey: string; responseId: string } | null> {\n  return new Promise((resolve) => {\n    let done = false\n    const finish = (result: { conversationKey: string; responseId: string } | null) => {\n      if (done) return\n      done = true\n      clearTimeout(timer)\n      unsubscribe()\n      resolve(result)\n    }\n    const check = () => {\n      const stream = findStream(session, controller)\n      if (stream?.state.streamingAssistantId) {\n        finish({\n          conversationKey: stream.conversationKey,\n          responseId: stream.state.streamingAssistantId,\n        })\n      } else if (!stream || !stream.state.isGenerating || controller.signal.aborted) {\n        finish(null)\n      }\n    }\n    const timer = setTimeout(() => finish(null), timeoutMs)\n    const unsubscribe = session.subscribe(check)\n    check()\n  })\n}\n\n// Stop for each conversation's live attach, with the run it follows. An attach has no local\n// AbortController, so Stop reaches it through `disconnectAttachedRun` instead.\nconst attachedRunStops = new Map<string, { responseId: string; stop: () => void }>()\n\n/** Register a conversation's live attach; returns the unregister. */\nexport function registerAttachedRun(\n  conversationId: string,\n  responseId: string,\n  stop: () => void\n): () => void {\n  attachedRunStops.set(conversationId, { responseId, stop })\n  return () => {\n    if (attachedRunStops.get(conversationId)?.stop === stop) attachedRunStops.delete(conversationId)\n  }\n}\n\n/**\n * Close the live attach stream of a run in a conversation, if that run is the one attached.\n * Matching the run matters: Stop awaits the cancel, and by then the server may have started the\n * next queued follow-up and attached it. Closing \"whatever is attached\" would cut that one off.\n */\nexport function disconnectAttachedRun(conversationId: string, responseId: string): void {\n  const attached = attachedRunStops.get(conversationId)\n  if (attached?.responseId === responseId) attached.stop()\n}\n\n/**\n * The workspace's AI usage as the cache knows it, when it is used up (its project's `ai_usage`\n * quota reached): the reason a failed turn failed.\n */\nexport function cachedQuotaUsedUp(\n  queryClient: QueryClient,\n  workspaceId: string | null | undefined\n): QuotaExceeded | null {\n  if (!workspaceId) return null\n  const workspaces = queryClient.getQueryData<\n    Array<{ external_id: string; project_ext_id?: string | null }>\n  >(arbiQueryKeys.workspaces())\n  const projectExtId = workspaces?.find((w) => w.external_id === workspaceId)?.project_ext_id\n  if (!projectExtId) return null\n  const projects = queryClient.getQueryData<\n    Array<{ external_id: string; quotas?: { ai_usage?: { used?: number; limit?: number } } }>\n  >(arbiQueryKeys.projects())\n  const project = projects?.find((p) => p.external_id === projectExtId)\n  if (!project) return null\n  const used = project.quotas?.ai_usage?.used ?? 0\n  const limit = project.quotas?.ai_usage?.limit ?? 0\n  if (limit <= 0 || used < limit) return null\n  return { spend: used, budget: limit, projectExtId }\n}\n"],
+  "mappings": "AAMA,SAAS,qBAAuC;AAChD,SAAS,uBAA2C;AACpD,SAAS,cAAc;AACvB,SAAS,qBAAqB;AAOvB,MAAM,yBAAyB;AAAA,EACpC,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,QAAQ;AACV;AAOO,SAAS,wBAAiC;AAC/C,MAAI,cAAc,SAAS,EAAG,QAAO;AACrC,SAAO,QAAQ,+EAA0E;AACzF,SAAO;AACT;AAEA,SAAS,WAAW,SAA2B,YAA6B;AAC1E,QAAM,aAAa,QAAQ,SAAS,EAAE;AAGtC,QAAM,OAAO,OAAO,KAAK,UAAU,EAAE,OAAO,CAAC,MAAM,WAAW,CAAC,GAAG,oBAAoB,UAAU;AAChG,QAAM,MAAM,KAAK,KAAK,CAAC,MAAM,WAAW,CAAC,EAAE,YAAY,KAAK,KAAK,CAAC;AAClE,SAAO,MAAM,EAAE,iBAAiB,KAAK,OAAO,WAAW,GAAG,EAAE,IAAI;AAClE;AAMO,SAAS,kBACd,SACA,YACA,YAAY,iBACqD;AACjE,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,QAAI,OAAO;AACX,UAAM,SAAS,CAAC,WAAmE;AACjF,UAAI,KAAM;AACV,aAAO;AACP,mBAAa,KAAK;AAClB,kBAAY;AACZ,cAAQ,MAAM;AAAA,IAChB;AACA,UAAM,QAAQ,MAAM;AAClB,YAAM,SAAS,WAAW,SAAS,UAAU;AAC7C,UAAI,QAAQ,MAAM,sBAAsB;AACtC,eAAO;AAAA,UACL,iBAAiB,OAAO;AAAA,UACxB,YAAY,OAAO,MAAM;AAAA,QAC3B,CAAC;AAAA,MACH,WAAW,CAAC,UAAU,CAAC,OAAO,MAAM,gBAAgB,WAAW,OAAO,SAAS;AAC7E,eAAO,IAAI;AAAA,MACb;AAAA,IACF;AACA,UAAM,QAAQ,WAAW,MAAM,OAAO,IAAI,GAAG,SAAS;AACtD,UAAM,cAAc,QAAQ,UAAU,KAAK;AAC3C,UAAM;AAAA,EACR,CAAC;AACH;AAIA,MAAM,mBAAmB,oBAAI,IAAsD;AAG5E,SAAS,oBACd,gBACA,YACA,MACY;AACZ,mBAAiB,IAAI,gBAAgB,EAAE,YAAY,KAAK,CAAC;AACzD,SAAO,MAAM;AACX,QAAI,iBAAiB,IAAI,cAAc,GAAG,SAAS,KAAM,kBAAiB,OAAO,cAAc;AAAA,EACjG;AACF;AAOO,SAAS,sBAAsB,gBAAwB,YAA0B;AACtF,QAAM,WAAW,iBAAiB,IAAI,cAAc;AACpD,MAAI,UAAU,eAAe,WAAY,UAAS,KAAK;AACzD;AAMO,SAAS,kBACd,aACA,aACsB;AACtB,MAAI,CAAC,YAAa,QAAO;AACzB,QAAM,aAAa,YAAY,aAE7B,cAAc,WAAW,CAAC;AAC5B,QAAM,eAAe,YAAY,KAAK,CAAC,MAAM,EAAE,gBAAgB,WAAW,GAAG;AAC7E,MAAI,CAAC,aAAc,QAAO;AAC1B,QAAM,WAAW,YAAY,aAE3B,cAAc,SAAS,CAAC;AAC1B,QAAM,UAAU,UAAU,KAAK,CAAC,MAAM,EAAE,gBAAgB,YAAY;AACpE,MAAI,CAAC,QAAS,QAAO;AACrB,QAAM,OAAO,QAAQ,QAAQ,UAAU,QAAQ;AAC/C,QAAM,QAAQ,QAAQ,QAAQ,UAAU,SAAS;AACjD,MAAI,SAAS,KAAK,OAAO,MAAO,QAAO;AACvC,SAAO,EAAE,OAAO,MAAM,QAAQ,OAAO,aAAa;AACpD;",
+  "names": []
+}

package/dist/chat/useAgentRunControl.js

@@ -0,0 +1,36 @@
+import { useCallback } from "react";
+import { useArbi } from "../useArbi.js";
+import { useArbiSessionStore } from "../session/index.js";
+import { AGENT_CONTROL_COMMANDS } from "./turn-control.js";
+function useAgentRunControl(assistantMessageExtId) {
+  const arbi = useArbi();
+  const session = useArbiSessionStore();
+  const send = useCallback(
+    (command) => {
+      if (!assistantMessageExtId) return;
+      void arbi.assistant.interject(assistantMessageExtId, command).catch(() => {
+      });
+    },
+    [assistantMessageExtId, arbi]
+  );
+  const pause = useCallback(() => {
+    if (!assistantMessageExtId) return;
+    session.setAgentControlState(assistantMessageExtId, "pausing");
+    send(AGENT_CONTROL_COMMANDS.pause);
+  }, [assistantMessageExtId, session, send]);
+  const resume = useCallback(() => {
+    if (!assistantMessageExtId) return;
+    session.setAgentControlState(assistantMessageExtId, "resuming");
+    send(AGENT_CONTROL_COMMANDS.resume);
+  }, [assistantMessageExtId, session, send]);
+  const report = useCallback(() => {
+    if (!assistantMessageExtId) return;
+    session.setAgentProbePending(assistantMessageExtId, true);
+    send(AGENT_CONTROL_COMMANDS.report);
+  }, [assistantMessageExtId, session, send]);
+  return { pause, resume, report };
+}
+export {
+  useAgentRunControl
+};
+//# sourceMappingURL=useAgentRunControl.js.map

package/dist/chat/useAgentRunControl.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/chat/useAgentRunControl.ts"],
+  "sourcesContent": ["/**\n * Run-control commands to a running agent turn. Choosing Pause in the turn bar's menu and typing\n * `/pause` in the composer are the same act: both send the command's text as an interjection\n * (`arbi.assistant.interject`), and the backend dispatches it. There is no dedicated control\n * endpoint; the menu is a shortcut for the slash command.\n *\n * Each action also sets an optimistic state in the session, because the loop only confirms at its\n * next boundary (`paused` / `running`) and a probe answers in the background. The\n * `arbi.agent_control_state` and `arbi.probe_answer` events then confirm or correct it.\n */\n\nimport { useCallback } from 'react'\nimport { useArbi } from '../useArbi'\nimport { useArbiSessionStore } from '../session'\nimport { AGENT_CONTROL_COMMANDS } from './turn-control'\n\nexport function useAgentRunControl(assistantMessageExtId: string | null) {\n  const arbi = useArbi()\n  const session = useArbiSessionStore()\n\n  const send = useCallback(\n    (command: string) => {\n      if (!assistantMessageExtId) return\n      // Fire and forget: the control events confirm or correct the optimistic state.\n      void arbi.assistant.interject(assistantMessageExtId, command).catch(() => {})\n    },\n    [assistantMessageExtId, arbi]\n  )\n\n  const pause = useCallback(() => {\n    if (!assistantMessageExtId) return\n    session.setAgentControlState(assistantMessageExtId, 'pausing')\n    send(AGENT_CONTROL_COMMANDS.pause)\n  }, [assistantMessageExtId, session, send])\n\n  const resume = useCallback(() => {\n    if (!assistantMessageExtId) return\n    session.setAgentControlState(assistantMessageExtId, 'resuming')\n    send(AGENT_CONTROL_COMMANDS.resume)\n  }, [assistantMessageExtId, session, send])\n\n  const report = useCallback(() => {\n    if (!assistantMessageExtId) return\n    session.setAgentProbePending(assistantMessageExtId, true)\n    send(AGENT_CONTROL_COMMANDS.report)\n  }, [assistantMessageExtId, session, send])\n\n  return { pause, resume, report }\n}\n"],
+  "mappings": "AAWA,SAAS,mBAAmB;AAC5B,SAAS,eAAe;AACxB,SAAS,2BAA2B;AACpC,SAAS,8BAA8B;AAEhC,SAAS,mBAAmB,uBAAsC;AACvE,QAAM,OAAO,QAAQ;AACrB,QAAM,UAAU,oBAAoB;AAEpC,QAAM,OAAO;AAAA,IACX,CAAC,YAAoB;AACnB,UAAI,CAAC,sBAAuB;AAE5B,WAAK,KAAK,UAAU,UAAU,uBAAuB,OAAO,EAAE,MAAM,MAAM;AAAA,MAAC,CAAC;AAAA,IAC9E;AAAA,IACA,CAAC,uBAAuB,IAAI;AAAA,EAC9B;AAEA,QAAM,QAAQ,YAAY,MAAM;AAC9B,QAAI,CAAC,sBAAuB;AAC5B,YAAQ,qBAAqB,uBAAuB,SAAS;AAC7D,SAAK,uBAAuB,KAAK;AAAA,EACnC,GAAG,CAAC,uBAAuB,SAAS,IAAI,CAAC;AAEzC,QAAM,SAAS,YAAY,MAAM;AAC/B,QAAI,CAAC,sBAAuB;AAC5B,YAAQ,qBAAqB,uBAAuB,UAAU;AAC9D,SAAK,uBAAuB,MAAM;AAAA,EACpC,GAAG,CAAC,uBAAuB,SAAS,IAAI,CAAC;AAEzC,QAAM,SAAS,YAAY,MAAM;AAC/B,QAAI,CAAC,sBAAuB;AAC5B,YAAQ,qBAAqB,uBAAuB,IAAI;AACxD,SAAK,uBAAuB,MAAM;AAAA,EACpC,GAAG,CAAC,uBAAuB,SAAS,IAAI,CAAC;AAEzC,SAAO,EAAE,OAAO,QAAQ,OAAO;AACjC;",
+  "names": []
+}

package/dist/chat/useAnswerAgentQuestion.js

@@ -0,0 +1,19 @@
+import { useCallback } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { useArbi } from "../useArbi.js";
+import { clearUserInputRequest } from "./conversation-cache.js";
+function useAnswerAgentQuestion() {
+  const arbi = useArbi();
+  const queryClient = useQueryClient();
+  return useCallback(
+    async (question, answer) => {
+      await arbi.assistant.interject(question.assistantMessageExtId, answer);
+      clearUserInputRequest(queryClient, question.conversationExtId, question.assistantMessageExtId);
+    },
+    [arbi, queryClient]
+  );
+}
+export {
+  useAnswerAgentQuestion
+};
+//# sourceMappingURL=useAnswerAgentQuestion.js.map

package/dist/chat/useAnswerAgentQuestion.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/chat/useAnswerAgentQuestion.ts"],
+  "sourcesContent": ["import { useCallback } from 'react'\nimport { useQueryClient } from '@tanstack/react-query'\nimport { useArbi } from '../useArbi'\nimport { clearUserInputRequest } from './conversation-cache'\n\n/** The agent's question an answer is for: its message, in its conversation. */\nexport interface AgentQuestionRef {\n  assistantMessageExtId: string\n  conversationExtId: string\n}\n\n/**\n * Answer the question a running turn paused on (ask_user): the answer goes into the turn, and the\n * question leaves the cached message so it is no longer offered. Rejects when the send fails.\n */\nexport function useAnswerAgentQuestion() {\n  const arbi = useArbi()\n  const queryClient = useQueryClient()\n  return useCallback(\n    async (question: AgentQuestionRef, answer: string) => {\n      await arbi.assistant.interject(question.assistantMessageExtId, answer)\n      clearUserInputRequest(queryClient, question.conversationExtId, question.assistantMessageExtId)\n    },\n    [arbi, queryClient]\n  )\n}\n"],
+  "mappings": "AAAA,SAAS,mBAAmB;AAC5B,SAAS,sBAAsB;AAC/B,SAAS,eAAe;AACxB,SAAS,6BAA6B;AAY/B,SAAS,yBAAyB;AACvC,QAAM,OAAO,QAAQ;AACrB,QAAM,cAAc,eAAe;AACnC,SAAO;AAAA,IACL,OAAO,UAA4B,WAAmB;AACpD,YAAM,KAAK,UAAU,UAAU,SAAS,uBAAuB,MAAM;AACrE,4BAAsB,aAAa,SAAS,mBAAmB,SAAS,qBAAqB;AAAA,IAC/F;AAAA,IACA,CAAC,MAAM,WAAW;AAAA,EACpB;AACF;",
+  "names": []
+}

package/dist/chat/useAskAgain.js

@@ -0,0 +1,32 @@
+import { useCallback, useEffect, useRef } from "react";
+import { useArbiSessionStore } from "../session/index.js";
+import { refuseChatWhenOffline } from "./turn-control.js";
+function useAskAgain(options) {
+  const session = useArbiSessionStore();
+  const optionsRef = useRef(options);
+  useEffect(() => {
+    optionsRef.current = options;
+  });
+  return useCallback(
+    (question, stoppedAnswer) => {
+      const { isGenerating, handleCreateBranch } = optionsRef.current;
+      const content = question.content.trim();
+      if (!content) return;
+      if (isGenerating) {
+        session.setDraft(content);
+        return;
+      }
+      if (refuseChatWhenOffline()) return;
+      session.completeEditing();
+      void handleCreateBranch(
+        question.parent_message_ext_id ?? stoppedAnswer.external_id ?? null,
+        content
+      );
+    },
+    [session]
+  );
+}
+export {
+  useAskAgain
+};
+//# sourceMappingURL=useAskAgain.js.map

package/dist/chat/useAskAgain.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/chat/useAskAgain.ts"],
+  "sourcesContent": ["/**\n * \"Ask again\" on a stopped answer: run its question again, straight away.\n *\n * - The question is sent again from where it was first asked, so the new answer replaces the\n *   stopped one as a branch (as an unchanged edit would). The first question of a conversation\n *   has nothing before it, so it is asked again as a follow-up to the stopped answer.\n * - While another turn is running, the question goes in the composer rather than racing it.\n */\n\nimport { useCallback, useEffect, useRef } from 'react'\nimport type { ChatMessage } from '@arbidocs/sdk/browser'\nimport { useArbiSessionStore } from '../session'\nimport { refuseChatWhenOffline } from './turn-control'\n\n/**\n * Re-run the question of a stopped answer.\n *\n * @param question The person's question the stopped answer replied to\n * @param stoppedAnswer The stopped answer itself\n */\nexport type AskAgain = (question: ChatMessage, stoppedAnswer: ChatMessage) => void\n\nexport interface UseAskAgainOptions {\n  isGenerating: boolean\n  /** Send `content` as ARBI's next turn after `parentMessageExtId`. */\n  handleCreateBranch: (parentMessageExtId: string | null, content: string) => Promise<void>\n}\n\nexport function useAskAgain(options: UseAskAgainOptions): AskAgain {\n  const session = useArbiSessionStore()\n  // A stable callback (it is a context value for every message), reading the latest options.\n  const optionsRef = useRef(options)\n  useEffect(() => {\n    optionsRef.current = options\n  })\n  return useCallback(\n    (question: ChatMessage, stoppedAnswer: ChatMessage) => {\n      const { isGenerating, handleCreateBranch } = optionsRef.current\n      const content = question.content.trim()\n      if (!content) return\n      if (isGenerating) {\n        session.setDraft(content)\n        return\n      }\n      if (refuseChatWhenOffline()) return\n      // Leave any open edit: the new turn must show.\n      session.completeEditing()\n      void handleCreateBranch(\n        question.parent_message_ext_id ?? stoppedAnswer.external_id ?? null,\n        content\n      )\n    },\n    [session]\n  )\n}\n"],
+  "mappings": "AASA,SAAS,aAAa,WAAW,cAAc;AAE/C,SAAS,2BAA2B;AACpC,SAAS,6BAA6B;AAgB/B,SAAS,YAAY,SAAuC;AACjE,QAAM,UAAU,oBAAoB;AAEpC,QAAM,aAAa,OAAO,OAAO;AACjC,YAAU,MAAM;AACd,eAAW,UAAU;AAAA,EACvB,CAAC;AACD,SAAO;AAAA,IACL,CAAC,UAAuB,kBAA+B;AACrD,YAAM,EAAE,cAAc,mBAAmB,IAAI,WAAW;AACxD,YAAM,UAAU,SAAS,QAAQ,KAAK;AACtC,UAAI,CAAC,QAAS;AACd,UAAI,cAAc;AAChB,gBAAQ,SAAS,OAAO;AACxB;AAAA,MACF;AACA,UAAI,sBAAsB,EAAG;AAE7B,cAAQ,gBAAgB;AACxB,WAAK;AAAA,QACH,SAAS,yBAAyB,cAAc,eAAe;AAAA,QAC/D;AAAA,MACF;AAAA,IACF;AAAA,IACA,CAAC,OAAO;AAAA,EACV;AACF;",
+  "names": []
+}

package/dist/chat/useAutoSendDraft.js

@@ -0,0 +1,17 @@
+import { useEffect } from "react";
+import { selectDraft, useArbiSessionState, useArbiSessionStore } from "../session/index.js";
+function useAutoSendDraft(sendDraft, ready = true) {
+  const session = useArbiSessionStore();
+  const autoSendDraft = useArbiSessionState((state) => state.autoSendDraft);
+  useEffect(() => {
+    if (!autoSendDraft || !ready) return;
+    session.setAutoSendDraft(false);
+    if (selectDraft(session.getState()).trim()) {
+      sendDraft();
+    }
+  }, [autoSendDraft, ready, sendDraft, session]);
+}
+export {
+  useAutoSendDraft
+};
+//# sourceMappingURL=useAutoSendDraft.js.map

package/dist/chat/useAutoSendDraft.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/chat/useAutoSendDraft.ts"],
+  "sourcesContent": ["/**\n * Fires the composer's send once when a quick-access surface (the workspace\n * home's ask bar) handed over a draft that should send on arrival \u2014 the user\n * already pressed Enter there; asking for a second Enter here would turn one\n * action into two.\n *\n * `ready` defers consumption: the flag stays set (and the effect re-runs when\n * `ready` flips) so the send can wait for the page's context to assemble \u2014\n * concretely, the workspace documents that useDocumentAutoAdd attaches to a\n * new chat. Sending before that seeding posts the question with no documents,\n * which answers from nothing. The CALL SITE must sit after useDocumentAutoAdd\n * in the component: effects run in declaration order, so that placement is\n * what guarantees the seeding effect has run by the time this one fires.\n *\n * One-shot: the flag is cleared before sending, so a failed send never\n * retries itself.\n */\n\nimport { useEffect } from 'react'\nimport { selectDraft, useArbiSessionState, useArbiSessionStore } from '../session'\n\nexport function useAutoSendDraft(sendDraft: () => void, ready: boolean = true) {\n  const session = useArbiSessionStore()\n  const autoSendDraft = useArbiSessionState((state) => state.autoSendDraft)\n  useEffect(() => {\n    if (!autoSendDraft || !ready) return\n    session.setAutoSendDraft(false)\n    if (selectDraft(session.getState()).trim()) {\n      sendDraft()\n    }\n  }, [autoSendDraft, ready, sendDraft, session])\n}\n"],
+  "mappings": "AAkBA,SAAS,iBAAiB;AAC1B,SAAS,aAAa,qBAAqB,2BAA2B;AAE/D,SAAS,iBAAiB,WAAuB,QAAiB,MAAM;AAC7E,QAAM,UAAU,oBAAoB;AACpC,QAAM,gBAAgB,oBAAoB,CAAC,UAAU,MAAM,aAAa;AACxE,YAAU,MAAM;AACd,QAAI,CAAC,iBAAiB,CAAC,MAAO;AAC9B,YAAQ,iBAAiB,KAAK;AAC9B,QAAI,YAAY,QAAQ,SAAS,CAAC,EAAE,KAAK,GAAG;AAC1C,gBAAU;AAAA,IACZ;AAAA,EACF,GAAG,CAAC,eAAe,OAAO,WAAW,OAAO,CAAC;AAC/C;",
+  "names": []
+}

package/dist/chat/useBranchNavigation.js

@@ -0,0 +1,97 @@
+import { useMemo } from "react";
+import {
+  getSubagentBranchRecord
+} from "@arbidocs/sdk/browser";
+function useBranchNavigation(threads, parentMessageId, messageHistory, setParentMessageId) {
+  const branchPoints = useMemo(() => {
+    const points = /* @__PURE__ */ new Map();
+    if (!threads || threads.length <= 1) {
+      return points;
+    }
+    const messageToThreads = /* @__PURE__ */ new Map();
+    threads.forEach((thread) => {
+      thread.history.forEach((message) => {
+        const messageId = message.external_id;
+        if (!messageId) return;
+        if (!messageToThreads.has(messageId)) {
+          messageToThreads.set(messageId, []);
+        }
+        messageToThreads.get(messageId).push(thread);
+      });
+    });
+    messageToThreads.forEach((containingThreads, messageId) => {
+      if (containingThreads.length <= 1) return;
+      const message = messageHistory.find((m) => m.external_id === messageId);
+      if (!message) return;
+      const nextMessages = /* @__PURE__ */ new Map();
+      containingThreads.forEach((thread) => {
+        const messageIndex = thread.history.findIndex((m) => m.external_id === messageId);
+        if (messageIndex >= 0 && messageIndex < thread.history.length - 1) {
+          const nextMessage = thread.history[messageIndex + 1];
+          if (nextMessage.external_id && !getSubagentBranchRecord(nextMessage)) {
+            nextMessages.set(nextMessage.external_id, nextMessage);
+          }
+        }
+      });
+      if (nextMessages.size > 1) {
+        const branches = Array.from(nextMessages.values()).map((nextMsg) => ({
+          id: nextMsg.external_id,
+          content: nextMsg.content,
+          author: nextMsg.role,
+          threadId: containingThreads.find(
+            (thread) => thread.history.some((m) => m.external_id === nextMsg.external_id)
+          )?.leaf_message_ext_id || "",
+          parentId: messageId
+        }));
+        let currentBranchIndex = 0;
+        if (parentMessageId) {
+          let currentBranchIdx = branches.findIndex((branch) => branch.threadId === parentMessageId);
+          if (currentBranchIdx === -1) {
+            const selectedThread = threads.find((t) => t.leaf_message_ext_id === parentMessageId);
+            if (selectedThread) {
+              currentBranchIdx = branches.findIndex(
+                (branch) => selectedThread.history.some((msg) => msg.external_id === branch.id)
+              );
+            }
+          }
+          if (currentBranchIdx >= 0) {
+            currentBranchIndex = currentBranchIdx;
+          }
+        }
+        const branchPoint = {
+          parentId: messageId,
+          parentMessage: message,
+          branches,
+          currentBranchIndex
+        };
+        branches.forEach((branch) => {
+          points.set(branch.id, branchPoint);
+        });
+      }
+    });
+    return points;
+  }, [threads, parentMessageId, messageHistory]);
+  const getBranchControlForMessage = useMemo(() => {
+    return (messageId) => {
+      return branchPoints.get(messageId) || null;
+    };
+  }, [branchPoints]);
+  const switchBranch = useMemo(() => {
+    return (branchPoint, targetIndex) => {
+      if (targetIndex < 0 || targetIndex >= branchPoint.branches.length) {
+        return;
+      }
+      const targetBranch = branchPoint.branches[targetIndex];
+      setParentMessageId(targetBranch.threadId);
+    };
+  }, [setParentMessageId]);
+  return {
+    branchPoints,
+    getBranchControlForMessage,
+    switchBranch
+  };
+}
+export {
+  useBranchNavigation
+};
+//# sourceMappingURL=useBranchNavigation.js.map

package/dist/chat/useBranchNavigation.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/chat/useBranchNavigation.ts"],
+  "sourcesContent": ["import { useMemo } from 'react'\nimport {\n  getSubagentBranchRecord,\n  type ChatMessage as Message,\n  type Thread,\n} from '@arbidocs/sdk/browser'\n\n/** A message the conversation branches after: the replies it has, and the one viewed. */\nexport interface BranchPoint {\n  parentId: string\n  parentMessage: Message\n  branches: Array<{\n    id: string\n    content: string\n    author: string\n    threadId: string\n    parentId: string\n  }>\n  currentBranchIndex: number\n}\n\nexport interface BranchNavigation {\n  branchPoints: Map<string, BranchPoint>\n  getBranchControlForMessage: (messageId: string) => BranchPoint | null\n  switchBranch: (branchPoint: BranchPoint, targetIndex: number) => void\n}\n\n/**\n * Hook to analyze threads and identify branch points for navigation\n */\nexport function useBranchNavigation(\n  threads: Thread[] | undefined,\n  parentMessageId: string | null,\n  messageHistory: Message[],\n  setParentMessageId: (threadId: string) => void\n): BranchNavigation {\n  const branchPoints = useMemo(() => {\n    const points = new Map<string, BranchPoint>()\n\n    if (!threads || threads.length <= 1) {\n      return points\n    }\n\n    // Create a map of message ID to the threads that contain it\n    const messageToThreads = new Map<string, Thread[]>()\n\n    threads.forEach((thread) => {\n      thread.history.forEach((message) => {\n        const messageId = message.external_id\n        if (!messageId) return\n\n        if (!messageToThreads.has(messageId)) {\n          messageToThreads.set(messageId, [])\n        }\n        messageToThreads.get(messageId)!.push(thread)\n      })\n    })\n\n    // Find branch points - messages that appear in multiple threads and have different next messages\n    messageToThreads.forEach((containingThreads, messageId) => {\n      if (containingThreads.length <= 1) return\n\n      const message = messageHistory.find((m) => m.external_id === messageId)\n      if (!message) return\n\n      // Get the next messages for each thread that contains this message\n      const nextMessages = new Map<string, Message>()\n\n      containingThreads.forEach((thread) => {\n        const messageIndex = thread.history.findIndex((m) => m.external_id === messageId)\n        if (messageIndex >= 0 && messageIndex < thread.history.length - 1) {\n          const nextMessage = thread.history[messageIndex + 1]\n          // A sub-agent's task message is a DELEGATION off this point, not a\n          // reply variant \u2014 RunningSubagents (attached to the message itself)\n          // is how that thread is reached, not this branch-arrow counter.\n          // Excluding it here keeps \"Branch N of M\" meaning what it says:\n          // alternative attempts at the same reply, never a mix of those and\n          // captive sub-agent runs.\n          if (nextMessage.external_id && !getSubagentBranchRecord(nextMessage)) {\n            nextMessages.set(nextMessage.external_id, nextMessage)\n          }\n        }\n      })\n\n      // If there are multiple different next messages, this is a branch point\n      if (nextMessages.size > 1) {\n        const branches = Array.from(nextMessages.values()).map((nextMsg) => ({\n          id: nextMsg.external_id!,\n          content: nextMsg.content,\n          author: nextMsg.role,\n          threadId:\n            containingThreads.find((thread) =>\n              thread.history.some((m) => m.external_id === nextMsg.external_id)\n            )?.leaf_message_ext_id || '',\n          parentId: messageId,\n        }))\n\n        // Find current branch index based on selected thread\n        let currentBranchIndex = 0\n        if (parentMessageId) {\n          // First try exact match with thread leaf ID\n          let currentBranchIdx = branches.findIndex((branch) => branch.threadId === parentMessageId)\n\n          // If no exact match, check if the selected thread contains any of the branch messages\n          if (currentBranchIdx === -1) {\n            const selectedThread = threads.find((t) => t.leaf_message_ext_id === parentMessageId)\n            if (selectedThread) {\n              currentBranchIdx = branches.findIndex((branch) =>\n                selectedThread.history.some((msg) => msg.external_id === branch.id)\n              )\n            }\n          }\n\n          if (currentBranchIdx >= 0) {\n            currentBranchIndex = currentBranchIdx\n          }\n        }\n\n        const branchPoint: BranchPoint = {\n          parentId: messageId,\n          parentMessage: message,\n          branches,\n          currentBranchIndex,\n        }\n\n        // Add branch point for each branch message (the messages that come after the branch point)\n        branches.forEach((branch) => {\n          points.set(branch.id, branchPoint)\n        })\n      }\n    })\n\n    return points\n  }, [threads, parentMessageId, messageHistory])\n\n  const getBranchControlForMessage = useMemo(() => {\n    return (messageId: string): BranchPoint | null => {\n      return branchPoints.get(messageId) || null\n    }\n  }, [branchPoints])\n\n  const switchBranch = useMemo(() => {\n    return (branchPoint: BranchPoint, targetIndex: number) => {\n      if (targetIndex < 0 || targetIndex >= branchPoint.branches.length) {\n        return\n      }\n\n      const targetBranch = branchPoint.branches[targetIndex]\n      setParentMessageId(targetBranch.threadId)\n    }\n  }, [setParentMessageId])\n\n  return {\n    branchPoints,\n    getBranchControlForMessage,\n    switchBranch,\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/chat/useConnectRunStream.js

@@ -0,0 +1,169 @@
+import { useEffect, useRef } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { getRunToAttach } from "@arbidocs/sdk/browser";
+import { useArbi } from "../useArbi.js";
+import { useArbiSessionState, useArbiSessionStore } from "../session/index.js";
+import {
+  applyOutputItemToMessage,
+  clearLoadingState,
+  completeQueuedUserMessageByContent,
+  ensureAssistantMessageLoading,
+  flushStreamingTokens,
+  getInterjectionText,
+  getRunStartedAt,
+  getThreadsQueryKey,
+  isMessageRunning,
+  setMessageContent,
+  updateMessageWithMetadata
+} from "./conversation-cache.js";
+import { registerAttachedRun } from "./turn-control.js";
+const RECONNECT_DELAY_MS = 2e3;
+const MAX_RECONNECTS = 5;
+function useConnectRunStream(conversationId, messages) {
+  const generation = useArbiSessionState(
+    (s) => conversationId ? s.generating[conversationId] : void 0
+  );
+  const responseId = conversationId ? getRunToAttach(generation, messages) : null;
+  useAttachRun(conversationId, responseId);
+}
+function useAttachRun(conversationId, responseId) {
+  const queryClient = useQueryClient();
+  const session = useArbiSessionStore();
+  const arbi = useArbi();
+  const arbiRef = useRef(arbi);
+  arbiRef.current = arbi;
+  useEffect(() => {
+    if (!conversationId || !responseId) return;
+    let disposed = false;
+    let controller = new AbortController();
+    let retryTimer;
+    let reconnects = 0;
+    const runStartedAt = session.getState().messageTimers[`${conversationId}:${responseId}`]?.startTime;
+    session.setConversationGenerating(conversationId, true, null);
+    session.setStreamingAssistantId(
+      conversationId,
+      responseId,
+      runStartedAt ?? getRunStartedAt(queryClient, conversationId, responseId) ?? Date.now()
+    );
+    const settle = (refetch) => {
+      session.setConversationGenerating(conversationId, false, null);
+      session.clearAgentControl(responseId);
+      clearLoadingState(queryClient, conversationId);
+      if (refetch) {
+        void queryClient.invalidateQueries({ queryKey: getThreadsQueryKey(conversationId) });
+      }
+    };
+    const markLoading = () => ensureAssistantMessageLoading(queryClient, conversationId, responseId);
+    const endedEarly = async () => {
+      flushStreamingTokens(queryClient);
+      await queryClient.invalidateQueries({ queryKey: getThreadsQueryKey(conversationId) });
+      if (disposed) return;
+      if (isMessageRunning(queryClient, conversationId, responseId) && reconnects < MAX_RECONNECTS) {
+        reconnects += 1;
+        markLoading();
+        retryTimer = setTimeout(connect, RECONNECT_DELAY_MS);
+        return;
+      }
+      settle(false);
+      if (isMessageRunning(queryClient, conversationId, responseId)) {
+        window.removeEventListener("online", reconnectWhenOnline);
+        window.addEventListener("online", reconnectWhenOnline, { once: true });
+      }
+    };
+    const reconnectWhenOnline = () => {
+      if (disposed || session.getState().generating[conversationId]?.isGenerating) return;
+      reconnects = 0;
+      session.setConversationGenerating(conversationId, true, null);
+      connect();
+    };
+    const connect = () => {
+      markLoading();
+      controller = new AbortController();
+      let ended = false;
+      arbiRef.current.assistant.attachRun(responseId, {
+        signal: controller.signal,
+        // The reconnect learns its conversation from the stream; we already know it, but assert
+        // the match so a stray attach on a mismatched cache can't write to the wrong conversation.
+        onUserMessage: (userMessage) => {
+          if (disposed) return;
+          if (userMessage.conversation_ext_id && userMessage.conversation_ext_id !== conversationId) {
+            disposed = true;
+          }
+        },
+        onOutputItemDone: (ev) => {
+          if (disposed) return;
+          reconnects = 0;
+          applyOutputItemToMessage(queryClient, conversationId, responseId, ev);
+          const interjection = getInterjectionText(ev.item);
+          if (interjection) {
+            completeQueuedUserMessageByContent(queryClient, conversationId, interjection);
+            session.consumeQueuedMessage(responseId, interjection);
+          }
+          const item = ev.item;
+          if (item?.type === "message" && item.arbi?.label === "Answered") {
+            const text = Array.isArray(item.content) ? item.content.map((c) => c.text ?? "").join("") : "";
+            if (text) setMessageContent(queryClient, conversationId, responseId, text);
+          }
+        },
+        onAgentControlState: (event) => {
+          if (disposed) return;
+          session.setAgentControlState(responseId, event.state);
+        },
+        // The authoritative message, and the only frame that carries the answer with its citation
+        // markers applied plus the `tools.model_citations` map they resolve through. The
+        // "Answered" item above carries the model's raw text, which predates both, so without
+        // this an attacher rendered a citation-free answer. Relying on the settle(true) refetch
+        // is not enough: the cleanup path settles WITHOUT a refetch, and sets `disposed` first,
+        // so a viewer who leaves as the run ends never gets the reconciliation.
+        onMetadata: (metadata) => {
+          if (disposed) return;
+          const { type: _type, ...messageData } = metadata;
+          updateMessageWithMetadata(queryClient, conversationId, responseId, messageData);
+        },
+        // onTextDone intentionally omitted: it fires for EVERY settled message item (narration
+        // included) and, being label-blind, would overwrite the streamed body. The terminal
+        // answer is applied above from the "Answered" item, then replaced by the authoritative
+        // metadata content in onMetadata.
+        onComplete: () => {
+          if (disposed) return;
+          ended = true;
+          flushStreamingTokens(queryClient);
+          settle(true);
+        },
+        onError: () => {
+          if (disposed) return;
+          ended = true;
+          void endedEarly();
+        }
+      }).then(() => {
+        if (disposed || ended) return;
+        void endedEarly();
+      }).catch(() => {
+        if (disposed) return;
+        void endedEarly();
+      });
+    };
+    connect();
+    const stop = () => {
+      if (disposed) return;
+      disposed = true;
+      clearTimeout(retryTimer);
+      window.removeEventListener("online", reconnectWhenOnline);
+      controller.abort();
+      settle(true);
+    };
+    const unregister = registerAttachedRun(conversationId, responseId, stop);
+    return () => {
+      unregister();
+      disposed = true;
+      clearTimeout(retryTimer);
+      window.removeEventListener("online", reconnectWhenOnline);
+      controller.abort();
+      settle(false);
+    };
+  }, [conversationId, responseId, queryClient, session]);
+}
+export {
+  useConnectRunStream
+};
+//# sourceMappingURL=useConnectRunStream.js.map