@base44/superagent-native 0.0.1 → 0.0.3

package/lib/commonjs/useSuperagentRuntime.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useSuperagentRuntime = useSuperagentRuntime;
 var _react = require("react");
+var _reactNative = require("react-native");
 var _apiClient = require("./apiClient.js");
 var _fileTreeUtils = require("./fileTreeUtils.js");
 var _realtimeClient = require("./realtimeClient.js");
@@ -22,6 +23,10 @@ function useSuperagentRuntime({
   }), [config.baseUrl, config.currentUserId, config.getAccessToken, config.getHeaders]);
   const [agents, setAgents] = (0, _react.useState)([]);
   const [activeAgentId, setActiveAgentId] = (0, _react.useState)(initialAgentId ?? null);
+  // Always-latest active agent id, so a slow load for a previous agent can detect
+  // that the user has since switched and skip applying its (now stale) result.
+  const activeAgentIdRef = (0, _react.useRef)(activeAgentId);
+  activeAgentIdRef.current = activeAgentId;
   const [currentRoute, setCurrentRoute] = (0, _react.useState)(initialAgentId ? {
     name: 'agent',
     agentId: initialAgentId
@@ -48,6 +53,11 @@ function useSuperagentRuntime({
   const [isLoading, setIsLoading] = (0, _react.useState)(true);
   const [loadError, setLoadError] = (0, _react.useState)(null);
   const [runtimeAuthToken, setRuntimeAuthToken] = (0, _react.useState)(null);
+  // Caches the resolved runtime token keyed by the agent it belongs to. The
+  // runtimeAuthToken state lags an agent switch (it's cleared in a later effect),
+  // so resolveRuntimeToken must not trust it as a cache — this ref can never hand
+  // back a different agent's token.
+  const runtimeTokenRef = (0, _react.useRef)(null);
   const [realtimeClient, setRealtimeClient] = (0, _react.useState)();
   const [secrets, setSecrets] = (0, _react.useState)([]);
   const connectorFlowRef = (0, _react.useRef)(null);
@@ -82,31 +92,37 @@ function useSuperagentRuntime({
     setIsLoadingConnectors(true);
     try {
       const connectors = await superagentService.listConnectors(agentId);
+      if (activeAgentIdRef.current !== agentId) return;
       setAvailableConnectors(connectors.availableConnectors);
       setConnectedConnectors(connectors.connectedConnectors);
     } catch {
+      if (activeAgentIdRef.current !== agentId) return;
       setAvailableConnectors([]);
       setConnectedConnectors([]);
     } finally {
-      setIsLoadingConnectors(false);
+      if (activeAgentIdRef.current === agentId) setIsLoadingConnectors(false);
     }
   }, [superagentService]);
   const loadAutomations = (0, _react.useCallback)(async agentId => {
     setIsLoadingAutomations(true);
     try {
       const loadedAutomations = await superagentService.listAutomations(agentId);
+      if (activeAgentIdRef.current !== agentId) return;
       setAutomations(loadedAutomations);
     } catch {
+      if (activeAgentIdRef.current !== agentId) return;
       setAutomations([]);
     } finally {
-      setIsLoadingAutomations(false);
+      if (activeAgentIdRef.current === agentId) setIsLoadingAutomations(false);
     }
   }, [superagentService]);
   const loadAutomationCredits = (0, _react.useCallback)(async agentId => {
     try {
       const loadedCredits = await superagentService.listAutomationCredits(agentId);
+      if (activeAgentIdRef.current !== agentId) return;
       setAutomationCredits(loadedCredits);
     } catch {
+      if (activeAgentIdRef.current !== agentId) return;
       setAutomationCredits({});
     }
   }, [superagentService]);
@@ -114,55 +130,74 @@ function useSuperagentRuntime({
     setIsLoadingFiles(true);
     try {
       const loadedFilePaths = await superagentService.listSandboxFiles(agentId);
+      if (activeAgentIdRef.current !== agentId) return;
       const normalizedFilePaths = (0, _fileTreeUtils.normalizeFilePaths)(loadedFilePaths);
       setFilePaths(normalizedFilePaths.length > 0 ? normalizedFilePaths : _fileTreeUtils.DEFAULT_SANDBOX_FILE_PATHS);
       setFileLoadError(null);
       setFileLoadFailed(false);
     } catch (error) {
+      if (activeAgentIdRef.current !== agentId) return;
       setFilePaths(_fileTreeUtils.DEFAULT_SANDBOX_FILE_PATHS);
       setFileLoadError(getErrorMessage(error));
       setFileLoadFailed(true);
     } finally {
-      setIsLoadingFiles(false);
+      if (activeAgentIdRef.current === agentId) setIsLoadingFiles(false);
     }
   }, [superagentService]);
   const loadAgentSettings = (0, _react.useCallback)(async agentId => {
     setIsLoadingAgentSettings(true);
     try {
       const loadedSecrets = await superagentService.listSecrets(agentId);
+      if (activeAgentIdRef.current !== agentId) return;
       setSecrets(loadedSecrets);
     } catch {
+      if (activeAgentIdRef.current !== agentId) return;
       setSecrets([]);
     } finally {
-      setIsLoadingAgentSettings(false);
+      if (activeAgentIdRef.current === agentId) setIsLoadingAgentSettings(false);
     }
   }, [superagentService]);
   const loadCollaborators = (0, _react.useCallback)(async agentId => {
     setIsLoadingCollaborators(true);
     try {
       const loadedCollaborators = await superagentService.listCollaborators(agentId);
+      if (activeAgentIdRef.current !== agentId) return;
       setCollaborators(loadedCollaborators);
     } catch {
+      if (activeAgentIdRef.current !== agentId) return;
       setCollaborators([]);
     } finally {
-      setIsLoadingCollaborators(false);
+      if (activeAgentIdRef.current === agentId) setIsLoadingCollaborators(false);
     }
   }, [superagentService]);
   const resolveRuntimeToken = (0, _react.useCallback)(async agentId => {
-    if (agentId === activeAgentId && runtimeAuthToken) {
-      return runtimeAuthToken;
+    // Use the agent-keyed ref, not the runtimeAuthToken state: the state still
+    // holds the previous agent's token during a switch (it's cleared in a later
+    // effect), so trusting it could return the wrong agent's token here.
+    const cached = runtimeTokenRef.current;
+    if (cached && cached.agentId === agentId) {
+      return cached.token;
     }
     const token = await superagentService.getRuntimeAuthToken(agentId);
-    if (agentId === activeAgentId) {
+    runtimeTokenRef.current = {
+      agentId,
+      token
+    };
+    // Compare against the latest active agent (ref), not the closure-captured
+    // activeAgentId: the user may have switched agents while the fetch was in
+    // flight, and writing a stale agent's token into shared state would point
+    // realtime/channel calls at the wrong agent.
+    if (agentId === activeAgentIdRef.current) {
       setRuntimeAuthToken(token);
     }
     return token;
-  }, [activeAgentId, runtimeAuthToken, superagentService]);
+  }, [superagentService]);
   const loadChannels = (0, _react.useCallback)(async agentId => {
     setIsLoadingChannels(true);
     try {
       const token = await resolveRuntimeToken(agentId);
       const status = await superagentService.getChannelStatus(agentId, token);
+      if (activeAgentIdRef.current !== agentId) return;
       setChannelStatus(current => ({
         ...status,
         imessage: {
@@ -175,25 +210,33 @@ function useSuperagentRuntime({
         }
       }));
     } catch {
+      if (activeAgentIdRef.current !== agentId) return;
       setChannelStatus({});
     } finally {
-      setIsLoadingChannels(false);
+      if (activeAgentIdRef.current === agentId) setIsLoadingChannels(false);
     }
   }, [resolveRuntimeToken, superagentService]);
   const refreshAutomations = (0, _react.useCallback)(async agentId => {
     await Promise.all([loadAutomations(agentId), loadAutomationCredits(agentId)]);
   }, [loadAutomationCredits, loadAutomations]);
   (0, _react.useEffect)(() => {
+    // Reset per-agent state on every active-agent change (not just when it goes
+    // null) so the drawer never shows the previous agent's secrets/connectors/
+    // files/collaborators/automations during the new agent's load window — which
+    // could otherwise let a destructive action target the wrong agent.
+    setAvailableConnectors([]);
+    setAutomationCredits({});
+    setAutomations([]);
+    setChannelStatus({});
+    setCollaborators([]);
+    setConnectingChannelId(null);
+    setConnectingConnectorId(null);
+    setConnectedConnectors([]);
+    setFilePaths([]);
+    setFileLoadError(null);
+    setFileLoadFailed(false);
+    setSecrets([]);
     if (!activeAgentId) {
-      setAvailableConnectors([]);
-      setAutomationCredits({});
-      setAutomations([]);
-      setChannelStatus({});
-      setCollaborators([]);
-      setConnectingChannelId(null);
-      setConnectedConnectors([]);
-      setFilePaths([]);
-      setSecrets([]);
       return;
     }
     loadAgentSettings(activeAgentId);
@@ -231,23 +274,17 @@ function useSuperagentRuntime({
     if (!flow || flow.cancelled) {
       return;
     }
-    if (event.status === 'success') {
-      flow.cancelled = true;
-      connectorFlowRef.current = null;
-      setConnectingConnectorId(null);
-      await loadConnectors(flow.agentId);
-      return;
-    }
-    if (event.status === 'error') {
-      flow.cancelled = true;
-      connectorFlowRef.current = null;
-      setConnectingConnectorId(null);
+
+    // The callback event carries no connection/connector identifier, so it can't
+    // be reliably attributed to this flow — a late callback from a superseded
+    // connect could otherwise mark the wrong flow. Don't mutate flow state here;
+    // waitForConnectorAuthorization polls the authoritative per-connection status
+    // (it detects ACTIVE/FAILED on its own). Just refresh the connector list so
+    // the UI reflects the latest state.
+    if (event.status === 'success' || event.status === 'error') {
       await loadConnectors(flow.agentId);
-      showAlert(nativeAdapters, 'Connector failed', 'OAuth authorization did not complete. Please try connecting again.');
-      return;
     }
-    await loadConnectors(flow.agentId);
-  }, [loadConnectors, nativeAdapters]);
+  }, [loadConnectors]);
   (0, _react.useEffect)(() => {
     return nativeAdapters.subscribeToExternalAuthCallbacks?.(completePendingConnectorFromCallback);
   }, [completePendingConnectorFromCallback, nativeAdapters]);
@@ -374,6 +411,9 @@ function useSuperagentRuntime({
       } : agent));
     } catch (error) {
       showAlert(nativeAdapters, 'Permissions update failed', getErrorMessage(error));
+      // Rethrow so optimistic callers (the permission toggle) can revert; the
+      // guard-config caller wraps this in try/catch since the alert already fired.
+      throw error;
     }
   }, [nativeAdapters, superagentService]);
   const onSaveSecret = (0, _react.useCallback)(async ({
@@ -386,6 +426,9 @@ function useSuperagentRuntime({
       await loadAgentSettings(agentId);
     } catch (error) {
       showAlert(nativeAdapters, 'Secret save failed', getErrorMessage(error));
+      // Rethrow so the form keeps the user's input instead of clearing on a
+      // failed save.
+      throw error;
     }
   }, [loadAgentSettings, nativeAdapters, superagentService]);
   const onDeleteSecret = (0, _react.useCallback)(async ({
@@ -448,7 +491,10 @@ function useSuperagentRuntime({
   const onCloneAgent = (0, _react.useCallback)(({
     agentId
   }) => {
-    nativeAdapters.openWebUrl?.(buildWebUrl(config.webUrl ?? config.baseUrl, `/remix-app/${encodeURIComponent(agentId)}?clone_history=true`));
+    // Use the Superagent clone route — /remix-app is an app route that the web
+    // builder redirects back to /superagent/:id for user_agent apps (reopening the
+    // original instead of cloning). /clone-superagent/:id is the agent clone flow.
+    nativeAdapters.openWebUrl?.(buildWebUrl(config.webUrl ?? config.baseUrl, `/clone-superagent/${encodeURIComponent(agentId)}`));
   }, [config.baseUrl, config.webUrl, nativeAdapters]);
   const onDeleteAgent = (0, _react.useCallback)(async ({
     agentId
@@ -571,7 +617,7 @@ function useSuperagentRuntime({
     agentId,
     path
   }) => {
-    return superagentService.readSandboxFile(agentId, path);
+    return superagentService.readSandboxFile(agentId, (0, _fileTreeUtils.sanitizeSandboxFilePath)(path));
   }, [superagentService]);
   const onSaveSandboxFile = (0, _react.useCallback)(async ({
     agentId,
@@ -579,7 +625,7 @@ function useSuperagentRuntime({
     path
   }) => {
     try {
-      await superagentService.writeSandboxFile(agentId, path, content);
+      await superagentService.writeSandboxFile(agentId, (0, _fileTreeUtils.sanitizeSandboxFilePath)(path), content);
       await loadFiles(agentId);
     } catch (error) {
       showAlert(nativeAdapters, 'Save failed', getErrorMessage(error));
@@ -594,12 +640,18 @@ function useSuperagentRuntime({
       if (!files?.length) {
         return [];
       }
+      const writtenPaths = [];
       for (const file of files) {
-        await superagentService.writeSandboxFile(agentId, file.name, file.content);
+        const safeName = (0, _fileTreeUtils.sanitizeSandboxFilePath)(file.name) || 'upload';
+        // Stage uploads under a dedicated folder so a picked file named like a
+        // generated-app file (package.json, README.md, ...) can't overwrite it.
+        const safePath = `incoming_files/${safeName}`;
+        await superagentService.writeSandboxFile(agentId, safePath, file.content);
+        writtenPaths.push(safePath);
       }
       await loadFiles(agentId);
-      return files.map(file => ({
-        path: file.name
+      return writtenPaths.map(path => ({
+        path
       }));
     } catch (error) {
       if (nativeAdapters.isAttachmentPickerCancel?.(error)) {
@@ -629,19 +681,31 @@ function useSuperagentRuntime({
     setConnectingChannelId('whatsapp');
     try {
       const token = await resolveRuntimeToken(agentId);
+      // Editor gate: the connect redirect only authenticates the app-user token and
+      // does not re-check live editor access, so a downgraded viewer could otherwise
+      // open it. /whatsapp/status enforces the two-layer editor check and throws
+      // (403) for viewers — require it to pass before opening the setup page.
+      await superagentService.getWhatsAppStatus(agentId, token);
       const connectUrl = superagentService.getWhatsAppConnectUrl(agentId, token);
-      setChannelStatus(current => ({
-        ...current,
-        whatsapp: {
-          ...current.whatsapp,
-          connectUrl
-        }
-      }));
-      await nativeAdapters.openUrl?.(connectUrl);
+      if (activeAgentIdRef.current === agentId) {
+        setChannelStatus(current => ({
+          ...current,
+          whatsapp: {
+            ...current.whatsapp,
+            connectUrl
+          }
+        }));
+      }
+      if (!nativeAdapters.openUrl) {
+        // Without a URL opener the setup page never launches; surface an error
+        // instead of completing silently (mirrors the connector OAuth flow).
+        throw new Error('This app cannot open the WhatsApp setup page. Connect WhatsApp from the web app.');
+      }
+      await nativeAdapters.openUrl(connectUrl);
     } catch (error) {
       showAlert(nativeAdapters, 'WhatsApp setup failed', getErrorMessage(error));
     } finally {
-      setConnectingChannelId(null);
+      if (activeAgentIdRef.current === agentId) setConnectingChannelId(null);
     }
   }, [nativeAdapters, resolveRuntimeToken, superagentService]);
   const onSetupTelegram = (0, _react.useCallback)(async ({
@@ -652,12 +716,14 @@ function useSuperagentRuntime({
     try {
       const runtimeToken = await resolveRuntimeToken(agentId);
       const telegram = await superagentService.setupTelegram(agentId, runtimeToken, token);
-      setChannelStatus(current => ({
-        ...current,
-        telegram
-      }));
+      if (activeAgentIdRef.current === agentId) {
+        setChannelStatus(current => ({
+          ...current,
+          telegram
+        }));
+      }
     } finally {
-      setConnectingChannelId(null);
+      if (activeAgentIdRef.current === agentId) setConnectingChannelId(null);
     }
   }, [resolveRuntimeToken, superagentService]);
   const onDisconnectTelegram = (0, _react.useCallback)(async ({
@@ -676,16 +742,18 @@ function useSuperagentRuntime({
     try {
       const token = await resolveRuntimeToken(agentId);
       await superagentService.disconnectTelegram(agentId, token);
-      setChannelStatus(current => ({
-        ...current,
-        telegram: {
-          connected: false
-        }
-      }));
+      if (activeAgentIdRef.current === agentId) {
+        setChannelStatus(current => ({
+          ...current,
+          telegram: {
+            connected: false
+          }
+        }));
+      }
     } catch (error) {
       showAlert(nativeAdapters, 'Telegram disconnect failed', getErrorMessage(error));
     } finally {
-      setConnectingChannelId(null);
+      if (activeAgentIdRef.current === agentId) setConnectingChannelId(null);
     }
   }, [nativeAdapters, resolveRuntimeToken, superagentService]);
   const onGenerateLineCode = (0, _react.useCallback)(async ({
@@ -695,18 +763,20 @@ function useSuperagentRuntime({
     try {
       const token = await resolveRuntimeToken(agentId);
       const activation = await superagentService.generateLineCode(agentId, token);
-      setChannelStatus(current => ({
-        ...current,
-        line: {
-          ...current.line,
-          activation,
-          connected: false
-        }
-      }));
+      if (activeAgentIdRef.current === agentId) {
+        setChannelStatus(current => ({
+          ...current,
+          line: {
+            ...current.line,
+            activation,
+            connected: false
+          }
+        }));
+      }
     } catch (error) {
       showAlert(nativeAdapters, 'LINE setup failed', getErrorMessage(error));
     } finally {
-      setConnectingChannelId(null);
+      if (activeAgentIdRef.current === agentId) setConnectingChannelId(null);
     }
   }, [nativeAdapters, resolveRuntimeToken, superagentService]);
   const onGenerateIMessageCode = (0, _react.useCallback)(async ({
@@ -716,20 +786,22 @@ function useSuperagentRuntime({
     try {
       const token = await resolveRuntimeToken(agentId);
       const activation = await superagentService.generateIMessageCode(agentId, token);
-      setChannelStatus(current => ({
-        ...current,
-        imessage: {
-          ...current.imessage,
-          activation,
-          connected: current.imessage?.connected ?? false
-        }
-      }));
+      if (activeAgentIdRef.current === agentId) {
+        setChannelStatus(current => ({
+          ...current,
+          imessage: {
+            ...current.imessage,
+            activation,
+            connected: current.imessage?.connected ?? false
+          }
+        }));
+      }
       return activation;
     } catch (error) {
       showAlert(nativeAdapters, 'iMessage setup failed', getErrorMessage(error));
       throw error;
     } finally {
-      setConnectingChannelId(null);
+      if (activeAgentIdRef.current === agentId) setConnectingChannelId(null);
     }
   }, [nativeAdapters, resolveRuntimeToken, superagentService]);
   const onDisconnectIMessage = (0, _react.useCallback)(async ({
@@ -748,14 +820,16 @@ function useSuperagentRuntime({
     try {
       const token = await resolveRuntimeToken(agentId);
       const imessage = await superagentService.disconnectIMessage(agentId, token);
-      setChannelStatus(current => ({
-        ...current,
-        imessage
-      }));
+      if (activeAgentIdRef.current === agentId) {
+        setChannelStatus(current => ({
+          ...current,
+          imessage
+        }));
+      }
     } catch (error) {
       showAlert(nativeAdapters, 'iMessage disconnect failed', getErrorMessage(error));
     } finally {
-      setConnectingChannelId(null);
+      if (activeAgentIdRef.current === agentId) setConnectingChannelId(null);
     }
   }, [nativeAdapters, resolveRuntimeToken, superagentService]);
   const onOpenIMessage = (0, _react.useCallback)(async ({
@@ -763,7 +837,10 @@ function useSuperagentRuntime({
     phoneNumber
   }) => {
     try {
-      await nativeAdapters.openUrl?.(buildIMessageUrl(phoneNumber, code));
+      if (!nativeAdapters.openUrl) {
+        throw new Error('This app cannot open Messages. Use the web app to share the iMessage code.');
+      }
+      await nativeAdapters.openUrl(buildIMessageUrl(phoneNumber, code));
     } catch (error) {
       showAlert(nativeAdapters, 'iMessage link unavailable', getErrorMessage(error));
     }
@@ -782,7 +859,11 @@ function useSuperagentRuntime({
     addFriendUrl,
     code
   }) => {
-    await nativeAdapters.share?.({
+    if (!nativeAdapters.share) {
+      showAlert(nativeAdapters, 'Sharing unavailable', 'This app cannot share the activation code. Copy it manually instead.');
+      return;
+    }
+    await nativeAdapters.share({
       message: `LINE activation code: ${code}\n${addFriendUrl}`,
       title: 'LINE activation code',
       url: addFriendUrl
@@ -792,7 +873,11 @@ function useSuperagentRuntime({
     code,
     phoneNumber
   }) => {
-    await nativeAdapters.share?.({
+    if (!nativeAdapters.share) {
+      showAlert(nativeAdapters, 'Sharing unavailable', 'This app cannot share the activation code. Copy it manually instead.');
+      return;
+    }
+    await nativeAdapters.share({
       message: `Text ${code} to ${phoneNumber} to connect this Superagent on iMessage.`,
       title: 'iMessage activation code',
       url: buildIMessageUrl(phoneNumber, code)
@@ -828,22 +913,35 @@ function useSuperagentRuntime({
         connectorFlowRef.current = null;
         setConnectingConnectorId(null);
         await loadConnectors(agentId);
-        return true;
+        // Return the connection_id (string) so the connector tool-approval can
+        // submit it; fall back to `true` when the backend omits it.
+        return connection.connection_id ?? true;
       }
       if (!connection.redirect_url || !connection.connection_id) {
         throw new Error('The backend did not return an authorization URL for this connector.');
       }
-      await nativeAdapters.openUrl?.(connection.redirect_url);
-      await waitForConnectorAuthorization(superagentService, agentId, connectorId, connection.connection_id, flow);
-      if (!flow.cancelled) {
+      if (!nativeAdapters.openUrl) {
+        // Without a URL opener the browser never launches, so polling would just
+        // time out after ~2 minutes. Fail immediately with an actionable error.
+        throw new Error('This app cannot open the authorization page. Connect this integration from the web app.');
+      }
+      await nativeAdapters.openUrl(connection.redirect_url);
+      const connected = await waitForConnectorAuthorization(superagentService, agentId, connectorId, connection.connection_id, flow);
+
+      // Only clear shared state if this flow is still the active one — a newer
+      // connect may have superseded it (and owns connectorFlowRef now).
+      if (connectorFlowRef.current === flow) {
         connectorFlowRef.current = null;
         setConnectingConnectorId(null);
+      }
+      if (connected) {
         await loadConnectors(agentId);
-        return true;
       }
-      return false;
+      // On success return the connection_id so the connector tool-approval can
+      // submit it for backend verification; `false` on failure.
+      return connected ? connection.connection_id : false;
     } catch (error) {
-      if (!flow.cancelled) {
+      if (connectorFlowRef.current === flow) {
         connectorFlowRef.current = null;
         setConnectingConnectorId(null);
         showAlert(nativeAdapters, 'Connector failed', getErrorMessage(error));
@@ -905,6 +1003,7 @@ function useSuperagentRuntime({
     }
   }, [loadConnectors, nativeAdapters, superagentService]);
   return {
+    activeAgentId,
     agents,
     apiClient,
     availableConnectors,
@@ -916,7 +1015,12 @@ function useSuperagentRuntime({
     connectingConnectorId,
     connectedConnectors,
     currentRoute,
+    // Also expose as initialRoute, the prop SuperagentHomeScreen actually consumes,
+    // so spreading the runtime opens on the deep-linked agent (initialAgentId)
+    // instead of defaulting to the home route.
+    initialRoute: currentRoute,
     currentUserAvatarUrl: config.currentUserAvatarUrl,
+    currentUserId: config.currentUserId,
     currentUserName: config.currentUserName,
     fileLoadError,
     fileLoadFailed,
@@ -969,7 +1073,10 @@ function useSuperagentRuntime({
     onShareAgentLink,
     onShareIMessageCode,
     onShareLineCode,
-    onStartLiveVoice,
+    // Only expose Live Voice when the native audio adapter is actually installed;
+    // otherwise the composer would prefer it and fail on tap ("audio callbacks are
+    // not installed") instead of falling back to onStartVoiceInput.
+    onStartLiveVoice: nativeAdapters.liveVoiceAudio?.startAudioCapture ? onStartLiveVoice : undefined,
     onSetupTelegram,
     onToggleAutomation,
     onUpdateAgentModel,
@@ -980,22 +1087,27 @@ function useSuperagentRuntime({
   };
 }
 async function waitForConnectorAuthorization(superagentService, agentId, connectorId, connectionId, flow) {
+  // The connection status (scoped to this flow's connectionId) is the
+  // authoritative source of truth — not a global callback flag, which can't be
+  // attributed to a specific flow. Returns whether the connector ended up ACTIVE.
+  const isActive = async () => (await superagentService.getConnectorConnectionStatus(agentId, connectorId, connectionId)) === 'ACTIVE';
   const maxAttempts = 40;
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
     if (flow.cancelled) {
-      return;
+      // Cancelled — but OAuth may have already completed; confirm with the
+      // authoritative status before reporting not-connected.
+      return isActive().catch(() => false);
     }
     await delay(3000);
-    if (flow.cancelled) {
-      return;
-    }
     const status = await superagentService.getConnectorConnectionStatus(agentId, connectorId, connectionId);
     if (status === 'ACTIVE') {
-      return;
+      return true;
     }
     if (status === 'FAILED') {
       throw new Error('OAuth connection failed.');
     }
+    // If the user cancelled during the delay, the next iteration's top-of-loop
+    // check re-confirms via the authoritative status before returning.
   }
   throw new Error('Connection timed out after 2 minutes.');
 }
@@ -1004,20 +1116,48 @@ async function openAllowedExternalUrl(nativeAdapters, url, allowedHosts, fallbac
     showAlert(nativeAdapters, fallbackMessage, 'The backend returned a channel link that cannot be opened safely.');
     return;
   }
+  if (!nativeAdapters.openUrl) {
+    // No URL opener: surface it instead of passing the host check and then
+    // silently doing nothing.
+    showAlert(nativeAdapters, fallbackMessage, 'This app cannot open external links. Use the web app instead.');
+    return;
+  }
   try {
-    await nativeAdapters.openUrl?.(url);
+    await nativeAdapters.openUrl(url);
   } catch (error) {
     showAlert(nativeAdapters, fallbackMessage, getErrorMessage(error));
   }
 }
 function showAlert(nativeAdapters, title, message) {
-  nativeAdapters.alert?.(title, message);
+  if (nativeAdapters.alert) {
+    nativeAdapters.alert(title, message);
+    return;
+  }
+  // No host alert adapter — fall back to React Native's Alert (as confirmAction
+  // does) so connector/channel/file/model errors aren't silently swallowed.
+  _reactNative.Alert.alert(title, message);
 }
 async function confirmAction(nativeAdapters, input) {
-  if (!nativeAdapters.confirm) {
-    return true;
+  if (nativeAdapters.confirm) {
+    return nativeAdapters.confirm(input);
   }
-  return nativeAdapters.confirm(input);
+
+  // No host confirm adapter — fall back to a native prompt so destructive actions
+  // still require explicit confirmation instead of silently proceeding.
+  return new Promise(resolve => {
+    _reactNative.Alert.alert(input.title, input.message, [{
+      onPress: () => resolve(false),
+      style: 'cancel',
+      text: 'Cancel'
+    }, {
+      onPress: () => resolve(true),
+      style: input.destructive ? 'destructive' : 'default',
+      text: input.confirmText ?? 'Confirm'
+    }], {
+      cancelable: true,
+      onDismiss: () => resolve(false)
+    });
+  });
 }
 function buildWebUrl(baseUrl, path) {
   return `${normalizeBaseUrl(baseUrl)}${path.startsWith('/') ? path : `/${path}`}`;