@base44/superagent-native 0.0.2 → 0.0.3

package/src/types.ts

@@ -1,6 +1,8 @@
 import type { ComponentType, ReactNode } from 'react';
 import type { ProviderProps } from 'react-native-paper';
 
+import type { SuperagentColorScheme } from './theme';
+
 export type SuperagentToolCall = {
   id?: string;
   name: string;
@@ -144,10 +146,15 @@ export type SuperagentConversation = {
   messages?: SuperagentMessage[];
 };
 
+export type SuperagentAgentDonePayload = {
+  sender_platform_user_id?: string;
+  bootstrap_intro?: boolean;
+};
+
 export type SuperagentRealtimeHandlers = {
   onMessage?: (message: SuperagentMessage) => void;
   onConversation?: (conversation: SuperagentConversation) => void;
-  onAgentDone?: () => void;
+  onAgentDone?: (payload?: SuperagentAgentDonePayload) => void;
   onReconnect?: () => void;
   onError?: (error: unknown) => void;
 };
@@ -241,6 +248,7 @@ export type SuperagentTelegramChannelStatus = {
 export type SuperagentWhatsAppChannelStatus = {
   connected?: boolean;
   connectUrl?: string | null;
+  userHandle?: string | null;
 };
 
 export type SuperagentLineActivation = {
@@ -380,6 +388,10 @@ export type SuperagentNativeClient = {
   getConversation(conversationId: string): Promise<SuperagentConversation>;
   getMessages(conversationId: string, params?: { limit?: number; before?: string }): Promise<SuperagentPaginatedMessages>;
   createConversation(metadata?: Record<string, unknown>): Promise<SuperagentConversation>;
+  // Seeds a brand-new conversation with the lightweight intro turn. Unlike
+  // addMessage, the backend persists the seed hidden and skips sandbox acquisition,
+  // so opening an empty chat doesn't stall on a cold sandbox or burn a tool turn.
+  bootstrapIntro(conversationId: string, messageParams?: Record<string, unknown>): Promise<{ started: boolean }>;
   addMessage(conversationId: string, message: Partial<SuperagentMessage>): Promise<unknown>;
   stopConversation(conversationId: string): Promise<void>;
   getQueuedMessages(conversationId: string): Promise<{ messages: QueuedSuperagentMessage[] }>;
@@ -422,6 +434,10 @@ export type SuperagentMarkdownRenderer = ComponentType<SuperagentMarkdownRendere
 
 export type SuperagentHomeScreenProps = {
   activeAgentId?: string | null;
+  /** Initial color scheme; the in-app settings toggle can change it. Defaults to 'light'. */
+  defaultColorScheme?: SuperagentColorScheme;
+  /** Called when the user changes the scheme from settings (e.g. to persist it). */
+  onColorSchemeChange?: (scheme: SuperagentColorScheme) => void;
   agents?: SuperagentAgent[];
   latestMessages?: SuperagentMessage[];
   messagesByAgentId?: Record<string, SuperagentMessage[]>;
@@ -434,6 +450,9 @@ export type SuperagentHomeScreenProps = {
   navigationMode?: 'internal' | 'external';
   paperTheme?: ProviderProps['theme'];
   currentUserAvatarUrl?: string | null;
+  // Platform user id of the signed-in user. Used to ignore agent_done events from
+  // other collaborators in shared conversations (sender_platform_user_id filter).
+  currentUserId?: string | null;
   currentUserName?: string;
   fileLoadError?: string | null;
   fileLoadFailed?: boolean;
@@ -466,7 +485,7 @@ export type SuperagentHomeScreenProps = {
   isLoadingChannels?: boolean;
   isLoadingConnectors?: boolean;
   onCancelConnectorConnection?: (input: { agentId: string; connectorId: string }) => void;
-  onConnectConnector?: (input: SuperagentConnectorActionInput) => Promise<boolean | void> | boolean | void;
+  onConnectConnector?: (input: SuperagentConnectorActionInput) => Promise<boolean | string | void> | boolean | string | void;
   onDisconnectConnector?: (input: SuperagentConnectorActionInput) => Promise<void> | void;
   onArchiveAutomation?: (input: SuperagentAutomationActionInput) => Promise<void> | void;
   onCloneAgent?: (input: SuperagentAgentActionInput) => Promise<void> | void;

package/src/useSuperagentConversation.ts

@@ -1,18 +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';
@@ -24,6 +26,7 @@ type UseConversationParams = {
   agentId: string;
   apiClient?: SuperagentNativeClient;
   realtimeClient?: SuperagentRealtimeClient;
+  currentUserId?: string | null;
   fallbackMessages: SuperagentMessage[];
   fallbackSending: boolean;
   onAgentMessageDone?: () => Promise<void> | void;
@@ -35,6 +38,7 @@ export function useSuperagentConversation({
   agentId,
   apiClient,
   realtimeClient,
+  currentUserId,
   fallbackMessages,
   fallbackSending,
   onAgentMessageDone,
@@ -88,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);
@@ -104,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);
         }
@@ -134,23 +150,64 @@ export function useSuperagentConversation({
         const incoming = normalizeMessages(conversation.messages ?? []);
         setMessages((current) => mergeConversationSnapshot(current, incoming));
       },
-      onAgentDone() {
+      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;
         }
-        setIsSending(false);
-        setQueuedMessages([]);
-        onAgentMessageDoneRef.current?.();
-        if (apiClient) {
-          refreshConversation(apiClient, conversationId, setMessages)
-            .then(() => onConversationSettledRef.current?.())
-            .catch(() => {});
-        } else {
+        // 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
@@ -162,17 +219,19 @@ export function useSuperagentConversation({
         setInitError(error instanceof Error ? error.message : 'Realtime connection failed');
       },
     });
-  }, [apiClient, conversationId, 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();
@@ -186,7 +245,7 @@ export function useSuperagentConversation({
         // 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;
+        return false;
       }
       const sendGeneration = sendGenerationRef.current + 1;
       sendGenerationRef.current = sendGeneration;
@@ -195,9 +254,11 @@ export function useSuperagentConversation({
       };
 
       setIsSending(true);
-      const hasAssistantResponse = await sendWithFallback(agentId, trimmedContent, fileUrls, options.replyTo, onSendMessage, setMessages, setSendingForCurrentSend);
+      const { delivered, hasAssistantResponse } = await sendWithFallback(agentId, trimmedContent, fileUrls, options.replyTo, onSendMessage, setMessages, setSendingForCurrentSend, userMessage.id);
       if (hasAssistantResponse) onAgentMessageDoneRef.current?.();
-      return;
+      // 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;
@@ -218,9 +279,32 @@ export function useSuperagentConversation({
             () => onAgentMessageDoneRef.current?.(),
           );
         } else {
-          settleTimeoutRef.current = setTimeout(() => {
+          settleTimeoutRef.current = setTimeout(async () => {
             settleTimeoutRef.current = null;
-            refreshConversation(apiClient, conversationId, setMessages).catch(() => {});
+            // 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?.();
@@ -232,11 +316,36 @@ export function useSuperagentConversation({
       const response = await apiClient.addMessage(conversationId, userMessage);
       if (isQueuedResponse(response)) {
         setQueuedMessages((current) => [...current, { id: userMessage.id!, content: userMessage.content, position: current.length }]);
-        // A queued send still needs a settle path, or isSending / the queued strip stick.
-        armSettleFallback();
+        // 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 && hasNewAssistantResponse(refreshedMessages, assistantCountBefore)) {
+        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?.();
@@ -245,10 +354,18 @@ export function useSuperagentConversation({
           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, clearPendingSettlers, conversationId, onSendMessage, realtimeClient]);