@arbidocs/react 0.5.111 → 0.5.113

package/dist/chat/useConversationActions.js

@@ -0,0 +1,662 @@
+import { pendingChatModelSave } from "../config/config-hooks.js";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import {
+  ArbiApiError,
+  STOP_REPEAT_WINDOW_MS,
+  getRunToCancel,
+  quotaFromStreamError
+} from "@arbidocs/sdk/browser";
+import { notify } from "../shell/index.js";
+import { arbiQueryKeys } from "../hooks.js";
+import { useArbi } from "../useArbi.js";
+import { useArbiHost } from "../host/config.js";
+import { selectDraft, useArbiSessionStore } from "../session/index.js";
+import {
+  invalidateConversationLists,
+  isConversationShared,
+  patchConversation,
+  patchConversationList,
+  removeConversationFromLists
+} from "../conversation-list.js";
+import {
+  allConversationThreads,
+  clearLoadingState,
+  flushStreamingTokens,
+  getThreadsQueryKey,
+  updateUserMessageStateInCache
+} from "./conversation-cache.js";
+import {
+  assistantLabels,
+  cachedAssistantMode,
+  cachedMentionCandidates,
+  isCommentToPeople
+} from "./conversation-mentions.js";
+import { useAssistantName } from "../host/assistant-copy.js";
+import { hasMessageBody, toMessageMentions, extractMentions } from "./mentions.js";
+import { takeDocumentForTurn } from "./open-document.js";
+import { agentChatOwnerOf, creatorOf } from "./agent-chat-owner.js";
+import { bindThreadDocument, boundDocumentOf } from "./thread-binding.js";
+import { resolveReplyTarget } from "./reply-target.js";
+import {
+  confirmConversationWorkspace,
+  conversationWorkspaceOf,
+  watchConversationWorkspaces
+} from "./conversation-workspace.js";
+import { useStreamHandlers } from "./stream-handlers.js";
+import {
+  AGENT_CONTROL_COMMANDS,
+  cachedQuotaUsedUp,
+  disconnectAttachedRun,
+  refuseChatWhenOffline,
+  waitForResponseId
+} from "./turn-control.js";
+const RECONCILE_TIMEOUT_MS = 5e3;
+function draftAfterSend(queryClient, session, wasComment, assistantName) {
+  const shared = isConversationShared(queryClient, session.getState().conversationId);
+  return shared && !wasComment ? `@${assistantName} ` : "";
+}
+function failQueuedContinuation(queryClient, session, streamState) {
+  if (streamState.queuedUserMessageId) {
+    updateUserMessageStateInCache(
+      queryClient,
+      streamState.conversationId,
+      streamState.queuedUserMessageId,
+      "failed",
+      false
+    );
+  }
+  if (streamState.queuedClientId) {
+    session.removeQueuedMessage(streamState.queuedClientId);
+  }
+  notify.error("Queued message failed to send");
+}
+function signedInUserId(arbi) {
+  try {
+    return arbi.user.identity()?.externalId ?? null;
+  } catch {
+    return null;
+  }
+}
+function useConversationActions({
+  selectedWorkspaceId,
+  parentMessageId,
+  conversationKey,
+  isGenerating,
+  lastFailedMessage
+}) {
+  const queryClient = useQueryClient();
+  const session = useArbiSessionStore();
+  const currentConversationId = conversationKey === "new" ? null : conversationKey;
+  const invalidateUserWorkspaces = useCallback(
+    () => void queryClient.invalidateQueries({ queryKey: arbiQueryKeys.workspaces() }),
+    [queryClient]
+  );
+  const arbi = useArbi();
+  useState(() => watchConversationWorkspaces(queryClient, session));
+  const createHandlers = useStreamHandlers();
+  const chatHost = useArbiHost().chat;
+  const assistantName = useAssistantName();
+  const mentionCandidates = useCallback(
+    () => cachedMentionCandidates(
+      queryClient,
+      session.getState().workspaceId,
+      signedInUserId(arbi),
+      assistantName
+    ),
+    [queryClient, session, arbi, assistantName]
+  );
+  const stoppedStreamRef = useRef(null);
+  const stopInFlightRef = useRef(false);
+  const lastStopAtRef = useRef(0);
+  const retryInFlightRef = useRef(false);
+  const sendMessageRef = useRef(null);
+  const routeMessage = useCallback(
+    (content, conversationId) => {
+      const state = session.getState();
+      const convId = conversationId === void 0 ? state.conversationId : conversationId;
+      const { newConversationAssistantMode } = state;
+      const candidates = mentionCandidates();
+      const mentioned = extractMentions(content, candidates);
+      const assistantMode = cachedAssistantMode(queryClient, convId, newConversationAssistantMode);
+      const isComment = isCommentToPeople(queryClient, convId, content, candidates);
+      const mentions = toMessageMentions(mentioned);
+      if (!isComment && assistantMode === "mentioned" && !mentions.some((m) => m.type === "assistant")) {
+        mentions.push({ type: "assistant" });
+      }
+      return {
+        mentions,
+        assistantMode,
+        isComment
+      };
+    },
+    [queryClient, session, mentionCandidates]
+  );
+  const postComment = useCallback(
+    async (content, parentId, mentions, branch = false) => {
+      const convId = session.getState().conversationId;
+      try {
+        const saved = await arbi.conversations.postMessage({
+          content,
+          mentions,
+          // Only an explicit edit creates a branch. Ordinary comments append to the
+          // server's latest message, so simultaneous sends stay visible together. Else
+          // (nothing yet) start a thread. The mode only applies to a conversation it creates.
+          ...branch && parentId ? { previous_message_ext_id: parentId } : convId ? { conversation_ext_id: convId } : {},
+          assistant_mode: "mentioned"
+        });
+        const conversationId = saved.conversation_ext_id;
+        const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+        if (!convId) {
+          const bindTo = session.getState().newChatDocumentId;
+          session.moveConversation("new", conversationId);
+          if (bindTo) session.setNewChatDocumentId(null);
+          patchConversationList(queryClient, session.getState().workspaceId, (old) => [
+            {
+              external_id: conversationId,
+              title: content.slice(0, 40),
+              created_by_ext_id: saved.created_by_ext_id,
+              updated_by_ext_id: null,
+              created_at: nowIso,
+              updated_at: nowIso,
+              // A mention of someone who cannot see it yet shares it server-side: refetched below.
+              is_shared: false,
+              message_count: 1,
+              last_message_status: "completed",
+              assistant_mode: "mentioned"
+            },
+            ...old
+          ]);
+          if (bindTo)
+            bindThreadDocument(arbi, queryClient, conversationId, bindTo).catch(
+              () => notify.error("Could not attach the document to this thread")
+            );
+          invalidateUserWorkspaces();
+        } else {
+          patchConversation(queryClient, conversationId, (c) => ({
+            ...c,
+            message_count: c.message_count + 1,
+            updated_at: nowIso
+          }));
+        }
+        if (mentions.some((m) => m.type === "user")) {
+          await invalidateConversationLists(queryClient);
+        }
+        await queryClient.invalidateQueries({ queryKey: getThreadsQueryKey(conversationId) });
+        session.setCursor(saved.external_id);
+      } catch (error) {
+        notify.error(
+          error instanceof ArbiApiError && error.detail || "Failed to post the message"
+        );
+        if (!selectDraft(session.getState())) session.setDraft(content);
+      }
+    },
+    [arbi, session, queryClient, invalidateUserWorkspaces]
+  );
+  const sendMessage = useCallback(
+    async (content, requestedParentId, options) => {
+      const target = options?.target;
+      const parentId = options?.queuedContinuation || !requestedParentId ? requestedParentId : resolveReplyTarget(
+        queryClient,
+        (target ? target.conversationId : session.getState().conversationId) || "new",
+        requestedParentId
+      ) ?? requestedParentId;
+      const route = routeMessage(content, target?.conversationId);
+      if (route.isComment && !options?.queuedContinuation && !target) {
+        await postComment(content, parentId ?? null, route.mentions, options?.branch);
+        return;
+      }
+      const modelSave = pendingChatModelSave(session);
+      if (modelSave) await modelSave.catch(() => void 0);
+      const state = session.getState();
+      const convId = target ? target.conversationId : state.conversationId;
+      const convKey = convId || "new";
+      const turnWorkspaceId = target?.workspaceId ?? conversationWorkspaceOf(queryClient, convId) ?? selectedWorkspaceId;
+      const agentChat = state.newAgentChat;
+      let agentExtId = convId ? state.agentChatOwners[convId] : agentChat?.workspaceId === turnWorkspaceId ? agentChat.agentId : void 0;
+      if (convId && !agentExtId && creatorOf(queryClient, convId)?.startsWith("agt-")) {
+        agentExtId = await agentChatOwnerOf(queryClient, () => arbi.agents.list(), convId);
+        if (agentExtId) session.setAgentChatOwner(convId, agentExtId);
+      }
+      const queuedContinuation = options?.queuedContinuation === true;
+      const isNewConversation = !convId;
+      const documentIds = (state.conversationDocuments[convKey] || []).map((doc) => doc.docId);
+      const factIds = [...state.conversationFacts[convKey] || []];
+      const newConfigId = state.chatModel;
+      const cachedSettings = queryClient.getQueriesData({ queryKey: arbiQueryKeys.userSettings() }).map(([, data]) => data).find((data) => data?.last_config);
+      const lastConfigId = cachedSettings?.last_config;
+      const resolvedConfigId = newConfigId || (agentExtId ? void 0 : lastConfigId);
+      const isPaMode = !agentExtId && state.paMode;
+      const threadDocumentId = boundDocumentOf(queryClient, { ...state, conversationId: convId });
+      const activeArtifactExtId = isPaMode ? null : takeDocumentForTurn({
+        boundDocumentId: threadDocumentId,
+        conversationId: convId,
+        workspaceId: turnWorkspaceId
+      });
+      const pendingTools = state.pendingTools;
+      if (pendingTools) session.setPendingTools(null);
+      const toolsOverride = options?.toolsOverride ?? pendingTools ?? void 0;
+      const request = {
+        question: content,
+        workspaceId: turnWorkspaceId,
+        docIds: documentIds,
+        pinnedDocumentId: state.pinnedDocumentId,
+        factIds,
+        tools: toolsOverride,
+        personalAgent: isPaMode,
+        activeArtifactExtId,
+        // A new chat about a document is bound by its first turn, on the server (every device).
+        ...!convId && threadDocumentId ? { bindDocumentId: threadDocumentId } : {},
+        previousResponseId: parentId,
+        agentId: agentExtId,
+        model: resolvedConfigId,
+        mentions: route.mentions,
+        // A brand-new conversation starts in the mode picked in the composer.
+        ...!convId && route.assistantMode === "mentioned" ? { assistantMode: "mentioned" } : {}
+      };
+      const abortController = new AbortController();
+      if (!queuedContinuation) {
+        session.setConversationGenerating(convKey, true, abortController);
+      }
+      if (!queuedContinuation) {
+        patchConversation(queryClient, convKey, { last_message_status: "in_progress" });
+      }
+      const streamState = {
+        conversationId: convKey,
+        workspaceId: turnWorkspaceId,
+        assistantId: null,
+        // 0 = nothing narrated yet, so nothing is owed a reading window.
+        lastNarrationSettledAt: 0,
+        // True once the model has pivoted to a tool call and not yet resumed
+        // prose. Prose arriving while this is set opens a NEW narration, so the
+        // one before it closes: paragraph break, and everything above becomes
+        // superseded. Item boundaries alone cannot say this — the backend splits
+        // a single sentence across several items.
+        pivotedSinceProse: false,
+        // Steering that landed too late to steer this turn; resubmitted as a new
+        // turn once this one completes (see after the ask below).
+        deferredInterjections: [],
+        queuedContinuation,
+        queuedUserMessageId: null,
+        hasStreamStarted: false,
+        queuedFailed: false,
+        abortController,
+        isStopped: () => stoppedStreamRef.current === abortController,
+        queueOwnerAssistantId: options?.queueOwnerAssistantId ?? null,
+        queuedClientId: options?.queuedClientId ?? null,
+        // Set when a create_fact / label_facts tool runs this turn, so the Facts
+        // table + label vocabulary refresh on completion (see handleComplete).
+        factsTouched: false,
+        threadDocumentId,
+        // Set by the handlers: the server stored the question / reported its own failure.
+        userMessageId: null,
+        serverError: null
+      };
+      const handlers = createHandlers({
+        streamState,
+        parentMessageId: target ? parentId ?? null : parentMessageId,
+        parentId
+      });
+      const confirmTurnWorkspace = () => {
+        if (streamState.workspaceId)
+          confirmConversationWorkspace(
+            queryClient,
+            streamState.conversationId,
+            streamState.workspaceId
+          );
+      };
+      const onUserMessageInWorkspace = handlers.onUserMessage;
+      handlers.onUserMessage = (message) => {
+        onUserMessageInWorkspace(message);
+        confirmTurnWorkspace();
+      };
+      if (agentExtId) {
+        const onUserMessage = handlers.onUserMessage;
+        handlers.onUserMessage = (message) => {
+          if (message.conversation_ext_id) {
+            session.setAgentChatOwner(message.conversation_ext_id, agentExtId);
+            queryClient.invalidateQueries({ queryKey: arbiQueryKeys.agentChats(agentExtId) });
+          }
+          onUserMessage(message);
+        };
+      }
+      const ownsActiveGeneration = () => {
+        const activeGeneration = session.getState().generating[streamState.conversationId];
+        return activeGeneration?.abortController === abortController || !!streamState.assistantId && activeGeneration?.streamingAssistantId === streamState.assistantId;
+      };
+      try {
+        performance.mark("arbi:send-message:start");
+        await arbi.assistant.ask(request, {
+          signal: abortController.signal,
+          onMessageQueued: handlers.onMessageQueued,
+          onUserMessage: handlers.onUserMessage,
+          onStreamStart: handlers.onStreamStart,
+          onToken: handlers.onToken,
+          onMetadata: handlers.onMetadata,
+          onError: handlers.onError,
+          onComplete: handlers.onComplete,
+          // `response.output_item.added` is deliberately NOT consumed: an item
+          // opening told us only that SOME block had started, which is exactly the
+          // guess this design gave up. Text arrives via onOutputTextDelta and
+          // settles via onOutputItemDone.
+          onOutputItemDone: handlers.onOutputItemDone,
+          onOutputTextDelta: handlers.onOutputTextDelta,
+          onUserInputRequest: handlers.onUserInputRequest,
+          onProbeAnswer: handlers.onProbeAnswer,
+          onDeferredInterjection: handlers.onDeferredInterjection,
+          onAgentControlState: handlers.onAgentControlState,
+          onArtifact: handlers.onArtifact,
+          onMailDraft: handlers.onMailDraft,
+          onElapsedTime: handlers.onElapsedTime,
+          onContextUpdate: handlers.onContextUpdate,
+          onQuotaExceeded: (quota) => chatHost?.onQuotaExceeded?.(quota),
+          onWorkspace: (workspaceId) => {
+            streamState.workspaceId = workspaceId;
+            confirmTurnWorkspace();
+          }
+        });
+        flushStreamingTokens(queryClient);
+        if (queuedContinuation && !streamState.hasStreamStarted) {
+          if (streamState.queuedFailed) failQueuedContinuation(queryClient, session, streamState);
+          return;
+        }
+        if (streamState.serverError && !streamState.userMessageId && !streamState.assistantId && !queuedContinuation) {
+          if (ownsActiveGeneration()) {
+            session.setConversationError(
+              streamState.conversationId,
+              streamState.serverError,
+              content
+            );
+            void queryClient.invalidateQueries({
+              queryKey: getThreadsQueryKey(streamState.conversationId)
+            });
+            void invalidateConversationLists(queryClient);
+          }
+          return;
+        }
+        const ownsGeneration = ownsActiveGeneration();
+        if (ownsGeneration) {
+          session.setConversationGenerating(streamState.conversationId, false, null);
+        }
+        queryClient.invalidateQueries({ queryKey: arbiQueryKeys.userUsageToday() });
+        if (streamState.deferredInterjections.length > 0) {
+          const followUp = streamState.deferredInterjections.join("\n\n");
+          const threadParent = streamState.assistantId;
+          if (threadParent) {
+            session.clearQueuedMessages(threadParent);
+          }
+          void sendMessageRef.current?.(
+            followUp,
+            threadParent,
+            streamState.workspaceId && streamState.conversationId !== "new" ? {
+              target: {
+                workspaceId: streamState.workspaceId,
+                conversationId: streamState.conversationId
+              }
+            } : void 0
+          );
+        }
+        if (ownsGeneration) {
+          const lastStatus = streamState.serverError ? "failed" : "completed";
+          patchConversation(queryClient, streamState.conversationId, {
+            last_message_status: lastStatus
+          });
+        }
+        if (isNewConversation && ownsGeneration) invalidateUserWorkspaces();
+        if (ownsGeneration) {
+          clearLoadingState(queryClient, streamState.conversationId);
+        }
+      } catch (error) {
+        flushStreamingTokens(queryClient);
+        const isAbort = error instanceof Error && error.name === "AbortError";
+        const isDroppedConnection = !streamState.serverError && !isAbort && !streamState.isStopped();
+        if (queuedContinuation && !streamState.hasStreamStarted) {
+          if (isDroppedConnection && streamState.queuedUserMessageId) {
+            if (streamState.queuedClientId) {
+              session.removeQueuedMessage(streamState.queuedClientId);
+            }
+            void queryClient.invalidateQueries({
+              queryKey: getThreadsQueryKey(streamState.conversationId)
+            });
+            return;
+          }
+          failQueuedContinuation(queryClient, session, streamState);
+          return;
+        }
+        if (streamState.isStopped() || isAbort) {
+          console.debug("Message sending was aborted by user");
+          clearLoadingState(queryClient, streamState.conversationId);
+          void queryClient.invalidateQueries({
+            queryKey: getThreadsQueryKey(streamState.conversationId)
+          });
+          if (ownsActiveGeneration()) {
+            session.setConversationGenerating(streamState.conversationId, false, null);
+            patchConversation(queryClient, streamState.conversationId, {
+              last_message_status: "completed"
+            });
+          }
+          return;
+        }
+        console.error("Message sending failed:", error);
+        if (!ownsActiveGeneration()) return;
+        if (isDroppedConnection && streamState.userMessageId) {
+          let timer;
+          await Promise.race([
+            queryClient.invalidateQueries({
+              queryKey: getThreadsQueryKey(streamState.conversationId)
+            }),
+            new Promise((resolve) => {
+              timer = setTimeout(resolve, RECONCILE_TIMEOUT_MS);
+            })
+          ]);
+          clearTimeout(timer);
+          clearLoadingState(queryClient, streamState.conversationId);
+          if (ownsActiveGeneration()) {
+            session.setConversationGenerating(streamState.conversationId, false, null);
+          }
+          void invalidateConversationLists(queryClient);
+          return;
+        }
+        patchConversation(queryClient, streamState.conversationId, {
+          last_message_status: "failed"
+        });
+        const quota = quotaFromStreamError(error) ?? cachedQuotaUsedUp(queryClient, session.getState().workspaceId);
+        if (quota) chatHost?.onQuotaExceeded?.(quota);
+        session.setConversationError(
+          streamState.conversationId,
+          error instanceof Error ? error.message : String(error),
+          content
+        );
+      }
+    },
+    [
+      selectedWorkspaceId,
+      parentMessageId,
+      queryClient,
+      session,
+      createHandlers,
+      chatHost,
+      arbi,
+      invalidateUserWorkspaces,
+      routeMessage,
+      postComment
+    ]
+  );
+  sendMessageRef.current = sendMessage;
+  const handleCreateBranch = useCallback(
+    async (parentMessageExtId, newContent) => {
+      if (!newContent.trim() || !selectedWorkspaceId) return;
+      await sendMessage(newContent, parentMessageExtId, { branch: true });
+    },
+    [selectedWorkspaceId, sendMessage]
+  );
+  const handleSendMessage = useCallback(
+    async (options) => {
+      const currentMessage = selectDraft(session.getState()).trim();
+      if (!selectedWorkspaceId || !hasMessageBody(currentMessage, assistantLabels(assistantName)))
+        return;
+      session.setSuggestedQuery(null);
+      if (refuseChatWhenOffline()) return;
+      if (isGenerating) {
+        const convKey = session.getState().conversationId || "new";
+        const genState = session.getState().generating[convKey];
+        const streamingAssistantId = genState?.streamingAssistantId;
+        const route = routeMessage(currentMessage);
+        if (route.isComment && streamingAssistantId) {
+          session.setDraft(draftAfterSend(queryClient, session, route.isComment, assistantName));
+          await postComment(currentMessage, streamingAssistantId, route.mentions);
+          return;
+        }
+        if (streamingAssistantId) {
+          const command = currentMessage.toLowerCase();
+          const isPause = command === AGENT_CONTROL_COMMANDS.pause;
+          const isResume = command === AGENT_CONTROL_COMMANDS.resume;
+          const isReport = command === AGENT_CONTROL_COMMANDS.report || command.startsWith(`${AGENT_CONTROL_COMMANDS.report} `);
+          session.setDraft(draftAfterSend(queryClient, session, route.isComment, assistantName));
+          if (isPause) {
+            session.setAgentControlState(streamingAssistantId, "pausing");
+          } else if (isResume) {
+            session.setAgentControlState(streamingAssistantId, "resuming");
+          } else if (isReport) {
+            session.setAgentProbePending(streamingAssistantId, true);
+          }
+          if (isPause || isResume || isReport) {
+            await arbi.assistant.interject(streamingAssistantId, currentMessage);
+          } else {
+            const queuedClientId = `queued-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            session.addQueuedMessage(streamingAssistantId, {
+              clientId: queuedClientId,
+              content: currentMessage,
+              serverId: null,
+              acknowledged: false,
+              createdAt: Date.now()
+            });
+            await sendMessage(currentMessage, streamingAssistantId, {
+              ...options,
+              queuedContinuation: true,
+              queueOwnerAssistantId: streamingAssistantId,
+              queuedClientId
+            });
+          }
+          return;
+        }
+        return;
+      }
+      const parentId = session.getState().cursor;
+      session.setDraft(
+        draftAfterSend(queryClient, session, routeMessage(currentMessage).isComment, assistantName)
+      );
+      await sendMessage(currentMessage, parentId, options);
+    },
+    [
+      selectedWorkspaceId,
+      isGenerating,
+      session,
+      sendMessage,
+      arbi,
+      routeMessage,
+      postComment,
+      queryClient,
+      assistantName
+    ]
+  );
+  const handleAbortGeneration = useCallback(async () => {
+    const stream = session.getState().generating[conversationKey];
+    if (stopInFlightRef.current || stream?.isGenerating === false) return;
+    if (Date.now() - lastStopAtRef.current < STOP_REPEAT_WINDOW_MS) return;
+    lastStopAtRef.current = Date.now();
+    stopInFlightRef.current = true;
+    try {
+      const controller = stream?.abortController ?? null;
+      stoppedStreamRef.current = controller;
+      let streamKey = conversationKey;
+      let responseId = stream?.streamingAssistantId ?? null;
+      if (!responseId && controller) {
+        const reported = await waitForResponseId(session, controller);
+        if (reported) {
+          streamKey = reported.conversationKey;
+          responseId = reported.responseId;
+        }
+      }
+      const threads = queryClient.getQueryData(getThreadsQueryKey(streamKey))?.threads ?? [];
+      const runId = responseId ? getRunToCancel(threads, responseId) : null;
+      if (runId) {
+        try {
+          await arbi.assistant.cancel(runId);
+        } catch {
+          notify.warning(
+            "Stopped here, but the server didn't confirm: the answer may still appear later."
+          );
+        }
+      }
+      const current = session.getState().generating[streamKey];
+      const isStoppedStream = controller ? current?.abortController === controller : !current?.streamingAssistantId || current.streamingAssistantId === responseId;
+      if (isStoppedStream) session.abortConversationGeneration(streamKey);
+      if (responseId) disconnectAttachedRun(streamKey, responseId);
+    } finally {
+      stopInFlightRef.current = false;
+    }
+  }, [session, arbi, conversationKey, queryClient]);
+  const handleRetryOrphanedMessage = useCallback(
+    async (messageContent, parentId, messageExtId) => {
+      if (retryInFlightRef.current) return;
+      if (refuseChatWhenOffline()) return;
+      retryInFlightRef.current = true;
+      try {
+        const replyTo = currentConversationId ? resolveReplyTarget(queryClient, currentConversationId, parentId) : parentId;
+        if (!replyTo && currentConversationId) {
+          try {
+            await arbi.conversations.delete(currentConversationId);
+            removeConversationFromLists(queryClient, currentConversationId);
+            session.startNewConversation();
+          } catch (error) {
+            console.error("Failed to delete conversation with orphaned first message:", error);
+          }
+        } else if (replyTo) {
+          try {
+            await arbi.conversations.deleteMessage(messageExtId);
+            void queryClient.invalidateQueries(allConversationThreads);
+          } catch (error) {
+            console.error("Failed to delete orphaned message:", error);
+          }
+        }
+        await sendMessage(messageContent, replyTo);
+      } finally {
+        retryInFlightRef.current = false;
+      }
+    },
+    [currentConversationId, arbi, session, sendMessage, queryClient]
+  );
+  const handleRetrySend = useCallback(async () => {
+    if (isGenerating || !lastFailedMessage || retryInFlightRef.current) return;
+    if (refuseChatWhenOffline()) return;
+    retryInFlightRef.current = true;
+    try {
+      session.clearConversationError(conversationKey);
+      const parentId = session.getState().cursor;
+      await sendMessage(lastFailedMessage, parentId);
+    } finally {
+      retryInFlightRef.current = false;
+    }
+  }, [isGenerating, lastFailedMessage, session, conversationKey, sendMessage]);
+  const clearErrorState = useCallback(() => {
+    session.clearConversationError(conversationKey);
+  }, [session, conversationKey]);
+  useEffect(() => {
+    if (currentConversationId === null) {
+      session.clearConversationError("new");
+    }
+  }, [currentConversationId, session]);
+  return {
+    handleCreateBranch,
+    handleSendMessage,
+    handleAbortGeneration,
+    handleRetrySend,
+    handleRetryOrphanedMessage,
+    clearErrorState
+  };
+}
+export {
+  useConversationActions
+};
+//# sourceMappingURL=useConversationActions.js.map