@arbidocs/react 0.5.110 → 0.5.112

package/dist/search/useSemanticSearch.js

@@ -0,0 +1,82 @@
+import { useCallback, useEffect, useState, useSyncExternalStore } from "react";
+import { searchChunks } from "@arbidocs/sdk/browser";
+import { useArbi } from "../useArbi.js";
+import {
+  clearSearchSession,
+  createSearchSession
+} from "./session.js";
+const IDLE = {
+  query: "",
+  results: [],
+  searched: false,
+  status: "idle",
+  error: null
+};
+function useSemanticSearch(docIds = [], options = {}) {
+  const arbi = useArbi();
+  const [ownSession] = useState(createSearchSession);
+  const session = options.session ?? ownSession;
+  const { model, workspaceId } = options;
+  const state = useSyncExternalStore(session.subscribe, session.getState, session.getState);
+  const foreign = !!workspaceId && !!state.workspaceId && state.workspaceId !== workspaceId;
+  useEffect(() => {
+    if (!workspaceId) return;
+    const current = session.getState().workspaceId;
+    if (current !== workspaceId) {
+      if (current) clearSearchSession(workspaceId, session);
+      else session.setState({ workspaceId });
+    }
+  }, [session, workspaceId]);
+  const search = useCallback(
+    async (query, mode = "hybrid") => {
+      const trimmed = query.trim();
+      if (!trimmed) {
+        clearSearchSession(void 0, session);
+        return;
+      }
+      const run = session.getState().run + 1;
+      const searched = workspaceId ?? session.getState().workspaceId ?? void 0;
+      session.setState((s) => ({
+        query: trimmed,
+        status: "running",
+        error: null,
+        run,
+        workspaceId: workspaceId ?? s.workspaceId
+      }));
+      try {
+        const result = await arbi.assistant.retrieve(trimmed, docIds, {
+          searchMode: mode,
+          store: false,
+          ...model ? { model } : {},
+          ...searched ? { workspaceId: searched } : {}
+        });
+        if (session.getState().run !== run) return;
+        session.setState({ results: searchChunks(result), searched: true, status: "done" });
+      } catch (error) {
+        if (session.getState().run !== run) return;
+        session.setState({
+          status: "error",
+          error: error instanceof Error ? error.message : "Search failed"
+        });
+      }
+    },
+    [arbi, docIds, model, session, workspaceId]
+  );
+  const clear = useCallback(() => clearSearchSession(void 0, session), [session]);
+  const shown = foreign ? IDLE : state;
+  return {
+    query: shown.query,
+    results: shown.results,
+    searched: shown.searched,
+    status: shown.status,
+    error: shown.error,
+    isRunning: shown.status === "running",
+    search,
+    clear,
+    session
+  };
+}
+export {
+  useSemanticSearch
+};
+//# sourceMappingURL=useSemanticSearch.js.map

package/dist/search/useSemanticSearch.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/search/useSemanticSearch.ts"],
+  "sourcesContent": ["/**\n * Search documents for passages: retrieval only, no LLM answer. One implementation for every\n * search surface (the search page, the \u2318K palette, a compact doc search).\n */\nimport { useCallback, useEffect, useState, useSyncExternalStore } from 'react'\nimport { searchChunks, type SearchChunk } from '@arbidocs/sdk/browser'\nimport { useArbi } from '../useArbi'\nimport {\n  clearSearchSession,\n  createSearchSession,\n  type SearchSession,\n  type SearchSessionState,\n  type SearchStatus,\n} from './session'\n\nexport type SearchMode = 'semantic' | 'keyword' | 'hybrid'\n\nexport interface SemanticSearchOptions {\n  /** The assistant configuration the search runs with; default the server's. */\n  model?: string\n  /**\n   * Where the search lives. Default: this component's own (gone when it unmounts). Pass\n   * `sharedSearchSession` for a page whose results outlive it.\n   */\n  session?: SearchSession\n  /**\n   * The workspace searched (default: the current one). The request names it; a session holding\n   * another workspace's search starts over.\n   */\n  workspaceId?: string | null\n}\n\nexport interface SemanticSearch {\n  /** The query last searched. */\n  query: string\n  /** Its passages, best first. */\n  results: SearchChunk[]\n  /** A search has finished with results to show (they stay while the next one runs). */\n  searched: boolean\n  status: SearchStatus\n  error: string | null\n  isRunning: boolean\n  /** Search; an empty query clears. */\n  search: (query: string, mode?: SearchMode) => Promise<void>\n  /** Back to nothing searched. */\n  clear: () => void\n  session: SearchSession\n}\n\nconst IDLE: Pick<SearchSessionState, 'query' | 'results' | 'searched' | 'status' | 'error'> = {\n  query: '',\n  results: [],\n  searched: false,\n  status: 'idle',\n  error: null,\n}\n\n/**\n * Search `docIds` (none: the whole workspace) and return the matching passages. The reply is\n * ranked by the SDK's `searchChunks`; nothing is kept server-side.\n */\nexport function useSemanticSearch(\n  docIds: string[] = [],\n  options: SemanticSearchOptions = {}\n): SemanticSearch {\n  const arbi = useArbi()\n  const [ownSession] = useState(createSearchSession)\n  const session = options.session ?? ownSession\n  const { model, workspaceId } = options\n  const state = useSyncExternalStore(session.subscribe, session.getState, session.getState)\n\n  // Another workspace's search is not this one's: start over.\n  const foreign = !!workspaceId && !!state.workspaceId && state.workspaceId !== workspaceId\n  useEffect(() => {\n    if (!workspaceId) return\n    const current = session.getState().workspaceId\n    if (current !== workspaceId) {\n      if (current) clearSearchSession(workspaceId, session)\n      else session.setState({ workspaceId })\n    }\n  }, [session, workspaceId])\n\n  const search = useCallback(\n    async (query: string, mode: SearchMode = 'hybrid') => {\n      const trimmed = query.trim()\n      if (!trimmed) {\n        clearSearchSession(undefined, session)\n        return\n      }\n      const run = session.getState().run + 1\n      // The workspace searched, captured now: the request names it (opened for this session if it\n      // is not the current one), so a switch while it runs cannot answer it from another workspace.\n      const searched = workspaceId ?? session.getState().workspaceId ?? undefined\n      session.setState((s) => ({\n        query: trimmed,\n        status: 'running',\n        error: null,\n        run,\n        workspaceId: workspaceId ?? s.workspaceId,\n      }))\n      try {\n        const result = await arbi.assistant.retrieve(trimmed, docIds, {\n          searchMode: mode,\n          store: false,\n          ...(model ? { model } : {}),\n          ...(searched ? { workspaceId: searched } : {}),\n        })\n        if (session.getState().run !== run) return\n        session.setState({ results: searchChunks(result), searched: true, status: 'done' })\n      } catch (error) {\n        if (session.getState().run !== run) return\n        session.setState({\n          status: 'error',\n          error: error instanceof Error ? error.message : 'Search failed',\n        })\n      }\n    },\n    [arbi, docIds, model, session, workspaceId]\n  )\n\n  const clear = useCallback(() => clearSearchSession(undefined, session), [session])\n\n  const shown = foreign ? IDLE : state\n  return {\n    query: shown.query,\n    results: shown.results,\n    searched: shown.searched,\n    status: shown.status,\n    error: shown.error,\n    isRunning: shown.status === 'running',\n    search,\n    clear,\n    session,\n  }\n}\n"],
+  "mappings": "AAIA,SAAS,aAAa,WAAW,UAAU,4BAA4B;AACvE,SAAS,oBAAsC;AAC/C,SAAS,eAAe;AACxB;AAAA,EACE;AAAA,EACA;AAAA,OAIK;AAoCP,MAAM,OAAwF;AAAA,EAC5F,OAAO;AAAA,EACP,SAAS,CAAC;AAAA,EACV,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,OAAO;AACT;AAMO,SAAS,kBACd,SAAmB,CAAC,GACpB,UAAiC,CAAC,GAClB;AAChB,QAAM,OAAO,QAAQ;AACrB,QAAM,CAAC,UAAU,IAAI,SAAS,mBAAmB;AACjD,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,EAAE,OAAO,YAAY,IAAI;AAC/B,QAAM,QAAQ,qBAAqB,QAAQ,WAAW,QAAQ,UAAU,QAAQ,QAAQ;AAGxF,QAAM,UAAU,CAAC,CAAC,eAAe,CAAC,CAAC,MAAM,eAAe,MAAM,gBAAgB;AAC9E,YAAU,MAAM;AACd,QAAI,CAAC,YAAa;AAClB,UAAM,UAAU,QAAQ,SAAS,EAAE;AACnC,QAAI,YAAY,aAAa;AAC3B,UAAI,QAAS,oBAAmB,aAAa,OAAO;AAAA,UAC/C,SAAQ,SAAS,EAAE,YAAY,CAAC;AAAA,IACvC;AAAA,EACF,GAAG,CAAC,SAAS,WAAW,CAAC;AAEzB,QAAM,SAAS;AAAA,IACb,OAAO,OAAe,OAAmB,aAAa;AACpD,YAAM,UAAU,MAAM,KAAK;AAC3B,UAAI,CAAC,SAAS;AACZ,2BAAmB,QAAW,OAAO;AACrC;AAAA,MACF;AACA,YAAM,MAAM,QAAQ,SAAS,EAAE,MAAM;AAGrC,YAAM,WAAW,eAAe,QAAQ,SAAS,EAAE,eAAe;AAClE,cAAQ,SAAS,CAAC,OAAO;AAAA,QACvB,OAAO;AAAA,QACP,QAAQ;AAAA,QACR,OAAO;AAAA,QACP;AAAA,QACA,aAAa,eAAe,EAAE;AAAA,MAChC,EAAE;AACF,UAAI;AACF,cAAM,SAAS,MAAM,KAAK,UAAU,SAAS,SAAS,QAAQ;AAAA,UAC5D,YAAY;AAAA,UACZ,OAAO;AAAA,UACP,GAAI,QAAQ,EAAE,MAAM,IAAI,CAAC;AAAA,UACzB,GAAI,WAAW,EAAE,aAAa,SAAS,IAAI,CAAC;AAAA,QAC9C,CAAC;AACD,YAAI,QAAQ,SAAS,EAAE,QAAQ,IAAK;AACpC,gBAAQ,SAAS,EAAE,SAAS,aAAa,MAAM,GAAG,UAAU,MAAM,QAAQ,OAAO,CAAC;AAAA,MACpF,SAAS,OAAO;AACd,YAAI,QAAQ,SAAS,EAAE,QAAQ,IAAK;AACpC,gBAAQ,SAAS;AAAA,UACf,QAAQ;AAAA,UACR,OAAO,iBAAiB,QAAQ,MAAM,UAAU;AAAA,QAClD,CAAC;AAAA,MACH;AAAA,IACF;AAAA,IACA,CAAC,MAAM,QAAQ,OAAO,SAAS,WAAW;AAAA,EAC5C;AAEA,QAAM,QAAQ,YAAY,MAAM,mBAAmB,QAAW,OAAO,GAAG,CAAC,OAAO,CAAC;AAEjF,QAAM,QAAQ,UAAU,OAAO;AAC/B,SAAO;AAAA,IACL,OAAO,MAAM;AAAA,IACb,SAAS,MAAM;AAAA,IACf,UAAU,MAAM;AAAA,IAChB,QAAQ,MAAM;AAAA,IACd,OAAO,MAAM;AAAA,IACb,WAAW,MAAM,WAAW;AAAA,IAC5B;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/session/chat.js

@@ -0,0 +1,512 @@
+import {
+  agentControl,
+  queuedMessages
+} from "../chat/run-state.js";
+import { threadTabId } from "./thread-tabs.js";
+const EMPTY_CHAT_STATE = {
+  conversationId: null,
+  generating: {},
+  paMode: false,
+  conversationDocuments: {},
+  conversationDocumentAutoAdd: {},
+  conversationFacts: {},
+  cursor: null,
+  suggestedQuery: null,
+  queuedMessages: {},
+  agentControlStates: {},
+  agentProbeAnswers: {},
+  agentProbePending: {},
+  drafts: {},
+  editingMessageId: null,
+  deepLinkMessageId: null,
+  activeCitationKey: null,
+  chatModel: void 0,
+  chatModelName: void 0,
+  newConversationAssistantMode: "always",
+  pendingTools: null,
+  autoSendDraft: false,
+  agentChatOwners: {},
+  newAgentChat: null,
+  newChatDocumentId: null,
+  messageTimers: {}
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isString = (v) => typeof v === "string";
+const stringOrNull = (v) => isString(v) ? v : null;
+const recordOf = (value, read) => {
+  if (!isRecord(value)) return {};
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const parsed = read(entry);
+    if (parsed !== null) out[key] = parsed;
+  }
+  return out;
+};
+const readDocuments = (value) => Array.isArray(value) ? value.filter((doc) => isRecord(doc) && isString(doc.docId)).map((doc) => ({ docId: doc.docId, isPinned: doc.isPinned === true })) : null;
+const readFacts = (value) => Array.isArray(value) ? Array.from(new Set(value.filter(isString))) : null;
+function parseSavedChat(saved) {
+  if (!isRecord(saved) || saved.version !== 1) return null;
+  return {
+    version: 1,
+    migrated: Array.isArray(saved.migrated) ? saved.migrated.filter(isString) : [],
+    conversationId: stringOrNull(saved.conversationId),
+    cursor: stringOrNull(saved.cursor),
+    conversationDocuments: recordOf(saved.conversationDocuments, readDocuments),
+    conversationDocumentAutoAdd: recordOf(
+      saved.conversationDocumentAutoAdd,
+      (v) => typeof v === "boolean" ? v : null
+    ),
+    conversationFacts: recordOf(saved.conversationFacts, readFacts),
+    agentChatOwners: recordOf(saved.agentChatOwners, (v) => isString(v) ? v : null),
+    agentChatOwnersUser: stringOrNull(saved.agentChatOwnersUser),
+    chatModel: stringOrNull(saved.chatModel)
+  };
+}
+function savedChatOf(state, migrated, agentChatOwnersUser = null) {
+  return {
+    version: 1,
+    migrated,
+    conversationId: state.conversationId,
+    cursor: state.cursor,
+    conversationDocuments: state.conversationDocuments,
+    conversationDocumentAutoAdd: { ...state.conversationDocumentAutoAdd },
+    conversationFacts: state.conversationFacts,
+    agentChatOwners: { ...state.agentChatOwners },
+    agentChatOwnersUser,
+    chatModel: state.chatModel ?? null
+  };
+}
+const SAVED_FIELDS = [
+  "conversationId",
+  "cursor",
+  "conversationDocuments",
+  "conversationDocumentAutoAdd",
+  "conversationFacts",
+  "agentChatOwners",
+  "chatModel"
+];
+function withoutNew(record) {
+  const saved = { ...record };
+  delete saved.new;
+  return saved;
+}
+function moveKey(record, fromId, toId) {
+  if (!(fromId in record)) return record;
+  const next = { ...record, [toId]: record[fromId] };
+  delete next[fromId];
+  return next;
+}
+const NO_EDIT = { draft: "", cursor: null };
+function createArbiChatStore({
+  layout,
+  persist,
+  draftStorage,
+  scrollTop = () => null,
+  user = () => draftStorage?.owner() ?? null,
+  initial
+}) {
+  let state = { ...EMPTY_CHAT_STATE, ...initial };
+  let migrated = [];
+  let ownersUser = null;
+  let isHydrated = !persist;
+  const listeners = /* @__PURE__ */ new Set();
+  const waiting = /* @__PURE__ */ new Set();
+  let depth = 0;
+  const settle = (listener) => depth > 0 ? waiting.add(listener) : listener();
+  const notify = () => listeners.forEach(settle);
+  const batch = (change) => {
+    depth += 1;
+    try {
+      return change();
+    } finally {
+      depth -= 1;
+      if (depth === 0) {
+        const told = [...waiting];
+        waiting.clear();
+        told.forEach((listener) => listener());
+      }
+    }
+  };
+  const save = () => {
+    if (persist && isHydrated) persist.save(savedChatOf(state, migrated, ownersUser));
+  };
+  const update = (patch) => {
+    const next = { ...state, ...patch };
+    const saved = SAVED_FIELDS.some((key) => next[key] !== state[key]);
+    state = next;
+    notify();
+    if (saved) save();
+  };
+  let preEdit = NO_EDIT;
+  let draftsRestored = !draftStorage;
+  let restoring = false;
+  let draftsOwner = draftStorage?.owner() ?? null;
+  const setDrafts = (drafts) => {
+    if (drafts === state.drafts) return;
+    update({ drafts });
+    if (draftsRestored) draftStorage?.save(drafts);
+  };
+  const setDraftOf = (key, text) => {
+    if ((state.drafts[key] ?? "") === text) return;
+    const drafts = { ...state.drafts };
+    if (text) drafts[key] = text;
+    else delete drafts[key];
+    setDrafts(drafts);
+  };
+  const keptDrafts = (drafts) => {
+    const open = new Set(layout.getLayout().tabs.threads.map(threadTabId));
+    open.add(state.conversationId ?? "new");
+    const keys = Object.keys(drafts);
+    if (keys.every((key) => open.has(key))) return drafts;
+    return Object.fromEntries(keys.filter((key) => open.has(key)).map((key) => [key, drafts[key]]));
+  };
+  const restoreDrafts = () => {
+    if (!draftStorage) return;
+    const owner = draftStorage.owner();
+    if (owner !== draftsOwner) {
+      if (draftsOwner !== null) update({ drafts: {} });
+      draftsOwner = owner;
+      draftsRestored = false;
+    }
+    if (draftsRestored || restoring || owner === null) return;
+    restoring = true;
+    void Promise.all([layout.hydrated(), hydration]).then(() => draftStorage.load()).then(
+      (saved) => {
+        restoring = false;
+        if (!saved || draftStorage.owner() !== owner) return;
+        draftsRestored = true;
+        setDrafts(keptDrafts({ ...saved, ...state.drafts }));
+        draftStorage.save(state.drafts);
+      },
+      () => {
+        restoring = false;
+      }
+    );
+  };
+  draftStorage?.onClear(() => {
+    draftsRestored = false;
+    draftsOwner = null;
+    preEdit = NO_EDIT;
+    if (Object.keys(state.drafts).length > 0) update({ drafts: {} });
+  });
+  const composer = () => ({
+    conversationId: state.conversationId,
+    view: {
+      cursor: state.cursor,
+      editingMessageId: state.editingMessageId,
+      preEditDraft: state.editingMessageId ? preEdit.draft : null,
+      preEditCursor: state.editingMessageId ? preEdit.cursor : null,
+      chatModel: state.chatModel,
+      chatModelName: state.chatModelName,
+      scrollTop: scrollTop()
+    }
+  });
+  const show = (next) => {
+    if (next === null) return;
+    const target = next === "list" ? { conversationId: null, view: void 0 } : next;
+    const view = target.view;
+    preEdit = view ? { draft: view.preEditDraft ?? "", cursor: view.preEditCursor ?? null } : NO_EDIT;
+    update({
+      conversationId: target.conversationId,
+      cursor: view?.cursor ?? null,
+      editingMessageId: view?.editingMessageId ?? null,
+      chatModel: view?.chatModel,
+      chatModelName: view?.chatModelName
+    });
+    if (!view) setDraftOf(target.conversationId ?? "new", "");
+  };
+  const afterTabs = () => setDrafts(keptDrafts(state.drafts));
+  const openThreadTab = (conversationId) => batch(() => {
+    update(
+      conversationId === null ? { newAgentChat: null, newChatDocumentId: null } : { newAgentChat: null }
+    );
+    const { tabId, show: next } = layout.threads.open(conversationId, composer());
+    show(next);
+    layout.setPageTab("conversations", tabId);
+    afterTabs();
+    return tabId;
+  });
+  const hydration = persist ? persist.load().then(
+    (saved) => {
+      const parsed = parseSavedChat(saved);
+      if (parsed) {
+        migrated = parsed.migrated;
+        ownersUser ??= parsed.agentChatOwnersUser;
+        const conversationId = state.conversationId ?? parsed.conversationId;
+        const savedOpen = conversationId === parsed.conversationId;
+        state = {
+          ...state,
+          conversationId,
+          cursor: state.cursor ?? (savedOpen ? parsed.cursor : null),
+          chatModel: state.chatModel ?? (savedOpen ? parsed.chatModel ?? void 0 : void 0),
+          conversationDocuments: {
+            ...parsed.conversationDocuments,
+            ...state.conversationDocuments
+          },
+          conversationDocumentAutoAdd: {
+            ...parsed.conversationDocumentAutoAdd,
+            ...state.conversationDocumentAutoAdd
+          },
+          conversationFacts: { ...parsed.conversationFacts, ...state.conversationFacts },
+          agentChatOwners: { ...parsed.agentChatOwners, ...state.agentChatOwners }
+        };
+      }
+      isHydrated = true;
+      notify();
+    },
+    () => {
+      isHydrated = true;
+      notify();
+    }
+  ) : Promise.resolve();
+  void Promise.all([layout.hydrated(), hydration]).then(() => {
+    const { threads, activeThread } = layout.getLayout().tabs;
+    const tab = activeThread ? threads.find((t) => threadTabId(t) === activeThread) : null;
+    if (tab && state.conversationId !== tab.conversationId)
+      update({ conversationId: tab.conversationId });
+  });
+  const generationOf = (conversationId) => state.generating[conversationId];
+  const setGeneration = (conversationId, generation) => update({ generating: { ...state.generating, [conversationId]: generation } });
+  const stopAll = () => Object.values(state.generating).forEach((generation) => generation.abortController?.abort());
+  return {
+    getState: () => state,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+        waiting.delete(listener);
+      };
+    },
+    settled: (listener) => () => settle(listener),
+    forget: (listener) => void waiting.delete(listener),
+    batch,
+    hydrated: () => hydration,
+    isHydrated: () => isHydrated,
+    restoreDrafts,
+    leave: () => batch(() => {
+      stopAll();
+      preEdit = NO_EDIT;
+      update({
+        conversationId: null,
+        cursor: null,
+        editingMessageId: null,
+        chatModel: void 0,
+        chatModelName: void 0,
+        newConversationAssistantMode: "always",
+        paMode: false,
+        generating: {},
+        // Saved conversations keep their documents; the unsent new chat's belong to this workspace.
+        conversationDocuments: withoutNew(state.conversationDocuments),
+        conversationDocumentAutoAdd: withoutNew(state.conversationDocumentAutoAdd),
+        conversationFacts: {},
+        newAgentChat: null,
+        newChatDocumentId: null,
+        messageTimers: {}
+      });
+      layout.threads.clear();
+      setDrafts({});
+    }),
+    reset: () => batch(() => {
+      stopAll();
+      preEdit = NO_EDIT;
+      const signedIn = user();
+      const keepOwners = signedIn === null || ownersUser === null || signedIn === ownersUser;
+      if (signedIn !== null) ownersUser = signedIn;
+      update({ ...EMPTY_CHAT_STATE, agentChatOwners: keepOwners ? state.agentChatOwners : {} });
+    }),
+    setConversationId: (id) => void openThreadTab(id),
+    openThreadTab,
+    closeThreadTab: (tabId) => batch(() => {
+      show(layout.threads.close(tabId));
+      layout.setPageTab("conversations", layout.getLayout().tabs.activeThread ?? "history");
+      afterTabs();
+    }),
+    selectThreadTab: (tabId) => batch(() => {
+      if (tabId !== null) {
+        show(layout.threads.select(tabId, composer()));
+        layout.setPageTab("conversations", tabId);
+        return;
+      }
+      layout.threads.showList(composer());
+      preEdit = NO_EDIT;
+      update({ conversationId: null, cursor: null, editingMessageId: null });
+      layout.setPageTab("conversations", "history");
+      afterTabs();
+    }),
+    moveConversation: (fromId, toId) => batch(() => {
+      update({
+        generating: moveKey(state.generating, fromId, toId),
+        conversationDocuments: moveKey(state.conversationDocuments, fromId, toId),
+        conversationDocumentAutoAdd: moveKey(state.conversationDocumentAutoAdd, fromId, toId),
+        conversationFacts: moveKey(state.conversationFacts, fromId, toId),
+        conversationId: state.conversationId ?? toId
+      });
+      layout.threads.rename(fromId, toId);
+      setDrafts(moveKey(state.drafts, fromId, toId));
+    }),
+    setConversationGenerating: (conversationId, isGenerating, abortController) => {
+      const current = generationOf(conversationId);
+      setGeneration(conversationId, {
+        ...current,
+        isGenerating,
+        error: isGenerating ? null : current?.error ?? null,
+        // Starting with an explicit null means generation this client does not own (an attach to a
+        // run started elsewhere): it must not inherit a finished local turn's controller, or the
+        // view takes it for a local stream and detaches, which makes it attachable again (an
+        // endless loop that froze the tab after Stop). Stopping keeps the controller: the finished
+        // turn's bookkeeping still matches on it.
+        abortController: isGenerating && abortController === null ? null : abortController ?? current?.abortController ?? null,
+        // The run's start is set when the server names its answer (setStreamingAssistantId).
+        startTime: null,
+        streamingAssistantId: null,
+        ...isGenerating ? { lastFailedMessage: null, backendElapsed: null } : {}
+      });
+    },
+    setStreamingAssistantId: (conversationId, streamingAssistantId, startTime = Date.now()) => setGeneration(conversationId, {
+      ...generationOf(conversationId) ?? { isGenerating: false, error: null },
+      streamingAssistantId,
+      startTime
+    }),
+    setBackendElapsed: (conversationId, backendElapsed) => setGeneration(conversationId, {
+      ...generationOf(conversationId) ?? { isGenerating: false, error: null, startTime: null },
+      backendElapsed
+    }),
+    setConversationError: (conversationId, error, lastFailedMessage) => {
+      const current = generationOf(conversationId);
+      setGeneration(conversationId, {
+        ...current,
+        isGenerating: false,
+        error,
+        startTime: current?.startTime ?? null,
+        lastFailedMessage: lastFailedMessage ?? current?.lastFailedMessage ?? null
+      });
+    },
+    clearConversationError: (conversationId) => setGeneration(conversationId, {
+      ...generationOf(conversationId) ?? { isGenerating: false, startTime: null },
+      error: null,
+      lastFailedMessage: null
+    }),
+    abortConversationGeneration: (conversationId) => {
+      const current = generationOf(conversationId);
+      current?.abortController?.abort();
+      setGeneration(conversationId, {
+        ...current ?? { error: null, startTime: null },
+        isGenerating: false,
+        abortController: null
+      });
+    },
+    setPaMode: (paMode) => {
+      if (state.paMode !== paMode) update({ paMode });
+    },
+    setConversationDocuments: (conversationId, documents, autoAdd = false) => update({
+      conversationDocuments: { ...state.conversationDocuments, [conversationId]: documents },
+      conversationDocumentAutoAdd: {
+        ...state.conversationDocumentAutoAdd,
+        [conversationId]: autoAdd
+      }
+    }),
+    setConversationFacts: (conversationId, factIds) => update({
+      conversationFacts: {
+        ...state.conversationFacts,
+        [conversationId]: Array.from(new Set(factIds))
+      }
+    }),
+    setCursor: (cursor) => {
+      if (state.cursor !== cursor) update({ cursor });
+    },
+    setSuggestedQuery: (suggestedQuery) => update({ suggestedQuery }),
+    addQueuedMessage: (id, message) => update({ queuedMessages: queuedMessages.add(state.queuedMessages, id, message) }),
+    acknowledgeQueuedMessage: (clientId, serverId) => update({
+      queuedMessages: queuedMessages.acknowledge(state.queuedMessages, clientId, serverId)
+    }),
+    removeQueuedMessage: (clientId) => update({ queuedMessages: queuedMessages.remove(state.queuedMessages, clientId) }),
+    removeQueuedMessageByServerId: (serverId) => update({ queuedMessages: queuedMessages.removeByServerId(state.queuedMessages, serverId) }),
+    consumeQueuedMessage: (id, content) => update({ queuedMessages: queuedMessages.consume(state.queuedMessages, id, content) }),
+    clearQueuedMessages: (id) => update({ queuedMessages: queuedMessages.clear(state.queuedMessages, id) }),
+    moveQueuedMessages: (from, to) => update({ queuedMessages: queuedMessages.move(state.queuedMessages, from, to) }),
+    setAgentControlState: (id, control) => update(agentControl.setState(state, id, control)),
+    setAgentProbeAnswer: (id, probe) => update(agentControl.setProbeAnswer(state, id, probe)),
+    setAgentProbePending: (id, pending) => update(agentControl.setProbePending(state, id, pending)),
+    clearAgentControl: (id) => update(agentControl.clear(state, id)),
+    setDraft: (text) => setDraftOf(state.conversationId ?? "new", text),
+    setChatModel: (chatModel) => {
+      if (state.chatModel !== chatModel) update({ chatModel });
+    },
+    setChatModelName: (chatModelName) => {
+      if (state.chatModelName !== chatModelName) update({ chatModelName });
+    },
+    setNewConversationAssistantMode: (newConversationAssistantMode) => {
+      if (state.newConversationAssistantMode !== newConversationAssistantMode)
+        update({ newConversationAssistantMode });
+    },
+    setNewAgentChat: (newAgentChat) => {
+      const current = state.newAgentChat;
+      if (current?.agentId !== newAgentChat?.agentId || current?.workspaceId !== newAgentChat?.workspaceId)
+        update({ newAgentChat });
+    },
+    setNewChatDocumentId: (newChatDocumentId) => {
+      if (state.newChatDocumentId !== newChatDocumentId) update({ newChatDocumentId });
+    },
+    startEditing: (messageId, content) => batch(() => {
+      const key = state.conversationId ?? "new";
+      preEdit = { draft: state.drafts[key] ?? "", cursor: state.cursor };
+      update({ editingMessageId: messageId });
+      setDraftOf(key, content);
+    }),
+    cancelEditing: () => {
+      if (!state.editingMessageId) return;
+      const restore = preEdit;
+      preEdit = NO_EDIT;
+      batch(() => {
+        update({ editingMessageId: null, cursor: restore.cursor });
+        setDraftOf(state.conversationId ?? "new", restore.draft);
+      });
+    },
+    completeEditing: () => {
+      preEdit = NO_EDIT;
+      if (state.editingMessageId) update({ editingMessageId: null });
+    },
+    setDeepLinkMessageId: (deepLinkMessageId) => {
+      if (state.deepLinkMessageId !== deepLinkMessageId) update({ deepLinkMessageId });
+    },
+    setActiveCitationKey: (activeCitationKey) => {
+      if (state.activeCitationKey !== activeCitationKey) update({ activeCitationKey });
+    },
+    setPendingTools: (pendingTools) => update({ pendingTools }),
+    setAutoSendDraft: (autoSendDraft) => {
+      if (state.autoSendDraft !== autoSendDraft) update({ autoSendDraft });
+    },
+    setAgentChatOwner: (conversationId, agentId) => {
+      const signedIn = user();
+      ownersUser = signedIn ?? ownersUser;
+      update({ agentChatOwners: { ...state.agentChatOwners, [conversationId]: agentId } });
+    },
+    setMessageTimer: (key, timer) => update({ messageTimers: { ...state.messageTimers, [key]: timer } }),
+    clearMessageTimer: (key) => {
+      if (!(key in state.messageTimers)) return;
+      const messageTimers = { ...state.messageTimers };
+      delete messageTimers[key];
+      update({ messageTimers });
+    },
+    startNewConversation: () => batch(() => {
+      preEdit = NO_EDIT;
+      update({
+        conversationId: null,
+        cursor: null,
+        editingMessageId: null,
+        chatModel: void 0,
+        chatModelName: void 0,
+        newConversationAssistantMode: "always",
+        paMode: false,
+        newChatDocumentId: null
+      });
+    })
+  };
+}
+export {
+  EMPTY_CHAT_STATE,
+  createArbiChatStore,
+  parseSavedChat,
+  savedChatOf
+};
+//# sourceMappingURL=chat.js.map