@base44/superagent-native 0.0.1 → 0.0.3

package/lib/commonjs/theme.js

@@ -0,0 +1,249 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SuperagentThemeContext = void 0;
+exports.createThemedStyles = createThemedStyles;
+exports.getSuperagentColorScheme = getSuperagentColorScheme;
+exports.syncSuperagentColorScheme = syncSuperagentColorScheme;
+exports.themedBorder = themedBorder;
+exports.themedColor = themedColor;
+exports.themedSurface = themedSurface;
+exports.useSuperagentTheme = useSuperagentTheme;
+var _react = require("react");
+var _reactNative = require("react-native");
+/**
+ * Theming for the Superagent native package.
+ *
+ * All stylesheets in this package are authored in the original dark palette;
+ * light mode (the default) is derived by remapping those colors through the
+ * tables below. `createThemedStyles` builds both StyleSheets up front and
+ * returns a proxy that resolves against the active scheme on every property
+ * read, so existing `styles.foo` call sites keep working unchanged. The
+ * scheme lives in module state synced from the provider in
+ * SuperagentHomeScreen during render; nothing in the tree is memoized, so a
+ * scheme change at the root re-renders (and re-reads) everything.
+ */
+
+let currentScheme = 'light';
+function getSuperagentColorScheme() {
+  return currentScheme;
+}
+function syncSuperagentColorScheme(scheme) {
+  currentScheme = scheme;
+}
+const SuperagentThemeContext = exports.SuperagentThemeContext = /*#__PURE__*/(0, _react.createContext)({
+  scheme: 'light',
+  setScheme: () => {}
+});
+function useSuperagentTheme() {
+  return (0, _react.useContext)(SuperagentThemeContext);
+}
+
+// Dark background -> light background.
+const BG_MAP = {
+  '#000000': '#F3F3F3',
+  '#050505': '#FFFFFF',
+  '#070707': '#FFFFFF',
+  '#080808': '#FFFFFF',
+  '#0A0A0A': '#FFFFFF',
+  '#0B0B0C': '#FFFFFF',
+  '#0F0F10': '#FFFFFF',
+  '#101010': '#FFFFFF',
+  '#101012': '#FFFFFF',
+  '#111111': '#FFFFFF',
+  '#111113': '#FFFFFF',
+  '#141414': '#FFFFFF',
+  '#151515': '#F4F4F5',
+  '#171717': '#F4F4F5',
+  '#181818': '#F4F4F5',
+  '#1B1B1B': '#F4F4F5',
+  '#1F1F22': '#F4F4F5',
+  '#1F1F23': '#F4F4F5',
+  '#242424': '#F4F4F5',
+  '#242427': '#F4F4F5',
+  '#252528': '#F4F4F5',
+  '#262626': '#F4F4F5',
+  '#2A2A2A': '#E4E4E7',
+  '#2C2C2E': '#E4E4E7',
+  '#3A3A3E': '#E4E4E7',
+  '#BDBDC2': '#A1A1AA',
+  '#F4F4F5': '#18181B',
+  // Cream CTAs become the dark CTA treatment on light surfaces.
+  '#F7F3E7': '#18181B',
+  '#F4F0E6': '#18181B',
+  // Status / accent tints.
+  '#11251A': '#DCFCE7',
+  '#13231D': '#DCFCE7',
+  '#21110A': '#FFEDD5',
+  '#1D120D': '#FFEDD5',
+  '#1C0F10': '#FEE2E2',
+  '#241111': '#FEE2E2',
+  '#351516': '#FEE2E2',
+  '#102036': '#DBEAFE',
+  '#1E1B4B': '#E0E7FF',
+  '#312E81': '#E0E7FF'
+};
+
+// Dark border -> light border.
+const BORDER_MAP = {
+  '#101012': '#E4E4E7',
+  '#1F1F23': '#E4E4E7',
+  '#242427': '#E4E4E7',
+  '#242429': '#E4E4E7',
+  '#252529': '#E4E4E7',
+  '#27272A': '#E4E4E7',
+  '#29292E': '#E4E4E7',
+  '#2A2A2A': '#E4E4E7',
+  '#2A2A2D': '#E4E4E7',
+  '#2A2A2E': '#E4E4E7',
+  '#303035': '#E4E4E7',
+  '#333333': '#E4E4E7',
+  '#333338': '#E4E4E7',
+  '#34343A': '#E4E4E7',
+  '#353535': '#E4E4E7',
+  '#353539': '#E4E4E7',
+  '#38383D': '#E4E4E7',
+  '#3A3A3C': '#E4E4E7',
+  '#3F3F46': '#D4D4D8',
+  '#F4F4F5': '#18181B',
+  // Status borders.
+  '#3B2222': '#FECACA',
+  '#552022': '#FECACA',
+  '#5F2424': '#FECACA',
+  '#3A2317': '#FED7AA',
+  '#4A2413': '#FED7AA'
+};
+
+// Dark foreground (text / icons) -> light foreground.
+const TEXT_MAP = {
+  '#FFFFFF': '#18181B',
+  // Home title: near-white in dark mode, #0F0F0F in light (per design spec).
+  '#FAFAFA': '#0F0F0F',
+  // Dark-on-light-accent foregrounds invert with their CTA surfaces.
+  '#111111': '#FFFFFF',
+  '#F7F7F7': '#18181B',
+  '#F4F4F5': '#18181B',
+  '#E4E4E7': '#3F3F46',
+  '#DADADA': '#3F3F46',
+  '#D4D4D8': '#3F3F46',
+  '#C7C7CC': '#52525B',
+  '#BDBDC2': '#52525B',
+  '#A1A1AA': '#52525B',
+  '#8E8E93': '#71717A',
+  '#73737A': '#A1A1AA',
+  // Status / accent foregrounds tuned for light surfaces.
+  '#FCA5A5': '#DC2626',
+  '#FECACA': '#B91C1C',
+  '#FF6B6B': '#DC2626',
+  '#86EFAC': '#15803D',
+  '#34D399': '#059669',
+  '#FDE68A': '#A16207',
+  '#F8D77B': '#A16207',
+  '#FDE047': '#A16207',
+  '#FBBF24': '#B45309',
+  '#C9CAF8': '#4F46E5',
+  '#A5B4FC': '#4F46E5',
+  '#E0E7FF': '#3730A3',
+  '#93C5FD': '#1D4ED8',
+  '#8AB4F8': '#1D4ED8'
+};
+
+/** Light-mode color for a dark-authored foreground (text / icon) color. */
+function themedColor(darkColor) {
+  if (currentScheme === 'dark') {
+    return darkColor;
+  }
+  return TEXT_MAP[darkColor.toUpperCase()] ?? darkColor;
+}
+
+/** Light-mode color for a dark-authored surface (background) color. */
+function themedSurface(darkColor) {
+  if (currentScheme === 'dark') {
+    return darkColor;
+  }
+  return BG_MAP[darkColor.toUpperCase()] ?? darkColor;
+}
+
+/** Light-mode color for a dark-authored border color. */
+function themedBorder(darkColor) {
+  if (currentScheme === 'dark') {
+    return darkColor;
+  }
+  return BORDER_MAP[darkColor.toUpperCase()] ?? darkColor;
+}
+
+// Brand typography: Wix Madefor, with the original heavy weights stepped
+// down to match the web app's lighter look. Native consumers must bundle the
+// "Wix Madefor Text" font family; the web demo loads it from Google Fonts.
+const SUPERAGENT_FONT_FAMILY = 'Wix Madefor Text';
+const FONT_WEIGHT_MAP = {
+  '900': '600',
+  '800': '500',
+  '700': '500',
+  '600': '400',
+  bold: '600'
+};
+function applyTypography(style) {
+  const isText = 'fontSize' in style || 'fontWeight' in style || 'lineHeight' in style;
+  if (!isText) {
+    return style;
+  }
+  const next = {
+    ...style
+  };
+  if (!next.fontFamily) {
+    next.fontFamily = SUPERAGENT_FONT_FAMILY;
+  }
+  const weight = next.fontWeight;
+  if (typeof weight === 'string' && FONT_WEIGHT_MAP[weight]) {
+    next.fontWeight = FONT_WEIGHT_MAP[weight];
+  }
+  return next;
+}
+const BG_KEYS = new Set(['backgroundColor']);
+const BORDER_KEYS = new Set(['borderColor', 'borderTopColor', 'borderBottomColor', 'borderLeftColor', 'borderRightColor']);
+const TEXT_KEYS = new Set(['color', 'textDecorationColor', 'tintColor']);
+// shadowColor stays dark in both schemes.
+
+function toLightStyle(style) {
+  const light = {};
+  for (const [key, value] of Object.entries(style)) {
+    if (typeof value === 'string' && value.startsWith('#')) {
+      const upper = value.toUpperCase();
+      if (BG_KEYS.has(key)) {
+        light[key] = BG_MAP[upper] ?? value;
+        continue;
+      }
+      if (BORDER_KEYS.has(key)) {
+        light[key] = BORDER_MAP[upper] ?? value;
+        continue;
+      }
+      if (TEXT_KEYS.has(key)) {
+        light[key] = TEXT_MAP[upper] ?? value;
+        continue;
+      }
+    }
+    light[key] = value;
+  }
+  return light;
+}
+
+/**
+ * Drop-in replacement for StyleSheet.create: takes dark-authored styles and
+ * returns a proxy resolving each style against the active color scheme.
+ */
+function createThemedStyles(base) {
+  const typographyBase = Object.fromEntries(Object.entries(base).map(([name, style]) => [name, applyTypography(style)]));
+  const dark = _reactNative.StyleSheet.create(typographyBase);
+  const lightBase = Object.fromEntries(Object.entries(typographyBase).map(([name, style]) => [name, toLightStyle(style)]));
+  const light = _reactNative.StyleSheet.create(lightBase);
+  return new Proxy(dark, {
+    get(_, property) {
+      const sheets = currentScheme === 'dark' ? dark : light;
+      return sheets[property];
+    }
+  });
+}
+//# sourceMappingURL=theme.js.map

package/lib/commonjs/theme.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_reactNative","currentScheme","getSuperagentColorScheme","syncSuperagentColorScheme","scheme","SuperagentThemeContext","exports","createContext","setScheme","useSuperagentTheme","useContext","BG_MAP","BORDER_MAP","TEXT_MAP","themedColor","darkColor","toUpperCase","themedSurface","themedBorder","SUPERAGENT_FONT_FAMILY","FONT_WEIGHT_MAP","bold","applyTypography","style","isText","next","fontFamily","weight","fontWeight","BG_KEYS","Set","BORDER_KEYS","TEXT_KEYS","toLightStyle","light","key","value","Object","entries","startsWith","upper","has","createThemedStyles","base","typographyBase","fromEntries","map","name","dark","StyleSheet","create","lightBase","Proxy","get","_","property","sheets"],"sourceRoot":"../../src","sources":["theme.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/useSuperagentConversation.js

@@ -11,6 +11,7 @@ function useSuperagentConversation({
   agentId,
   apiClient,
   realtimeClient,
+  currentUserId,
   fallbackMessages,
   fallbackSending,
   onAgentMessageDone,
@@ -25,6 +26,36 @@ function useSuperagentConversation({
   const [initError, setInitError] = (0, _react.useState)(null);
   const [hasMoreMessages, setHasMoreMessages] = (0, _react.useState)(false);
   const sendGenerationRef = (0, _react.useRef)(0);
+  const pollIntervalRef = (0, _react.useRef)(null);
+  const loadingPreviousRef = (0, _react.useRef)(false);
+  const settleTimeoutRef = (0, _react.useRef)(null);
+  const messagesRef = (0, _react.useRef)(messages);
+  const onAgentMessageDoneRef = (0, _react.useRef)(onAgentMessageDone);
+  const onConversationSettledRef = (0, _react.useRef)(onConversationSettled);
+  (0, _react.useEffect)(() => {
+    messagesRef.current = messages;
+  }, [messages]);
+  (0, _react.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 = (0, _react.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.
+  (0, _react.useEffect)(() => {
+    return () => clearPendingSettlers();
+  }, [clearPendingSettlers]);
   (0, _react.useEffect)(() => {
     if (!apiClient) setMessages(fallbackMessages);
   }, [apiClient, fallbackMessages]);
@@ -32,6 +63,13 @@ function useSuperagentConversation({
     if (!apiClient) return;
     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);
@@ -50,7 +88,12 @@ function useSuperagentConversation({
         setMessages((0, _conversationRuntime.normalizeMessages)(conversation.messages ?? []));
         setHasMoreMessages(Boolean(page.has_more ?? page.hasMore));
         if ((conversation.messages ?? []).length === 0) {
-          await client.addMessage(conversation.id, (0, _conversationRuntime.createUserMessage)(_constants.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 (0, _conversationRuntime.refreshConversation)(client, conversation.id, setMessages);
         }
@@ -69,54 +112,121 @@ function useSuperagentConversation({
     if (!realtimeClient || !conversationId) return undefined;
     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 => (0, _conversationRuntime.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((0, _conversationRuntime.normalizeMessages)(conversation.messages ?? []));
+        const incoming = (0, _conversationRuntime.normalizeMessages)(conversation.messages ?? []);
+        setMessages(current => (0, _conversationRuntime.mergeConversationSnapshot)(current, incoming));
       },
-      onAgentDone() {
-        setIsSending(false);
-        onAgentMessageDone?.();
-        if (apiClient) {
-          (0, _conversationRuntime.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 => {
+          if (sendGenerationRef.current === sendGeneration) setIsSending(value);
+        };
+        const settle = () => {
+          setSendingIfCurrent(false);
+          setQueuedMessages([]);
+          onAgentMessageDoneRef.current?.();
+          onConversationSettledRef.current?.();
+        };
+        if (!apiClient) {
+          settle();
+          return;
+        }
+        const handOffToPoll = assistantCountBefore => {
+          // 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 = (0, _conversationRuntime.pollConversation)(apiClient, conversationId, setMessages, setSendingIfCurrent, assistantCountBefore, () => {
+            setQueuedMessages([]);
+            onConversationSettledRef.current?.();
+          }, () => onAgentMessageDoneRef.current?.());
+        };
+        (0, _conversationRuntime.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 ((0, _conversationRuntime.hasRunningToolCall)(refreshed)) {
+            handOffToPoll((0, _conversationRuntime.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((0, _conversationRuntime.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) (0, _conversationRuntime.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 = (0, _react.useMemo)(() => messages.filter((message, index) => (0, _conversationRuntime.isVisibleMessage)(message, index)), [messages]);
+
+  // 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 = (0, _react.useCallback)(async (content, options = {}) => {
     const trimmedContent = content.trim();
     const fileUrls = options.fileUrls?.filter(Boolean) ?? [];
-    if (!trimmedContent && fileUrls.length === 0) return;
-    const assistantCountBefore = (0, _conversationRuntime.countAssistantResponses)(messages);
+    if (!trimmedContent && fileUrls.length === 0) return false;
+
+    // A new send supersedes any pending poll/settle timers from the previous one.
+    clearPendingSettlers();
+    const assistantCountBefore = (0, _conversationRuntime.countAssistantResponses)(messagesRef.current);
     const userMessage = (0, _conversationRuntime.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 => {
         if (sendGenerationRef.current === sendGeneration) setIsSending(value);
       };
       setIsSending(true);
-      const hasAssistantResponse = await (0, _conversationRuntime.sendWithFallback)(agentId, trimmedContent, fileUrls, options.replyTo, onSendMessage, setMessages, setSendingForCurrentSend);
-      if (hasAssistantResponse) onAgentMessageDone?.();
-      return;
+      const {
+        delivered,
+        hasAssistantResponse
+      } = await (0, _conversationRuntime.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;
     sendGenerationRef.current = sendGeneration;
@@ -125,6 +235,47 @@ 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 = (0, _conversationRuntime.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 = (0, _conversationRuntime.pollConversation)(apiClient, conversationId, setMessages, setSendingForCurrentSend, assistantCountBefore, () => {
+                setQueuedMessages([]);
+                onConversationSettledRef.current?.();
+              }, () => onAgentMessageDoneRef.current?.());
+            };
+            try {
+              const refreshed = await (0, _conversationRuntime.refreshConversation)(apiClient, conversationId, setMessages);
+              if ((0, _conversationRuntime.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 ((0, _conversationRuntime.isQueuedResponse)(response)) {
         setQueuedMessages(current => [...current, {
@@ -132,29 +283,55 @@ function useSuperagentConversation({
           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 = (0, _conversationRuntime.pollQueuedSend)(apiClient, conversationId, userMessage.id, setMessages, setSendingForCurrentSend, interval => {
+          pollIntervalRef.current = interval;
+        }, () => {
+          setQueuedMessages([]);
+          onConversationSettledRef.current?.();
+        }, () => onAgentMessageDoneRef.current?.());
       } else {
-        const refreshedMessages = await (0, _conversationRuntime.refreshConversation)(apiClient, conversationId, setMessages);
-        if (!realtimeClient) {
-          if ((0, _conversationRuntime.hasNewAssistantResponse)(refreshedMessages, assistantCountBefore)) {
-            setSendingForCurrentSend(false);
-            onAgentMessageDone?.();
-            onConversationSettled?.();
-          } else {
-            (0, _conversationRuntime.pollConversation)(apiClient, conversationId, setMessages, setSendingForCurrentSend, assistantCountBefore, onConversationSettled, onAgentMessageDone);
-          }
+        let refreshedMessages;
+        try {
+          refreshedMessages = await (0, _conversationRuntime.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 && (0, _conversationRuntime.hasNewAssistantResponse)(refreshedMessages, assistantCountBefore) && !(0, _conversationRuntime.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 = (0, _conversationRuntime.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 = (0, _react.useCallback)(async messageId => {
     if (!messageId || messageId === 'welcome') return false;
     if (!apiClient || !conversationId) {
@@ -163,15 +340,22 @@ 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 (0, _conversationRuntime.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 = (0, _react.useCallback)(async () => {
     sendGenerationRef.current += 1;
+    clearPendingSettlers();
     if (!apiClient || !conversationId) {
       setIsSending(false);
       return;
@@ -180,21 +364,33 @@ function useSuperagentConversation({
     setQueuedMessages([]);
     await apiClient.stopConversation(conversationId);
     await (0, _conversationRuntime.refreshConversation)(apiClient, conversationId, setMessages);
-  }, [apiClient, conversationId]);
+  }, [apiClient, clearPendingSettlers, conversationId]);
   const loadPrevious = (0, _react.useCallback)(async () => {
+    if (loadingPreviousRef.current) return;
     const before = (0, _conversationRuntime.getMessageCursor)(messages[0]);
     if (!apiClient || !conversationId || !before) return;
-    const page = await apiClient.getMessages(conversationId, {
-      limit: _constants.MESSAGES_PAGE_SIZE,
-      before
-    });
-    setMessages(current => [...(0, _conversationRuntime.normalizeMessages)(page.messages), ...current]);
-    setHasMoreMessages(Boolean(page.has_more ?? page.hasMore));
+    loadingPreviousRef.current = true;
+    try {
+      const page = await apiClient.getMessages(conversationId, {
+        limit: _constants.MESSAGES_PAGE_SIZE,
+        before
+      });
+      setMessages(current => [...(0, _conversationRuntime.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 = (0, _react.useCallback)(async (toolCallId, approve, extraUserInput, originRequestId) => {
     if (!apiClient || !conversationId) return null;
     const updated = await apiClient.submitToolCallInput(conversationId, toolCallId, approve, extraUserInput, originRequestId);
-    if (updated.messages) setMessages((0, _conversationRuntime.normalizeMessages)(updated.messages));
+    if (updated.messages) {
+      const incoming = (0, _conversationRuntime.normalizeMessages)(updated.messages);
+      setMessages(current => (0, _conversationRuntime.mergeConversationSnapshot)(current, incoming));
+    }
     onConversationSettled?.();
     return updated;
   }, [apiClient, conversationId, onConversationSettled]);