@arbidocs/react 0.5.110 → 0.5.112

package/dist/websocket/store.js

@@ -0,0 +1,58 @@
+import { create } from "zustand";
+import {
+  FINISHED_DOCUMENT_STATUSES,
+  isStaleTaskUpdate,
+  settledByRows
+} from "../documents/processing-order.js";
+const DISMISSED_TASK_TTL_MS = 10 * 60 * 1e3;
+const finished = (status) => FINISHED_DOCUMENT_STATUSES.has(status);
+const useArbiWsStore = create((set, get) => ({
+  status: "disconnected",
+  tasks: {},
+  dismissed: {},
+  lastTaskUpdate: null,
+  presence: {},
+  evicted: false,
+  setStatus: (status) => set({ status }),
+  setEvicted: (evicted) => set({ evicted }),
+  applyTaskUpdate: (msg) => {
+    const { tasks, dismissed } = get();
+    const dismissedAt = dismissed[msg.doc_ext_id];
+    if (dismissedAt !== void 0 && Date.now() - dismissedAt < DISMISSED_TASK_TTL_MS) return false;
+    const held = tasks[msg.doc_ext_id];
+    if (isStaleTaskUpdate(held, msg)) return false;
+    const now = Date.now();
+    const task = {
+      ...msg,
+      startTime: held?.startTime ?? now,
+      endTime: finished(msg.status) ? held?.endTime ?? now : void 0
+    };
+    set({ tasks: { ...tasks, [msg.doc_ext_id]: task }, lastTaskUpdate: msg });
+    return true;
+  },
+  putTask: (task) => set((s) => ({ tasks: { ...s.tasks, [task.doc_ext_id]: task } })),
+  clearTask: (docId) => set((s) => {
+    const tasks = { ...s.tasks };
+    delete tasks[docId];
+    return { tasks, dismissed: { ...s.dismissed, [docId]: Date.now() } };
+  }),
+  clearFinishedTasks: () => set((s) => ({
+    tasks: Object.fromEntries(Object.entries(s.tasks).filter(([, t]) => !finished(t.status)))
+  })),
+  settleTasks: (rows) => set((s) => {
+    const settled = settledByRows(s.tasks, rows);
+    if (!settled.length) return s;
+    const tasks = { ...s.tasks };
+    const now = Date.now();
+    for (const task of settled)
+      tasks[task.doc_ext_id] = { ...task, endTime: task.endTime ?? now };
+    return { tasks };
+  }),
+  applyPresence: (msg) => set((s) => ({ presence: { ...s.presence, [msg.user_id]: msg.status } })),
+  reset: () => set({ status: "disconnected", tasks: {}, dismissed: {}, lastTaskUpdate: null, presence: {} })
+}));
+export {
+  DISMISSED_TASK_TTL_MS,
+  useArbiWsStore
+};
+//# sourceMappingURL=store.js.map

package/dist/websocket/store.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/websocket/store.ts"],
+  "sourcesContent": ["/**\n * Canonical WebSocket state, shared across apps.\n *\n * One store for every site's live connection: its status, people's presence and each document's\n * live processing. `ArbiWebSocketProvider` feeds it; components read it with the selector hooks in\n * `./hooks` and the documents hooks (`useProcessingTasks`, `useWorkspaceProcessing`).\n */\n\nimport { create } from 'zustand'\nimport type { WsTaskUpdateMessage, WsPresenceUpdateMessage } from '@arbidocs/client'\nimport {\n  FINISHED_DOCUMENT_STATUSES,\n  isStaleTaskUpdate,\n  settledByRows,\n  type SequencedRow,\n} from '../documents/processing-order'\n\n/** `error`: the host's socket failed. */\nexport type ArbiWsStatus = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error'\n\n/**\n * A document's live processing: its last `task_update` (or a status set here, such as \"queued\"\n * while a write sends it back into processing), with when it was first seen (`startTime`) and\n * when it finished (`endTime`), both on this device's clock.\n */\nexport type LiveTask = Omit<WsTaskUpdateMessage, 'type' | 'seq'> & {\n  type?: 'task_update'\n  seq?: number | null\n  startTime?: number\n  endTime?: number\n}\n\n/** How long a document's tasks stay dismissed (late updates of a deleted upload are dropped). */\nexport const DISMISSED_TASK_TTL_MS = 10 * 60 * 1000\n\nexport interface ArbiWsState {\n  /** Live connection status of the shared socket. */\n  status: ArbiWsStatus\n  /** Latest processing status per document id (the `task_update` stream). */\n  tasks: Record<string, LiveTask>\n  /** Documents whose processing rows were dismissed (deleted, cleared), with when. */\n  dismissed: Record<string, number>\n  /** The most recent `task_update` \u2014 a convenient single-value change trigger. */\n  lastTaskUpdate: WsTaskUpdateMessage | null\n  /** Online status keyed by user id (the `presence_update` stream). */\n  presence: Record<string, string>\n  /**\n   * The server closed this socket for a newer session of the same user (another device, close\n   * code 1008). The socket stays closed: reconnecting would only be evicted again.\n   */\n  evicted: boolean\n  setStatus: (status: ArbiWsStatus) => void\n  setEvicted: (evicted: boolean) => void\n  /**\n   * Take a `task_update`, unless it is older than the one held for its document (`seq`) or the\n   * document was dismissed a moment ago. Resolves whether it was taken.\n   */\n  applyTaskUpdate: (msg: WsTaskUpdateMessage) => boolean\n  /** Set a document's live processing directly (an optimistic status, or an undo). */\n  putTask: (task: LiveTask) => void\n  /** Drop a document's processing row, and ignore its late updates for a while. */\n  clearTask: (docId: string) => void\n  /** Drop every finished processing row (the in-flight ones stay). */\n  clearFinishedTasks: () => void\n  /** End the in-flight statuses that documents read since say finished after them. */\n  settleTasks: (rows: ReadonlyArray<SequencedRow & { external_id: string }>) => void\n  applyPresence: (msg: WsPresenceUpdateMessage) => void\n  reset: () => void\n}\n\nconst finished = (status: string) => FINISHED_DOCUMENT_STATUSES.has(status)\n\nexport const useArbiWsStore = create<ArbiWsState>((set, get) => ({\n  status: 'disconnected',\n  tasks: {},\n  dismissed: {},\n  lastTaskUpdate: null,\n  presence: {},\n  evicted: false,\n  setStatus: (status) => set({ status }),\n  setEvicted: (evicted) => set({ evicted }),\n  applyTaskUpdate: (msg) => {\n    const { tasks, dismissed } = get()\n    const dismissedAt = dismissed[msg.doc_ext_id]\n    if (dismissedAt !== undefined && Date.now() - dismissedAt < DISMISSED_TASK_TTL_MS) return false\n    const held = tasks[msg.doc_ext_id]\n    if (isStaleTaskUpdate(held, msg)) return false\n    const now = Date.now()\n    const task: LiveTask = {\n      ...msg,\n      startTime: held?.startTime ?? now,\n      endTime: finished(msg.status) ? (held?.endTime ?? now) : undefined,\n    }\n    set({ tasks: { ...tasks, [msg.doc_ext_id]: task }, lastTaskUpdate: msg })\n    return true\n  },\n  putTask: (task) => set((s) => ({ tasks: { ...s.tasks, [task.doc_ext_id]: task } })),\n  clearTask: (docId) =>\n    set((s) => {\n      const tasks = { ...s.tasks }\n      delete tasks[docId]\n      return { tasks, dismissed: { ...s.dismissed, [docId]: Date.now() } }\n    }),\n  clearFinishedTasks: () =>\n    set((s) => ({\n      tasks: Object.fromEntries(Object.entries(s.tasks).filter(([, t]) => !finished(t.status))),\n    })),\n  settleTasks: (rows) =>\n    set((s) => {\n      const settled = settledByRows(s.tasks, rows)\n      if (!settled.length) return s\n      const tasks = { ...s.tasks }\n      const now = Date.now()\n      for (const task of settled)\n        tasks[task.doc_ext_id] = { ...(task as LiveTask), endTime: task.endTime ?? now }\n      return { tasks }\n    }),\n  applyPresence: (msg) => set((s) => ({ presence: { ...s.presence, [msg.user_id]: msg.status } })),\n  reset: () =>\n    set({ status: 'disconnected', tasks: {}, dismissed: {}, lastTaskUpdate: null, presence: {} }),\n}))\n"],
+  "mappings": "AAQA,SAAS,cAAc;AAEvB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AAkBA,MAAM,wBAAwB,KAAK,KAAK;AAqC/C,MAAM,WAAW,CAAC,WAAmB,2BAA2B,IAAI,MAAM;AAEnE,MAAM,iBAAiB,OAAoB,CAAC,KAAK,SAAS;AAAA,EAC/D,QAAQ;AAAA,EACR,OAAO,CAAC;AAAA,EACR,WAAW,CAAC;AAAA,EACZ,gBAAgB;AAAA,EAChB,UAAU,CAAC;AAAA,EACX,SAAS;AAAA,EACT,WAAW,CAAC,WAAW,IAAI,EAAE,OAAO,CAAC;AAAA,EACrC,YAAY,CAAC,YAAY,IAAI,EAAE,QAAQ,CAAC;AAAA,EACxC,iBAAiB,CAAC,QAAQ;AACxB,UAAM,EAAE,OAAO,UAAU,IAAI,IAAI;AACjC,UAAM,cAAc,UAAU,IAAI,UAAU;AAC5C,QAAI,gBAAgB,UAAa,KAAK,IAAI,IAAI,cAAc,sBAAuB,QAAO;AAC1F,UAAM,OAAO,MAAM,IAAI,UAAU;AACjC,QAAI,kBAAkB,MAAM,GAAG,EAAG,QAAO;AACzC,UAAM,MAAM,KAAK,IAAI;AACrB,UAAM,OAAiB;AAAA,MACrB,GAAG;AAAA,MACH,WAAW,MAAM,aAAa;AAAA,MAC9B,SAAS,SAAS,IAAI,MAAM,IAAK,MAAM,WAAW,MAAO;AAAA,IAC3D;AACA,QAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,UAAU,GAAG,KAAK,GAAG,gBAAgB,IAAI,CAAC;AACxE,WAAO;AAAA,EACT;AAAA,EACA,SAAS,CAAC,SAAS,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,CAAC,KAAK,UAAU,GAAG,KAAK,EAAE,EAAE;AAAA,EAClF,WAAW,CAAC,UACV,IAAI,CAAC,MAAM;AACT,UAAM,QAAQ,EAAE,GAAG,EAAE,MAAM;AAC3B,WAAO,MAAM,KAAK;AAClB,WAAO,EAAE,OAAO,WAAW,EAAE,GAAG,EAAE,WAAW,CAAC,KAAK,GAAG,KAAK,IAAI,EAAE,EAAE;AAAA,EACrE,CAAC;AAAA,EACH,oBAAoB,MAClB,IAAI,CAAC,OAAO;AAAA,IACV,OAAO,OAAO,YAAY,OAAO,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;AAAA,EAC1F,EAAE;AAAA,EACJ,aAAa,CAAC,SACZ,IAAI,CAAC,MAAM;AACT,UAAM,UAAU,cAAc,EAAE,OAAO,IAAI;AAC3C,QAAI,CAAC,QAAQ,OAAQ,QAAO;AAC5B,UAAM,QAAQ,EAAE,GAAG,EAAE,MAAM;AAC3B,UAAM,MAAM,KAAK,IAAI;AACrB,eAAW,QAAQ;AACjB,YAAM,KAAK,UAAU,IAAI,EAAE,GAAI,MAAmB,SAAS,KAAK,WAAW,IAAI;AACjF,WAAO,EAAE,MAAM;AAAA,EACjB,CAAC;AAAA,EACH,eAAe,CAAC,QAAQ,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,CAAC,IAAI,OAAO,GAAG,IAAI,OAAO,EAAE,EAAE;AAAA,EAC/F,OAAO,MACL,IAAI,EAAE,QAAQ,gBAAgB,OAAO,CAAC,GAAG,WAAW,CAAC,GAAG,gBAAgB,MAAM,UAAU,CAAC,EAAE,CAAC;AAChG,EAAE;",
+  "names": []
+}

package/dist/workforce.js

@@ -0,0 +1,607 @@
+import { useEffect, useMemo, useRef } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useArbi } from "./useArbi.js";
+import { useCurrentWorkspace } from "./workspaces/current.js";
+import { arbiMutationKeys, arbiQueryKeys, useConversations } from "./hooks.js";
+import {
+  addConversationToList,
+  invalidateConversationDetails,
+  invalidateConversationLists,
+  patchConversation,
+  removeConversationFromLists
+} from "./conversation-list.js";
+import { useArbiSessionState } from "./session/index.js";
+function isActivityKey(queryKey, conversationId) {
+  const [scope, resource, id, leaf] = queryKey;
+  if (scope !== "arbi" || resource !== "conversations" || leaf !== "activity") return false;
+  return !conversationId || id === conversationId;
+}
+function invalidateConversationActivity(queryClient, conversationId) {
+  void queryClient.invalidateQueries({
+    predicate: (q) => isActivityKey(q.queryKey, conversationId)
+  });
+}
+const GENERATING_POLL_MS = 2500;
+let listPollHolders = 0;
+let listPollTimer;
+let listPollRefetch;
+function holdListPoll(refetch) {
+  listPollRefetch = refetch;
+  listPollHolders += 1;
+  if (listPollTimer === void 0) {
+    listPollTimer = setInterval(() => void listPollRefetch?.(), GENERATING_POLL_MS);
+  }
+  return () => {
+    listPollHolders -= 1;
+    if (listPollHolders === 0 && listPollTimer !== void 0) {
+      clearInterval(listPollTimer);
+      listPollTimer = void 0;
+    }
+  };
+}
+function useConversationItems() {
+  const workspaceId = useArbiSessionState((s) => s.workspaceId);
+  const open = useArbiSessionState((s) => s.workspaceStatus === "open");
+  const query = useConversations(workspaceId ?? void 0, { enabled: open });
+  const { refetch } = query;
+  const all = query.data;
+  const tasks = useMemo(() => (all ?? []).filter((c) => c.status != null), [all]);
+  const queryClient = useQueryClient();
+  const seen = useRef(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    for (const t of tasks) {
+      const stamp = `${t.status}|${t.updated_at ?? ""}`;
+      const before = seen.current.get(t.external_id);
+      if (before !== void 0 && before !== stamp) {
+        invalidateConversationActivity(queryClient, t.external_id);
+      }
+      seen.current.set(t.external_id, stamp);
+    }
+  }, [tasks, queryClient]);
+  const generating = tasks.some((t) => t.in_progress || t.status === "generating");
+  useEffect(() => generating ? holdListPoll(refetch) : void 0, [generating, refetch]);
+  return { conversations: all ?? [], tasks, isLoading: query.isLoading, refetch };
+}
+function useConversationIsShared() {
+  const id = useArbiSessionState((state) => state.conversationId);
+  const { conversations } = useConversationItems();
+  return conversations.find((conversation) => conversation.external_id === id)?.is_shared ?? false;
+}
+function useWorkItems() {
+  const { tasks, isLoading, refetch } = useConversationItems();
+  return { tasks, isLoading, refetch };
+}
+function useWorkspaceRole() {
+  return useCurrentWorkspace().role;
+}
+function useCanEditShared() {
+  const role = useWorkspaceRole();
+  return role === "owner" || role === "collaborator";
+}
+function useIsWorkspaceOwner() {
+  return useWorkspaceRole() === "owner";
+}
+class TaskThreadPendingError extends Error {
+  constructor(messageId) {
+    super("The task has started, but its thread isn't ready yet.");
+    this.messageId = messageId;
+    this.name = "TaskThreadPendingError";
+  }
+  messageId;
+}
+const THREAD_LOOKUP_ATTEMPTS = 20;
+const THREAD_LOOKUP_DELAY_MS = 500;
+function useStartTaskQuery() {
+  const arbi = useArbi();
+  const queryClient = useQueryClient();
+  const chatModel = useArbiSessionState((s) => s.chatModel);
+  const post = useMutation({
+    mutationFn: (query) => {
+      const selectedConfig = chatModel || queryClient.getQueriesData({ queryKey: arbiQueryKeys.userSettings() }).map(([, settings]) => settings?.last_config).find(Boolean);
+      return arbi.assistant.submit(query.input, {
+        workspaceId: query.workspaceId,
+        docIds: query.docIds,
+        fullContext: false,
+        ...selectedConfig ? { model: selectedConfig } : {},
+        ...query.mentions !== void 0 ? { mentions: query.mentions } : {},
+        ...query.task !== void 0 ? { task: query.task } : {}
+      });
+    }
+  });
+  const threadOf = async (messageId, known) => {
+    const response = await arbi.assistant.getResponse(messageId);
+    const events = response.metadata?.events ?? [];
+    const posted = events.find((e) => e.type === "arbi.user_message")?.conversation_ext_id;
+    if (posted) return posted;
+    if (response.status === "queued" || response.status === "in_progress") return void 0;
+    return known || (await arbi.conversations.getMessage(messageId)).conversation_ext_id;
+  };
+  const lookUpThread = async (messageId, attempts, known) => {
+    let conversationId;
+    for (let attempt = 0; attempt < attempts && !conversationId; attempt += 1) {
+      if (attempt > 0) await new Promise((r) => setTimeout(r, THREAD_LOOKUP_DELAY_MS));
+      try {
+        conversationId = await threadOf(messageId, known);
+      } catch (error) {
+        if (!(error && typeof error === "object" && "status" in error && error.status === 404))
+          throw error;
+      }
+    }
+    if (!conversationId) return null;
+    await invalidateConversationLists(queryClient);
+    return { conversationId };
+  };
+  return {
+    isPending: post.isPending,
+    /** Look again for the thread of a run whose start threw {@link TaskThreadPendingError}. */
+    findThread: (messageId) => lookUpThread(messageId, 1),
+    start: async (query) => {
+      const accepted = await post.mutateAsync(query);
+      const found = await lookUpThread(
+        accepted.id,
+        THREAD_LOOKUP_ATTEMPTS,
+        accepted.conversation_ext_id
+      );
+      if (!found) throw new TaskThreadPendingError(accepted.id);
+      return found;
+    }
+  };
+}
+function useUpdateConversation() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({
+      conversationId,
+      patch
+    }) => arbi.conversations.update(conversationId, patch),
+    // The list takes the server's version of the row; what hangs off it is read again.
+    onSuccess: (updated, { conversationId }) => {
+      patchConversation(qc, conversationId, updated);
+      return invalidateConversationDetails(qc, conversationId);
+    }
+  });
+}
+function useDeleteConversation() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (conversationId) => arbi.conversations.delete(conversationId),
+    onSuccess: (_res, conversationId) => removeConversationFromLists(qc, conversationId)
+  });
+}
+function workWorkspace(arbi, workspaceId) {
+  return workspaceId || (arbi.hasWorkspace ? arbi.getWorkspaceId() : void 0);
+}
+function useConversationSearch(workspaceId) {
+  const arbi = useArbi();
+  return useMutation({
+    mutationFn: (body) => arbi.conversations.search(body, { workspaceId: workWorkspace(arbi, workspaceId) })
+  });
+}
+function useCreateWork(options) {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  const named = options?.workspaceId;
+  return useMutation({
+    // The workspace is read once, when the request is sent: the request names it and the new work
+    // joins that workspace's list, so one switched to while it is in flight neither receives it
+    // nor lists it.
+    mutationFn: async (body) => {
+      const workspaceId = workWorkspace(arbi, named);
+      const created = await arbi.conversations.createWork(body, { workspaceId });
+      addConversationToList(qc, workspaceId ?? null, created);
+      return created;
+    }
+  });
+}
+function useRunConversation() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (conversationId) => arbi.conversations.runWithAuth(conversationId),
+    // The server's version replaces the listed one; everything under the conversation is re-read.
+    onSuccess: (updated) => {
+      if (updated?.external_id) patchConversation(qc, updated.external_id, updated);
+      return qc.invalidateQueries({ queryKey: arbiQueryKeys.allConversations() });
+    }
+  });
+}
+function useActOnStep() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({
+      conversationId,
+      body
+    }) => arbi.conversations.actOnStep(conversationId, body),
+    // The server's version of the conversation replaces the listed one; its history is re-read.
+    onSuccess: (updated) => {
+      if (!updated?.external_id) return;
+      patchConversation(qc, updated.external_id, updated);
+      invalidateConversationActivity(qc, updated.external_id);
+    }
+  });
+}
+function usePlanWork(workspaceId) {
+  const arbi = useArbi();
+  return useMutation({
+    mutationFn: (body) => arbi.conversations.plan(body, { workspaceId: workWorkspace(arbi, workspaceId) })
+  });
+}
+function useConversationPendingAuth(conversationId, options) {
+  const arbi = useArbi();
+  return useQuery({
+    queryKey: arbiQueryKeys.conversationPendingAuth(conversationId ?? ""),
+    queryFn: () => arbi.conversations.pendingAuth(conversationId),
+    enabled: (options?.enabled ?? true) && !!conversationId && arbi.isLoggedIn,
+    retry: false
+  });
+}
+function useConversationActivity(conversationId, options) {
+  const arbi = useArbi();
+  return useQuery({
+    queryKey: arbiQueryKeys.conversationActivity(conversationId ?? ""),
+    queryFn: () => arbi.conversations.activity(conversationId),
+    enabled: (options?.enabled ?? true) && !!conversationId && arbi.isLoggedIn,
+    refetchInterval: options?.live ? 2500 : false
+  });
+}
+function useWorkflows(options) {
+  const arbi = useArbi();
+  return useQuery({
+    queryKey: arbiQueryKeys.workflows(),
+    queryFn: () => arbi.workflows.list(),
+    // A clock or event can fire while the list is open, without a write here.
+    refetchInterval: options?.live ? 1e4 : false,
+    enabled: (options?.enabled ?? true) && arbi.isLoggedIn
+  });
+}
+function useWorkflowRuns(workflowId) {
+  const arbi = useArbi();
+  return useQuery({
+    queryKey: arbiQueryKeys.workflowRuns(workflowId ?? ""),
+    queryFn: () => arbi.workflows.runs(workflowId),
+    enabled: !!workflowId && arbi.isLoggedIn,
+    refetchInterval: 3e3,
+    staleTime: 0,
+    refetchOnMount: "always"
+  });
+}
+function useCreateWorkflow() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (body) => arbi.workflows.create(body),
+    onSuccess: () => qc.invalidateQueries({ queryKey: arbiQueryKeys.workflows() })
+  });
+}
+function useUpdateWorkflow() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({
+      workflowId,
+      patch
+    }) => arbi.workflows.update(workflowId, patch),
+    onSuccess: () => qc.invalidateQueries({ queryKey: arbiQueryKeys.workflows() })
+  });
+}
+function useDeleteWorkflow() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (workflowId) => arbi.workflows.delete(workflowId),
+    onSuccess: () => qc.invalidateQueries({ queryKey: arbiQueryKeys.workflows() })
+  });
+}
+function useRunWorkflow() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationKey: arbiMutationKeys.runWorkflow(),
+    mutationFn: (workflowId) => arbi.workflows.run(workflowId),
+    onSuccess: () => Promise.all([
+      qc.invalidateQueries({ queryKey: arbiQueryKeys.workflows() }),
+      qc.invalidateQueries({ queryKey: arbiQueryKeys.allConversations() })
+    ])
+  });
+}
+function useCreateAgent() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (name) => arbi.agents.create(name),
+    onSuccess: () => qc.invalidateQueries({ queryKey: arbiQueryKeys.agents() })
+  });
+}
+function useGenerateAgentAvatar() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({ agentExtId, prompt }) => arbi.agents.generateAvatar(agentExtId, prompt),
+    onSuccess: () => qc.invalidateQueries({ queryKey: arbiQueryKeys.agents() })
+  });
+}
+function useAuthorizeLimits(options) {
+  const arbi = useArbi();
+  return useQuery({
+    queryKey: arbiQueryKeys.authorizeLimits(),
+    queryFn: () => arbi.agents.authorizeLimits(),
+    enabled: (options?.enabled ?? true) && arbi.isLoggedIn
+  });
+}
+function useMcpTools(options) {
+  const arbi = useArbi();
+  return useQuery({
+    queryKey: arbiQueryKeys.mcpTools(),
+    queryFn: () => arbi.health.mcpTools(),
+    enabled: (options?.enabled ?? true) && arbi.isLoggedIn
+  });
+}
+function useAgentConfig(agentExtId, options) {
+  const arbi = useArbi();
+  return useQuery({
+    queryKey: arbiQueryKeys.agentConfig(agentExtId),
+    queryFn: async () => agentExtId ? await arbi.agents.getConfig(agentExtId) : await arbi.agentConfig.get("default"),
+    enabled: (options?.enabled ?? true) && arbi.isLoggedIn
+  });
+}
+function useAgentModels(options) {
+  const arbi = useArbi();
+  return useQuery({
+    queryKey: arbiQueryKeys.models(),
+    queryFn: async () => (await arbi.agentConfig.getModels()).models.map((m) => m.model_name),
+    enabled: (options?.enabled ?? true) && arbi.isLoggedIn
+  });
+}
+function useSaveAgentConfig() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ agentExtId, title, sections }) => {
+      const pinned = await arbi.agents.getConfig(agentExtId);
+      const base = pinned ?? await arbi.agentConfig.get("default");
+      const merged = structuredClone(base);
+      for (const [section, params] of Object.entries(sections)) {
+        merged[section] = { ...merged[section] ?? {}, ...params };
+      }
+      return arbi.agentConfig.save({
+        ...merged,
+        agent_ext_id: agentExtId,
+        title: title ?? `agent-${agentExtId}`
+      });
+    },
+    onSuccess: (_saved, { agentExtId }) => Promise.all([
+      qc.invalidateQueries({ queryKey: arbiQueryKeys.configs() }),
+      qc.invalidateQueries({ queryKey: arbiQueryKeys.agentConfig(agentExtId) }),
+      // The agent list shows the pinned persona/model, so it refreshes too.
+      qc.invalidateQueries({ queryKey: arbiQueryKeys.agents() })
+    ])
+  });
+}
+function useAgentWorkspaces(agentExtId, options) {
+  const arbi = useArbi();
+  return useQuery({
+    queryKey: arbiQueryKeys.agentWorkspaces(agentExtId ?? ""),
+    queryFn: () => arbi.agents.listWorkspaces(agentExtId),
+    enabled: (options?.enabled ?? true) && !!agentExtId && arbi.isLoggedIn
+  });
+}
+function useGrantAgentAccess() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async ({
+      agentExtId,
+      workspaceId,
+      mode = { kind: "standing" }
+    }) => {
+      if (mode.kind === "temporary") {
+        return arbi.agents.grantTemporaryAccess(agentExtId, workspaceId, mode.ttlSeconds);
+      }
+      const agent = (await arbi.agents.list()).find((a) => a.external_id === agentExtId);
+      if (!agent?.email) throw new Error("The agent's address is unknown.");
+      return arbi.workspaces.grantAccess({ workspaceId, emails: [agent.email] });
+    },
+    onSuccess: (_res, { agentExtId, mode }) => {
+      void qc.invalidateQueries({ queryKey: arbiQueryKeys.agentWorkspaces(agentExtId) });
+      if (mode?.kind === "temporary")
+        void qc.invalidateQueries({ queryKey: arbiQueryKeys.sessions() });
+    }
+  });
+}
+function useRevokeAgentAccess() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({ agentExtId, workspaceId }) => arbi.workspaces.removeUsers([agentExtId], { workspaceId }),
+    onSuccess: (_res, { agentExtId }) => qc.invalidateQueries({ queryKey: arbiQueryKeys.agentWorkspaces(agentExtId) })
+  });
+}
+function useSkills(options) {
+  const arbi = useArbi();
+  const workspaceId = arbi.hasWorkspace ? arbi.getWorkspaceId() : "";
+  return useQuery({
+    queryKey: arbiQueryKeys.skillList(workspaceId, options?.includeHidden ?? false),
+    queryFn: () => arbi.assistant.listSkills({
+      includeHidden: options?.includeHidden,
+      workspaceId: workspaceId || void 0
+    }),
+    refetchInterval: options?.live ? 5e3 : false,
+    enabled: (options?.enabled ?? true) && arbi.isLoggedIn,
+    staleTime: 3e4
+  });
+}
+function useUploadSkillFiles() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async (entries) => {
+      if (!entries.length) throw new Error("Choose at least one skill file.");
+      for (const entry of entries) assertSkillFolder(entry.folder);
+      const results = [];
+      for (const entry of entries) {
+        const options = {
+          folder: entry.folder,
+          wpType: "skill",
+          shared: entry.shared ?? false
+        };
+        const result = entry.workspaceId ? await arbi.documents.upload(
+          [new File([entry.content], entry.fileName, { type: entry.content.type })],
+          { ...options, workspaceExtId: entry.workspaceId }
+        ) : await arbi.documents.uploadFile(entry.content, entry.fileName, options);
+        throwOnSkipped(result);
+        results.push(result);
+      }
+      return results;
+    },
+    onSuccess: () => qc.invalidateQueries({ queryKey: arbiQueryKeys.skills() })
+  });
+}
+function assertSkillFolder(folder) {
+  if (!/^skills\/[a-z0-9][a-z0-9_-]*(?:\/[^/]+)*$/.test(folder) || folder.split("/").some((segment) => segment === ".." || segment === "."))
+    throw new Error("Skill files need a folder under skills/<name>.");
+}
+function throwOnSkipped(result) {
+  if (result.skipped?.length)
+    throw new Error(result.skipped.map((file) => `${file.file_name}: ${file.reason}`).join("; "));
+}
+function useSaveSkill() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async ({
+      slug,
+      markdown,
+      shared
+    }) => {
+      assertSkillFolder(`skills/${slug}`);
+      const result = await arbi.assistant.uploadSkill(slug, markdown, { shared });
+      throwOnSkipped(result);
+      return result;
+    },
+    onSuccess: () => qc.invalidateQueries({ queryKey: arbiQueryKeys.skills() })
+  });
+}
+function useSkillSource(docExtId, options) {
+  const arbi = useArbi();
+  return useQuery({
+    queryKey: arbiQueryKeys.skillSource(docExtId ?? ""),
+    queryFn: async () => {
+      const response = await arbi.documents.download(docExtId);
+      if (!response.ok) throw new Error(`Could not read the skill (${response.status})`);
+      return response.text();
+    },
+    enabled: (options?.enabled ?? true) && !!docExtId && arbi.isLoggedIn,
+    staleTime: 5 * 6e4
+  });
+}
+function useDeleteSkill() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (docExtId) => arbi.documents.delete([docExtId]),
+    onSuccess: () => qc.invalidateQueries({ queryKey: arbiQueryKeys.skills() })
+  });
+}
+function useSetSkillVisibility() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({ docExtId, visibility }) => arbi.documents.update([{ external_id: docExtId, shared: visibility === "global" }]),
+    onSuccess: () => qc.invalidateQueries({ queryKey: arbiQueryKeys.skills() })
+  });
+}
+function useAgentSession(agentId, options) {
+  const arbi = useArbi();
+  return useQuery({
+    queryKey: arbiQueryKeys.agentSession(agentId ?? ""),
+    queryFn: () => arbi.agents.getSession(agentId),
+    enabled: !!agentId && arbi.isLoggedIn && (options?.enabled ?? true),
+    refetchInterval: 5e3
+  });
+}
+function useAgentChats(agentId) {
+  const arbi = useArbi();
+  return useQuery({
+    queryKey: arbiQueryKeys.agentChats(agentId ?? ""),
+    queryFn: () => arbi.agents.listChats(agentId),
+    enabled: !!agentId && arbi.isLoggedIn,
+    refetchInterval: 5e3
+  });
+}
+function refreshAgentSession(qc, agentId) {
+  return Promise.all(
+    [
+      arbiQueryKeys.agentSession(agentId),
+      arbiQueryKeys.agentWorkspaces(agentId),
+      arbiQueryKeys.agentChats(agentId),
+      arbiQueryKeys.sessions()
+    ].map((queryKey) => qc.invalidateQueries({ queryKey }))
+  );
+}
+function useStartAgentSession() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({ agentId, workspaceId }) => arbi.agents.startSession(agentId, workspaceId),
+    onSuccess: (_session, { agentId }) => refreshAgentSession(qc, agentId)
+  });
+}
+function useCloseAgentSession() {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (agentId) => arbi.agents.closeSession(agentId),
+    onSuccess: (_result, agentId) => refreshAgentSession(qc, agentId)
+  });
+}
+export {
+  TaskThreadPendingError,
+  invalidateConversationActivity,
+  isActivityKey,
+  useActOnStep,
+  useAgentChats,
+  useAgentConfig,
+  useAgentModels,
+  useAgentSession,
+  useAgentWorkspaces,
+  useAuthorizeLimits,
+  useCanEditShared,
+  useCloseAgentSession,
+  useConversationActivity,
+  useConversationIsShared,
+  useConversationItems,
+  useConversationPendingAuth,
+  useConversationSearch,
+  useCreateAgent,
+  useCreateWork,
+  useCreateWorkflow,
+  useDeleteConversation,
+  useDeleteSkill,
+  useDeleteWorkflow,
+  useGenerateAgentAvatar,
+  useGrantAgentAccess,
+  useIsWorkspaceOwner,
+  useMcpTools,
+  usePlanWork,
+  useRevokeAgentAccess,
+  useRunConversation,
+  useRunWorkflow,
+  useSaveAgentConfig,
+  useSaveSkill,
+  useSetSkillVisibility,
+  useSkillSource,
+  useSkills,
+  useStartAgentSession,
+  useStartTaskQuery,
+  useUpdateConversation,
+  useUpdateWorkflow,
+  useUploadSkillFiles,
+  useWorkItems,
+  useWorkflowRuns,
+  useWorkflows,
+  useWorkspaceRole
+};
+//# sourceMappingURL=workforce.js.map