@arbidocs/react 0.5.111 → 0.5.112

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