@base44/superagent-native 0.0.1 → 0.0.3

package/src/useSuperagentConversation.ts

@@ -1,17 +1,20 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
-import { AUTO_GREET_MESSAGE, MESSAGES_PAGE_SIZE } from './constants';
+import { MESSAGES_PAGE_SIZE } from './constants';
 import {
   countAssistantResponses,
   createErrorMessage,
   createUserMessage,
   getMessageCursor,
   hasNewAssistantResponse,
+  hasRunningToolCall,
   isQueuedResponse,
   isVisibleMessage,
+  mergeConversationSnapshot,
   mergeMessage,
   normalizeMessages,
   pollConversation,
+  pollQueuedSend,
   refreshConversation,
   sendWithFallback,
 } from './conversationRuntime';
@@ -23,6 +26,7 @@ type UseConversationParams = {
   agentId: string;
   apiClient?: SuperagentNativeClient;
   realtimeClient?: SuperagentRealtimeClient;
+  currentUserId?: string | null;
   fallbackMessages: SuperagentMessage[];
   fallbackSending: boolean;
   onAgentMessageDone?: () => Promise<void> | void;
@@ -34,6 +38,7 @@ export function useSuperagentConversation({
   agentId,
   apiClient,
   realtimeClient,
+  currentUserId,
   fallbackMessages,
   fallbackSending,
   onAgentMessageDone,
@@ -48,6 +53,35 @@ export function useSuperagentConversation({
   const [initError, setInitError] = useState<string | null>(null);
   const [hasMoreMessages, setHasMoreMessages] = useState(false);
   const sendGenerationRef = useRef(0);
+  const pollIntervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const loadingPreviousRef = useRef(false);
+  const settleTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const messagesRef = useRef(messages);
+  const onAgentMessageDoneRef = useRef(onAgentMessageDone);
+  const onConversationSettledRef = useRef(onConversationSettled);
+
+  useEffect(() => { messagesRef.current = messages; }, [messages]);
+  useEffect(() => {
+    onAgentMessageDoneRef.current = onAgentMessageDone;
+    onConversationSettledRef.current = onConversationSettled;
+  }, [onAgentMessageDone, onConversationSettled]);
+
+  // Cancel any in-flight poll/settle timers — called on each new send and on unmount.
+  const clearPendingSettlers = useCallback(() => {
+    if (pollIntervalRef.current) {
+      clearInterval(pollIntervalRef.current);
+      pollIntervalRef.current = null;
+    }
+    if (settleTimeoutRef.current) {
+      clearTimeout(settleTimeoutRef.current);
+      settleTimeoutRef.current = null;
+    }
+  }, []);
+
+  // Clear any active poll interval / settle timeout when the hook unmounts.
+  useEffect(() => {
+    return () => clearPendingSettlers();
+  }, [clearPendingSettlers]);
 
   useEffect(() => {
     if (!apiClient) setMessages(fallbackMessages);
@@ -58,6 +92,13 @@ export function useSuperagentConversation({
     const client = apiClient;
     let cancelled = false;
 
+    // Clear the previous agent/client's conversation up front so a stale id or
+    // thread can't linger while the new one loads — or, if the reload fails, be
+    // shown or receive sends (conversationUnavailable only blocks with no id).
+    setConversationId(null);
+    setMessages([]);
+    setHasMoreMessages(false);
+
     async function initConversation() {
       setIsLoading(true);
       setInitError(null);
@@ -74,7 +115,12 @@ export function useSuperagentConversation({
         setHasMoreMessages(Boolean(page.has_more ?? page.hasMore));
 
         if ((conversation.messages ?? []).length === 0) {
-          await client.addMessage(conversation.id, createUserMessage(AUTO_GREET_MESSAGE));
+          // Seed the intro via bootstrap-intro (hidden seed, no sandbox acquisition)
+          // instead of sending a visible "Hey!" through the full /messages path —
+          // opening an empty chat shouldn't stall on a cold sandbox or burn a
+          // tool-capable turn. The assistant intro arrives via realtime / a later
+          // refresh, so we don't block on it here.
+          await client.bootstrapIntro(conversation.id);
           if (cancelled) return;
           await refreshConversation(client, conversation.id, setMessages);
         }
@@ -94,51 +140,113 @@ export function useSuperagentConversation({
 
     return realtimeClient.subscribeToConversation(conversationId, {
       onMessage(message) {
+        // Don't clear the sending/stop state on intermediate assistant messages
+        // (tool-call steps or streamed content arrive before the turn is done).
+        // The turn ends on `agent_done` (onAgentDone) or the 5s settle fallback.
         setMessages((current) => mergeMessage(current, message));
-        if (message.role === 'assistant' && (message.content || message.toolCalls?.length || message.tool_calls?.length)) {
-          setIsSending(false);
-        }
       },
       onConversation(conversation) {
         if (conversation.id !== conversationId) return;
-        setMessages(normalizeMessages(conversation.messages ?? []));
+        const incoming = normalizeMessages(conversation.messages ?? []);
+        setMessages((current) => mergeConversationSnapshot(current, incoming));
       },
-      onAgentDone() {
-        setIsSending(false);
-        onAgentMessageDone?.();
-        if (apiClient) {
-          refreshConversation(apiClient, conversationId, setMessages)
-            .then(() => onConversationSettled?.())
-            .catch(() => {});
-        } else {
-          onConversationSettled?.();
+      onAgentDone(payload) {
+        // Shared conversations: the backend tags agent_done with the sender's
+        // platform user id. Ignore completions from OTHER collaborators so a
+        // teammate's finishing run doesn't clear THIS user's sending state or fire
+        // their completion callbacks early (matches the web client).
+        if (payload?.sender_platform_user_id && currentUserId && payload.sender_platform_user_id !== currentUserId) {
+          return;
+        }
+        // Agent finished via realtime — cancel the 5s settle fallback so
+        // onConversationSettled doesn't also fire when the timer elapses.
+        if (settleTimeoutRef.current) {
+          clearTimeout(settleTimeoutRef.current);
+          settleTimeoutRef.current = null;
         }
+        // Guard the busy-state clear against a newer send superseding this turn
+        // while we refresh/poll: only clear if no later send has started since
+        // (mirrors setSendingForCurrentSend in sendMessage).
+        const sendGeneration = sendGenerationRef.current;
+        const setSendingIfCurrent = (value: boolean) => {
+          if (sendGenerationRef.current === sendGeneration) setIsSending(value);
+        };
+        const settle = () => {
+          setSendingIfCurrent(false);
+          setQueuedMessages([]);
+          onAgentMessageDoneRef.current?.();
+          onConversationSettledRef.current?.();
+        };
+        if (!apiClient) {
+          settle();
+          return;
+        }
+        const handOffToPoll = (assistantCountBefore: number) => {
+          // Keep the busy state and let the bounded poll finish the turn (it
+          // retries refreshes and settles once no tool is running or the cap is
+          // hit), matching the no-realtime poll and 5s settle paths.
+          if (pollIntervalRef.current) clearInterval(pollIntervalRef.current);
+          pollIntervalRef.current = pollConversation(
+            apiClient, conversationId, setMessages, setSendingIfCurrent, assistantCountBefore,
+            () => { setQueuedMessages([]); onConversationSettledRef.current?.(); },
+            () => onAgentMessageDoneRef.current?.(),
+          );
+        };
+        refreshConversation(apiClient, conversationId, setMessages)
+          .then((refreshed) => {
+            // agent_done arrived while a tool is still running in the snapshot —
+            // don't settle yet, let the poll loop finish it.
+            if (hasRunningToolCall(refreshed)) {
+              handOffToPoll(countAssistantResponses(refreshed));
+              return;
+            }
+            settle();
+          })
+          .catch(() => {
+            // The final refresh failed, so we can't tell whether a tool is still
+            // running — hand off to the bounded poll instead of clearing the busy
+            // state blind (it will settle on completion or the hard cap).
+            handOffToPoll(countAssistantResponses(messagesRef.current));
+          });
       },
       onReconnect() {
+        // A reconnect means the transient socket error cleared — drop the
+        // "something went wrong" state so it doesn't linger as a failed load.
+        setInitError(null);
         if (apiClient) refreshConversation(apiClient, conversationId, setMessages).catch(() => {});
       },
       onError(error) {
         setInitError(error instanceof Error ? error.message : 'Realtime connection failed');
       },
     });
-  }, [apiClient, conversationId, onAgentMessageDone, onConversationSettled, realtimeClient]);
+  }, [apiClient, conversationId, currentUserId, realtimeClient]);
 
   const visibleMessages = useMemo(
     () => messages.filter((message, index) => isVisibleMessage(message, index)),
     [messages],
   );
 
-  const sendMessage = useCallback(async (content: string, options: { fileUrls?: string[]; replyTo?: SuperagentReplyTo } = {}) => {
+  // Resolves true when the send was accepted (queued/sent), false when it failed
+  // before reaching the conversation — so the composer can restore the draft.
+  const sendMessage = useCallback(async (content: string, options: { fileUrls?: string[]; replyTo?: SuperagentReplyTo } = {}): Promise<boolean> => {
     const trimmedContent = content.trim();
     const fileUrls = options.fileUrls?.filter(Boolean) ?? [];
-    if (!trimmedContent && fileUrls.length === 0) return;
+    if (!trimmedContent && fileUrls.length === 0) return false;
+
+    // A new send supersedes any pending poll/settle timers from the previous one.
+    clearPendingSettlers();
 
-    const assistantCountBefore = countAssistantResponses(messages);
+    const assistantCountBefore = countAssistantResponses(messagesRef.current);
     const userMessage = createUserMessage(trimmedContent, { fileUrls, replyTo: options.replyTo });
     setMessages((current) => [...current, userMessage]);
 
     if (!apiClient || !conversationId) {
-      if (!onSendMessage) return;
+      if (!onSendMessage) {
+        // No send path yet (no fallback handler, or the conversation is still
+        // loading) — drop the optimistic bubble so the turn doesn't look sent.
+        setMessages((current) => current.filter((message) => message.id !== userMessage.id));
+        return false;
+      }
       const sendGeneration = sendGenerationRef.current + 1;
       sendGenerationRef.current = sendGeneration;
       const setSendingForCurrentSend = (value: boolean) => {
@@ -146,9 +254,11 @@ export function useSuperagentConversation({
       };
 
       setIsSending(true);
-      const hasAssistantResponse = await sendWithFallback(agentId, trimmedContent, fileUrls, options.replyTo, onSendMessage, setMessages, setSendingForCurrentSend);
-      if (hasAssistantResponse) onAgentMessageDone?.();
-      return;
+      const { delivered, hasAssistantResponse } = await sendWithFallback(agentId, trimmedContent, fileUrls, options.replyTo, onSendMessage, setMessages, setSendingForCurrentSend, userMessage.id);
+      if (hasAssistantResponse) onAgentMessageDoneRef.current?.();
+      // Report actual delivery so the composer restores the draft on a rejected
+      // fallback send instead of silently dropping the user's text/attachments.
+      return delivered;
     }
 
     const sendGeneration = sendGenerationRef.current + 1;
@@ -159,32 +269,105 @@ export function useSuperagentConversation({
 
     setIsSending(true);
     try {
+      // Wait for the turn to complete: poll without realtime, otherwise a 5s
+      // fallback in case agent_done never arrives.
+      const armSettleFallback = () => {
+        if (!realtimeClient) {
+          pollIntervalRef.current = pollConversation(
+            apiClient, conversationId, setMessages, setSendingForCurrentSend, assistantCountBefore,
+            () => { setQueuedMessages([]); onConversationSettledRef.current?.(); },
+            () => onAgentMessageDoneRef.current?.(),
+          );
+        } else {
+          settleTimeoutRef.current = setTimeout(async () => {
+            settleTimeoutRef.current = null;
+            // agent_done is late — hand off to the bounded poll loop, which keeps
+            // "sending" until tools finish (or the hard cap), instead of clearing
+            // it mid-turn.
+            const handOffToPoll = () => {
+              if (pollIntervalRef.current) clearInterval(pollIntervalRef.current);
+              pollIntervalRef.current = pollConversation(
+                apiClient, conversationId, setMessages, setSendingForCurrentSend, assistantCountBefore,
+                () => { setQueuedMessages([]); onConversationSettledRef.current?.(); },
+                () => onAgentMessageDoneRef.current?.(),
+              );
+            };
+            try {
+              const refreshed = await refreshConversation(apiClient, conversationId, setMessages);
+              if (hasRunningToolCall(refreshed)) {
+                handOffToPoll();
+                return;
+              }
+            } catch {
+              // Refresh failed — we can't tell whether a tool is still running, so
+              // hand off to the bounded poll rather than clearing the busy state
+              // blind (it retries and settles on completion or the hard cap).
+              handOffToPoll();
+              return;
+            }
+            setSendingForCurrentSend(false);
+            setQueuedMessages([]);
+            onAgentMessageDoneRef.current?.();
+            onConversationSettledRef.current?.();
+          }, 5000);
+        }
+      };
+
       const response = await apiClient.addMessage(conversationId, userMessage);
       if (isQueuedResponse(response)) {
         setQueuedMessages((current) => [...current, { id: userMessage.id!, content: userMessage.content, position: current.length }]);
+        // Another turn holds the conversation lock. Wait for OUR message to drain
+        // from the backend queue before settling — otherwise the running turn's
+        // completion would clear isSending / the queued strip early and let another
+        // send start while this one is still pending. pollQueuedSend re-baselines and
+        // hands off to the normal response poll once our turn actually starts.
+        if (pollIntervalRef.current) clearInterval(pollIntervalRef.current);
+        pollIntervalRef.current = pollQueuedSend(
+          apiClient, conversationId, userMessage.id!, setMessages, setSendingForCurrentSend,
+          (interval) => { pollIntervalRef.current = interval; },
+          () => { setQueuedMessages([]); onConversationSettledRef.current?.(); },
+          () => onAgentMessageDoneRef.current?.(),
+        );
       } else {
-        const refreshedMessages = await refreshConversation(apiClient, conversationId, setMessages);
-        if (!realtimeClient) {
-          if (hasNewAssistantResponse(refreshedMessages, assistantCountBefore)) {
-            setSendingForCurrentSend(false);
-            onAgentMessageDone?.();
-            onConversationSettled?.();
-          } else {
-            pollConversation(apiClient, conversationId, setMessages, setSendingForCurrentSend, assistantCountBefore, onConversationSettled, onAgentMessageDone);
-          }
+        let refreshedMessages;
+        try {
+          refreshedMessages = await refreshConversation(apiClient, conversationId, setMessages);
+        } catch {
+          // addMessage already succeeded (a non-queued send returns only after the
+          // agent is invoked), so the turn IS delivered. A failed post-send refresh
+          // must NOT drop the optimistic row or report failure — that would make
+          // ConversationChat restore the draft and the user resend, duplicating the
+          // message. Hand off to the bounded poll/settle loop and report delivered.
+          armSettleFallback();
+          return true;
+        }
+        // Only complete immediately if a new assistant reply landed AND no tool is
+        // still running — otherwise hand off to armSettleFallback (pollConversation
+        // without realtime), which keeps "sending" until tools finish. Matches the
+        // poll/settle paths so tool-using turns don't drop the busy state early.
+        if (!realtimeClient && hasNewAssistantResponse(refreshedMessages, assistantCountBefore) && !hasRunningToolCall(refreshedMessages)) {
+          setSendingForCurrentSend(false);
+          setQueuedMessages([]);
+          onAgentMessageDoneRef.current?.();
+          onConversationSettledRef.current?.();
         } else {
-          setTimeout(() => {
-            setSendingForCurrentSend(false);
-            onConversationSettled?.();
-          }, 5000);
+          armSettleFallback();
         }
       }
+      return true;
     } catch (error) {
+      // The optimistic bubble never reached the server (addMessage threw), so drop
+      // it and surface the error in its place — otherwise the turn looks sent and a
+      // later refresh/resend could duplicate it. Mirrors the no-send-path above.
       const errorMessage = createErrorMessage(error);
-      setMessages((current) => [...current, errorMessage]);
+      setMessages((current) => [
+        ...current.filter((message) => message.id !== userMessage.id),
+        errorMessage,
+      ]);
       setSendingForCurrentSend(false);
+      return false;
     }
-  }, [agentId, apiClient, conversationId, messages, onAgentMessageDone, onConversationSettled, onSendMessage, realtimeClient]);
+  }, [agentId, apiClient, clearPendingSettlers, conversationId, onSendMessage, realtimeClient]);
 
   const deleteMessage = useCallback(async (messageId: string) => {
     if (!messageId || messageId === 'welcome') return false;
@@ -196,16 +379,23 @@ export function useSuperagentConversation({
 
     try {
       await apiClient.deleteMessage(conversationId, messageId);
+      // Remove locally before refreshing: mergeConversationSnapshot keeps rows
+      // missing from the server snapshot, so without this the just-deleted
+      // message would be resurrected.
+      setMessages((current) => current.filter((message) => message.id !== messageId));
       await refreshConversation(apiClient, conversationId, setMessages);
       return true;
-    } catch (error) {
-      setInitError(error instanceof Error ? error.message : 'Failed to delete message');
+    } catch {
+      // A failed delete is not a load failure — don't drive the "something went
+      // wrong" panel (it would persist). Signal failure via the return value so
+      // the caller can surface it.
       return false;
     }
   }, [apiClient, conversationId]);
 
   const stop = useCallback(async () => {
     sendGenerationRef.current += 1;
+    clearPendingSettlers();
 
     if (!apiClient || !conversationId) {
       setIsSending(false);
@@ -216,20 +406,32 @@ export function useSuperagentConversation({
     setQueuedMessages([]);
     await apiClient.stopConversation(conversationId);
     await refreshConversation(apiClient, conversationId, setMessages);
-  }, [apiClient, conversationId]);
+  }, [apiClient, clearPendingSettlers, conversationId]);
 
   const loadPrevious = useCallback(async () => {
+    if (loadingPreviousRef.current) return;
     const before = getMessageCursor(messages[0]);
     if (!apiClient || !conversationId || !before) return;
-    const page = await apiClient.getMessages(conversationId, { limit: MESSAGES_PAGE_SIZE, before });
-    setMessages((current) => [...normalizeMessages(page.messages), ...current]);
-    setHasMoreMessages(Boolean(page.has_more ?? page.hasMore));
+    loadingPreviousRef.current = true;
+    try {
+      const page = await apiClient.getMessages(conversationId, { limit: MESSAGES_PAGE_SIZE, before });
+      setMessages((current) => [...normalizeMessages(page.messages), ...current]);
+      setHasMoreMessages(Boolean(page.has_more ?? page.hasMore));
+    } catch {
+      // Pagination failed — swallow so it isn't an unhandled rejection from the
+      // button, and leave hasMoreMessages as-is so the user can retry.
+    } finally {
+      loadingPreviousRef.current = false;
+    }
   }, [apiClient, conversationId, messages]);
 
   const submitToolCallInput = useCallback(async (toolCallId: string, approve: boolean, extraUserInput?: unknown, originRequestId?: string): Promise<SuperagentConversation | null> => {
     if (!apiClient || !conversationId) return null;
     const updated = await apiClient.submitToolCallInput(conversationId, toolCallId, approve, extraUserInput, originRequestId);
-    if (updated.messages) setMessages(normalizeMessages(updated.messages));
+    if (updated.messages) {
+      const incoming = normalizeMessages(updated.messages);
+      setMessages((current) => mergeConversationSnapshot(current, incoming));
+    }
     onConversationSettled?.();
     return updated;
   }, [apiClient, conversationId, onConversationSettled]);