@arbidocs/blocks 0.4.72 → 0.4.74

package/dist/connect/index.js

@@ -1,26 +1,30 @@
 "use client";
 import { SettingsSection, ProfileCard, AvatarPicker, IdentityVerificationCard, IdentityVerificationDialog, RequireVerified, SettingsCard, SettingsActionRow, PasswordChangeDialog, EMAIL_NOTIFICATION_KEYS, EMAIL_NOTIFICATION_CATEGORIES, NotificationCategoryList, toNotificationCategories, toActiveSessionViews, SettingsRow, ActiveSessionsDialog, LogoutDialog, toLogoutSessionViews, SettingsDangerZone, DeleteAccountDialog, toDeleteBlockerViews } from '../chunk-GJV2G4FC.js';
-export { ConnectedAssistantDock, redlineStats, textToArtifact, toRedlineMarkdown, useConnectedAiTask, useConnectedChat, useSemanticSearch, useWorkspaceDocs } from '../chunk-KOXUBCLL.js';
-import { ConnectionProvider, useConnection } from '../chunk-5HOAOKZL.js';
-export { ConnectionProvider, SESSION_EXPIRED_MESSAGE, isAuthenticated, useConnection } from '../chunk-5HOAOKZL.js';
-import { StreamedArtifactFrame } from '../chunk-LOJVUGBJ.js';
+import { useWorkspaceDocs } from '../chunk-MK6NJQGF.js';
+export { ConnectedAssistantDock, redlineStats, textToArtifact, toRedlineMarkdown, useConnectedAiTask, useConnectedChat, useSemanticSearch, useWorkspaceDocs } from '../chunk-MK6NJQGF.js';
+import { ConnectionProvider, useConnection } from '../chunk-OYMWV45N.js';
+export { ConnectionProvider, SESSION_EXPIRED_MESSAGE, isAuthenticated, useConnection } from '../chunk-OYMWV45N.js';
+import { WorkflowRunner, initialRunInputs, workflowSteps, fromPlanSteps, stepStatesFromActivity, toPlanSteps, runThreadTitle, useWorkflowView } from '../chunk-YWYVIQ7T.js';
+import '../chunk-EVUEIBNU.js';
+import '../chunk-XD2M6LIG.js';
 import '../chunk-VILAPTCB.js';
-import { ChatPage } from '../chunk-G5DP27DU.js';
+import { StreamedArtifactFrame } from '../chunk-LOJVUGBJ.js';
+import { ChatPage } from '../chunk-UIWLDSTF.js';
 import '../chunk-KZJAG7T3.js';
-import '../chunk-3VQYJBOI.js';
+import '../chunk-HOXKR26S.js';
 import '../chunk-AA3PT6KR.js';
 import '../chunk-NPLYHR2E.js';
 import { initials } from '../chunk-OXF2IFXG.js';
 import '../chunk-TX2ZICS7.js';
 import '../chunk-7F6CBP3Z.js';
 import '../chunk-VUNV25KB.js';
-import { lazy, useState, Suspense, useMemo, useEffect } from 'react';
+import { lazy, useState, Suspense, useCallback, useEffect, useMemo, useRef } from 'react';
 import { QueryClient, QueryClientProvider, useQueryClient, useQuery } from '@tanstack/react-query';
-import { ArbiProvider, useConversations, useRunConversation, useUploadSkillFiles, ArtifactCanvas, useWorkspaces, useShellWorkspaces, useProfile, useUpdateProfile, useRequestEmailChange, useConfirmEmailChange, useNameEditor, useAvatarCrop, useEmailChange, ImageCropModal, useIdentityVerification, usePasswordChange, usePasswordChangeForm, useNotificationPreferences, useSessions, useCurrentSessionId, useTerminateSession, useLogoutAllSessions, useDeleteAccount, useDeleteAccountFlow, useArbi, useArbiWebSocket, notify, useWorkNotifications, useAgentSession, useStartAgentSession, useCloseAgentSession, ArbiWebSocketProvider, useArbiChat } from '@arbidocs/react';
+import { ArbiProvider, useConversations, useRunConversation, useUploadSkillFiles, ArtifactCanvas, useArbi, useDocuments, useWorkspaceUsers, useWorkspaces, useShellWorkspaces, useProfile, useUpdateProfile, useRequestEmailChange, useConfirmEmailChange, useNameEditor, useAvatarCrop, useEmailChange, ImageCropModal, useIdentityVerification, usePasswordChange, usePasswordChangeForm, useNotificationPreferences, useSessions, useCurrentSessionId, useTerminateSession, useLogoutAllSessions, useDeleteAccount, useDeleteAccountFlow, useArbiWebSocket, notify, useWorkNotifications, useAgentSession, useStartAgentSession, useCloseAgentSession, AiAnswer, ArbiWebSocketProvider, useCreateWork, useActOnStep, useConversationActivity, useConversationThreads, useArbiChat } from '@arbidocs/react';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-import { Button, Label, Input } from '@arbidocs/react/ui';
+import { Button, Label, Input, cn } from '@arbidocs/react/ui';
 import { useStreamedArtifact } from '@arbidocs/react/artifacts';
-import { UserCircle, KeyRound, Radio } from 'lucide-react';
+import { ExternalLink, UserCircle, KeyRound, Radio, Loader2 } from 'lucide-react';
 import { useNotify } from '@arbidocs/react/shell';
 
 function ConnectionBoundWebSocket({ children }) {
@@ -179,6 +183,353 @@ function StreamedArtifact({
     }
   );
 }
+var STARTING = /* @__PURE__ */ new Set(["pending", "running"]);
+function formValues(step, inputs) {
+  if (step.kind !== "form") return void 0;
+  return Object.fromEntries(step.inputs.map((f) => [f.name, inputs[f.name] ?? ""]));
+}
+var ANSWER_RETRY_CAP = 16;
+function answerRetryDelay(attempt) {
+  return attempt === 0 ? 0 : Math.min(1e3 * 2 ** (attempt - 1), 15e3);
+}
+function useAnswerRetry(missing, refetch) {
+  const [attempt, setAttempt] = useState(0);
+  const [prev, setPrev] = useState(missing);
+  if (prev !== missing) {
+    setPrev(missing);
+    setAttempt(0);
+  }
+  const refetchRef = useRef(refetch);
+  refetchRef.current = refetch;
+  useEffect(() => {
+    if (!missing || attempt >= ANSWER_RETRY_CAP) return;
+    const t = setTimeout(() => {
+      void refetchRef.current();
+      setAttempt((a) => a + 1);
+    }, answerRetryDelay(attempt));
+    return () => clearTimeout(t);
+  }, [missing, attempt]);
+}
+function useWorkflowThread(workflow, options = {}) {
+  const arbi = useArbi();
+  const { ensureWorkspaceOpen } = useConnection();
+  const { wsId } = useWorkspaceDocs();
+  const [threadId, setThreadId] = useState(options.conversationId);
+  const [localInputs, setLocalInputs] = useState(
+    () => initialRunInputs(workflow, options.initialInputs)
+  );
+  const [edits, setEdits] = useState({});
+  const [localStates, setLocalStates] = useState({});
+  const createWork = useCreateWork();
+  const actOnStep = useActOnStep();
+  const conversations = useConversations(wsId, { enabled: !!threadId, live: true });
+  const conversation = conversations.data?.find((c) => c.external_id === threadId);
+  const steps = useMemo(
+    () => workflowSteps(workflow).length > 0 ? workflowSteps(workflow) : fromPlanSteps(conversation?.plan?.steps ?? []),
+    [workflow, conversation?.plan?.steps]
+  );
+  const activity = useConversationActivity(threadId, { live: !!threadId });
+  const serverStates = useMemo(
+    () => stepStatesFromActivity(activity.data ?? []),
+    [activity.data]
+  );
+  const working = steps.some(
+    (s) => s.kind === "agent" && STARTING.has(serverStates[s.id]?.status ?? "pending")
+  );
+  const threads = useConversationThreads(wsId, threadId, { enabled: !!threadId, live: working });
+  const answers = useMemo(() => {
+    const byId = /* @__PURE__ */ new Map();
+    for (const t of threads.data?.threads ?? [])
+      for (const m of t.history)
+        if (m.role === "assistant" && m.content?.trim()) byId.set(m.external_id, m.content);
+    return byId;
+  }, [threads.data]);
+  const missing = Object.values(serverStates).flatMap(
+    (st) => st.status === "done" && st.responseId && !answers.has(st.responseId) ? [st.responseId] : []
+  ).sort().join(" ");
+  useAnswerRetry(missing, threads.refetch);
+  const states = useMemo(() => {
+    if (!threadId) return localStates;
+    const out = {};
+    for (const [id, s] of Object.entries(serverStates))
+      out[id] = { ...s, text: s.responseId ? answers.get(s.responseId) : void 0 };
+    return out;
+  }, [threadId, localStates, serverStates, answers]);
+  const inputs = useMemo(
+    () => threadId ? { ...localInputs, ...conversation?.skill_inputs ?? {}, ...edits } : { ...localInputs, ...edits },
+    [threadId, localInputs, conversation?.skill_inputs, edits]
+  );
+  const refresh = useCallback(async () => {
+    await Promise.all([activity.refetch(), conversations.refetch()]);
+  }, [activity, conversations]);
+  const act = useCallback(
+    async (id, body) => {
+      await actOnStep.mutateAsync({ conversationId: id, body });
+      await refresh();
+    },
+    [actOnStep, refresh]
+  );
+  const complete = useCallback(
+    async (step) => {
+      let values = inputs;
+      const commit = step.commit ? options.commit?.[step.id] : void 0;
+      if (commit && localStates[step.id]?.status !== "done") {
+        values = { ...values, ...await commit(values) ?? {} };
+        setLocalInputs(values);
+        setEdits({});
+      }
+      let id = threadId;
+      if (!id) {
+        await ensureWorkspaceOpen();
+        const created = await createWork.mutateAsync({
+          title: runThreadTitle(workflow, values).slice(0, 60),
+          description: workflow.description || null,
+          prompt: null,
+          skill_ref: null,
+          skill_inputs: values,
+          agent_ext_id: options.agentId ?? null,
+          auth_mode: "run_now_temp",
+          plan: {
+            goal: "",
+            criteria: [],
+            max_passes: 3,
+            documents: [],
+            steps: toPlanSteps(workflow, {
+              inputs: values,
+              resolveWorkflow: options.resolveWorkflow,
+              compose: options.compose
+            })
+          }
+        });
+        id = created.external_id;
+        setThreadId(id);
+        setLocalStates((s) => ({ ...s, [step.id]: { status: "done" } }));
+        options.onStarted?.(id);
+      }
+      await act(id, { step: step.id, action: "complete", inputs: formValues(step, values) });
+    },
+    [inputs, options, localStates, threadId, ensureWorkspaceOpen, createWork, workflow, act]
+  );
+  const skip = useCallback(
+    async (stepId) => {
+      if (!threadId) {
+        setLocalStates((s) => ({ ...s, [stepId]: { status: "skipped" } }));
+        return;
+      }
+      await act(threadId, { step: stepId, action: "skip" });
+    },
+    [threadId, act]
+  );
+  const retry = useCallback(
+    async (_stepId) => {
+      if (!threadId) return;
+      await arbi.conversations.runWithAuth(threadId);
+      await refresh();
+    },
+    [arbi, threadId, refresh]
+  );
+  const view = useWorkflowView({
+    steps,
+    states,
+    inputs,
+    setInput: (name, value) => setEdits((i) => ({ ...i, [name]: value })),
+    complete,
+    skip,
+    retry,
+    isLocked: (id) => states[id]?.status === "done"
+  });
+  return { view, conversationId: threadId, conversation };
+}
+var DEFAULT_CONNECTED_WORKFLOW_RUNNER_LABELS = {
+  notify: "Ask to approve",
+  notified: "Notified.",
+  openThread: "Open the thread",
+  loadingAnswer: "Fetching the answer\u2026"
+};
+function ConnectedWorkflowRunner({
+  workflow,
+  options,
+  onOpenConversation,
+  emptyHint,
+  connectedLabels,
+  testIdPrefix = "workflow-run",
+  ...runnerProps
+}) {
+  const l = { ...DEFAULT_CONNECTED_WORKFLOW_RUNNER_LABELS, ...connectedLabels };
+  const arbi = useArbi();
+  const { ensureWorkspaceOpen } = useConnection();
+  const { wsId } = useWorkspaceDocs();
+  const { data: docs = [], refetch } = useDocuments(wsId);
+  const [uploading, setUploading] = useState(false);
+  const { view, conversationId } = useWorkflowThread(workflow, options);
+  const [added, setAdded] = useState({});
+  const onUpload = useCallback(
+    async (files2, step) => {
+      if (!files2.length) return;
+      setUploading(true);
+      try {
+        await ensureWorkspaceOpen();
+        for (const f of files2) {
+          const { doc_ext_ids = [] } = await arbi.documents.uploadFile(f, f.name) ?? {};
+          setAdded((a) => ({ ...a, ...Object.fromEntries(doc_ext_ids.map((id) => [id, step.id])) }));
+        }
+        await refetch();
+      } finally {
+        setUploading(false);
+      }
+    },
+    [arbi, ensureWorkspaceOpen, refetch]
+  );
+  const files = docs.map((d) => ({
+    id: d.external_id,
+    name: d.file_name ?? d.external_id,
+    status: fileStatus(d.status),
+    addedFor: added[d.external_id]
+  }));
+  const reading = files.some((f) => f.addedFor && f.status === "processing");
+  useEffect(() => {
+    if (!reading) return;
+    const t = setInterval(() => void refetch(), READ_POLL_MS);
+    return () => clearInterval(t);
+  }, [reading, refetch]);
+  const renderAgentOutput = (step, state) => {
+    const status = state?.status;
+    if (!state?.text && status !== "done") return null;
+    if (!state?.text && state?.responseId) {
+      return /* @__PURE__ */ jsxs(
+        "p",
+        {
+          className: "flex items-center gap-2 text-sm text-muted-foreground",
+          "data-testid": `${testIdPrefix}-${step.id}-answer-loading`,
+          children: [
+            /* @__PURE__ */ jsx(Loader2, { className: "size-4 animate-spin" }),
+            " ",
+            l.loadingAnswer
+          ]
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx(
+      AiAnswer,
+      {
+        status: status === "running" ? "running" : "done",
+        text: state?.text ?? "",
+        emptyHint: emptyHint?.(step),
+        testId: `${testIdPrefix}-${step.id}-answer`
+      }
+    );
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-3", children: [
+    conversationId && onOpenConversation && /* @__PURE__ */ jsx("div", { className: "flex justify-end", children: /* @__PURE__ */ jsxs(
+      Button,
+      {
+        variant: "ghost",
+        size: "sm",
+        onClick: () => onOpenConversation(conversationId),
+        "data-testid": `${testIdPrefix}-open-thread`,
+        children: [
+          /* @__PURE__ */ jsx(ExternalLink, { className: "size-4" }),
+          " ",
+          l.openThread
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx(
+      WorkflowRunner,
+      {
+        ...runnerProps,
+        workflow,
+        run: view,
+        renderAgentOutput,
+        renderReview: (step) => conversationId ? /* @__PURE__ */ jsx(
+          ReviewNotify,
+          {
+            conversationId,
+            workspaceId: wsId,
+            labels: l,
+            testId: `${testIdPrefix}-${step.id}`
+          }
+        ) : null,
+        onUpload,
+        uploading,
+        files,
+        testIdPrefix
+      }
+    )
+  ] });
+}
+var READ_POLL_MS = 3e3;
+function fileStatus(status) {
+  const s = status?.toLowerCase();
+  if (!s) return void 0;
+  if (s === "failed") return "failed";
+  if (s === "completed" || s === "empty" || s === "low-content") return "ready";
+  return "processing";
+}
+function ReviewNotify({
+  conversationId,
+  workspaceId,
+  labels,
+  testId
+}) {
+  const arbi = useArbi();
+  const { status, user, ensureWorkspaceOpen } = useConnection();
+  const { data: members = [] } = useWorkspaceUsers(workspaceId, {
+    enabled: status === "authenticated" && !!workspaceId,
+    beforeFetch: ensureWorkspaceOpen
+  });
+  const people = members.filter(
+    (m) => !m.agent_ext_id && !m.user.external_id.startsWith("agt-") && m.user.external_id !== user?.externalId
+  );
+  const [picked, setPicked] = useState([]);
+  const [sent, setSent] = useState(false);
+  const [busy, setBusy] = useState(false);
+  if (people.length === 0) return null;
+  const toggle = (id) => setPicked((p) => p.includes(id) ? p.filter((x) => x !== id) : [...p, id]);
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-3", "data-testid": `${testId}-notify`, children: [
+    /* @__PURE__ */ jsx("div", { className: "flex flex-wrap gap-1.5", children: people.map((m) => {
+      const name = [m.user.given_name, m.user.family_name].filter(Boolean).join(" ") || m.user.email;
+      const on = picked.includes(m.user.external_id);
+      return /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          onClick: () => toggle(m.user.external_id),
+          "aria-pressed": on,
+          className: cn(
+            "rounded-full border px-2.5 py-1 text-xs",
+            on ? "border-primary bg-primary/10 text-primary" : "border-border text-muted-foreground"
+          ),
+          "data-testid": `${testId}-person-${m.user.external_id}`,
+          children: name
+        },
+        m.user.external_id
+      );
+    }) }),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          variant: "outline",
+          size: "sm",
+          disabled: !picked.length || busy,
+          onClick: async () => {
+            setBusy(true);
+            try {
+              await arbi.conversations.notify(conversationId, picked);
+              setSent(true);
+            } finally {
+              setBusy(false);
+            }
+          },
+          "data-testid": `${testId}-notify-send`,
+          children: labels.notify
+        }
+      ),
+      sent && /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: labels.notified })
+    ] })
+  ] });
+}
 function useConnectedShellWorkspaces(options = {}) {
   const { workspaceId, setWorkspace } = useConnection();
   const query = useWorkspaces();
@@ -777,6 +1128,6 @@ function ConnectedAgentChatPanel({
   ] });
 }
 
-export { ArbiAppProvider, ConnectedAgentChatPanel, ConnectedDangerZone, ConnectedIdentityVerification, ConnectedLogoutDialog, ConnectedNotificationPreferences, ConnectedProfileCard, ConnectedRequireVerified, ConnectedSecuritySection, ConnectedSessionsRow, ConnectedSkillUpload, ConnectedTaskAccessRequest, StreamedArtifact, defaultUnmetPasswordRequirement, useConnectedDocxNotifications, useConnectedShellWorkspaces, useConnectedWorkNotifications };
+export { ArbiAppProvider, ConnectedAgentChatPanel, ConnectedDangerZone, ConnectedIdentityVerification, ConnectedLogoutDialog, ConnectedNotificationPreferences, ConnectedProfileCard, ConnectedRequireVerified, ConnectedSecuritySection, ConnectedSessionsRow, ConnectedSkillUpload, ConnectedTaskAccessRequest, ConnectedWorkflowRunner, DEFAULT_CONNECTED_WORKFLOW_RUNNER_LABELS, StreamedArtifact, defaultUnmetPasswordRequirement, useConnectedDocxNotifications, useConnectedShellWorkspaces, useConnectedWorkNotifications };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map