@base44/superagent-native 0.0.1 → 0.0.3

package/src/useSuperagentRuntime.ts

@@ -1,6 +1,7 @@
 import {useCallback, useEffect, useMemo, useRef, useState} from 'react';
+import { Alert } from 'react-native';
 import { createSuperagentNativeClient } from './apiClient';
-import { DEFAULT_SANDBOX_FILE_PATHS, normalizeFilePaths } from './fileTreeUtils';
+import { DEFAULT_SANDBOX_FILE_PATHS, normalizeFilePaths, sanitizeSandboxFilePath } from './fileTreeUtils';
 import {
   createSuperagentSocketClient,
   type SuperagentSocketLike,
@@ -146,6 +147,10 @@ export function useSuperagentRuntime({
   }), [config.baseUrl, config.currentUserId, config.getAccessToken, config.getHeaders]);
   const [agents, setAgents] = useState<SuperagentAgent[]>([]);
   const [activeAgentId, setActiveAgentId] = useState<string | null>(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 = useRef(activeAgentId);
+  activeAgentIdRef.current = activeAgentId;
   const [currentRoute, setCurrentRoute] = useState<SuperagentRoute>(
     initialAgentId ? {name: 'agent', agentId: initialAgentId} : {name: 'home'},
   );
@@ -169,6 +174,11 @@ export function useSuperagentRuntime({
   const [isLoading, setIsLoading] = useState(true);
   const [loadError, setLoadError] = useState<string | null>(null);
   const [runtimeAuthToken, setRuntimeAuthToken] = useState<string | null>(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 = useRef<{ agentId: string; token: string } | null>(null);
   const [realtimeClient, setRealtimeClient] = useState<SuperagentRealtimeClient | undefined>();
   const [secrets, setSecrets] = useState<SuperagentSecret[]>([]);
   const connectorFlowRef = useRef<ConnectorFlow | null>(null);
@@ -209,13 +219,15 @@ export 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]);
 
@@ -223,19 +235,23 @@ export function useSuperagentRuntime({
     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 = useCallback(async (agentId: string) => {
     try {
       const loadedCredits = await superagentService.listAutomationCredits(agentId);
+      if (activeAgentIdRef.current !== agentId) return;
       setAutomationCredits(loadedCredits);
     } catch {
+      if (activeAgentIdRef.current !== agentId) return;
       setAutomationCredits({});
     }
   }, [superagentService]);
@@ -244,16 +260,18 @@ export function useSuperagentRuntime({
     setIsLoadingFiles(true);
     try {
       const loadedFilePaths = await superagentService.listSandboxFiles(agentId);
+      if (activeAgentIdRef.current !== agentId) return;
       const normalizedFilePaths = normalizeFilePaths(loadedFilePaths);
       setFilePaths(normalizedFilePaths.length > 0 ? normalizedFilePaths : DEFAULT_SANDBOX_FILE_PATHS);
       setFileLoadError(null);
       setFileLoadFailed(false);
     } catch (error) {
+      if (activeAgentIdRef.current !== agentId) return;
       setFilePaths(DEFAULT_SANDBOX_FILE_PATHS);
       setFileLoadError(getErrorMessage(error));
       setFileLoadFailed(true);
     } finally {
-      setIsLoadingFiles(false);
+      if (activeAgentIdRef.current === agentId) setIsLoadingFiles(false);
     }
   }, [superagentService]);
 
@@ -261,11 +279,13 @@ export function useSuperagentRuntime({
     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]);
 
@@ -273,31 +293,43 @@ export function useSuperagentRuntime({
     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 = useCallback(async (agentId: string) => {
-    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 = useCallback(async (agentId: string) => {
     setIsLoadingChannels(true);
     try {
       const token = await resolveRuntimeToken(agentId);
       const status = await superagentService.getChannelStatus(agentId, token);
+      if (activeAgentIdRef.current !== agentId) return;
       setChannelStatus((current) => ({
         ...status,
         imessage: {
@@ -310,9 +342,10 @@ export function useSuperagentRuntime({
         },
       }));
     } catch {
+      if (activeAgentIdRef.current !== agentId) return;
       setChannelStatus({});
     } finally {
-      setIsLoadingChannels(false);
+      if (activeAgentIdRef.current === agentId) setIsLoadingChannels(false);
     }
   }, [resolveRuntimeToken, superagentService]);
 
@@ -324,16 +357,24 @@ export function useSuperagentRuntime({
   }, [loadAutomationCredits, loadAutomations]);
 
   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;
     }
 
@@ -380,25 +421,16 @@ export function useSuperagentRuntime({
       return;
     }
 
-    if (event.status === 'success') {
-      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);
-      return;
-    }
-
-    if (event.status === 'error') {
-      flow.cancelled = true;
-      connectorFlowRef.current = null;
-      setConnectingConnectorId(null);
-      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]);
 
   useEffect(() => {
     return nativeAdapters.subscribeToExternalAuthCallbacks?.(completePendingConnectorFromCallback);
@@ -536,6 +568,9 @@ export function useSuperagentRuntime({
       )));
     } 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]);
 
@@ -545,6 +580,9 @@ export 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]);
 
@@ -605,7 +643,10 @@ export function useSuperagentRuntime({
   }, [config.baseUrl, config.webUrl, nativeAdapters]);
 
   const onCloneAgent = useCallback(({agentId}: SuperagentAgentActionInput) => {
-    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 = useCallback(async ({agentId}: SuperagentAgentActionInput) => {
@@ -705,12 +746,12 @@ export function useSuperagentRuntime({
   }, [config.baseUrl, config.webUrl, nativeAdapters]);
 
   const onOpenSandboxFile = useCallback(async ({agentId, path}: SuperagentSandboxFileActionInput) => {
-    return superagentService.readSandboxFile(agentId, path);
+    return superagentService.readSandboxFile(agentId, sanitizeSandboxFilePath(path));
   }, [superagentService]);
 
   const onSaveSandboxFile = useCallback(async ({agentId, content, path}: SuperagentSandboxFileSaveInput) => {
     try {
-      await superagentService.writeSandboxFile(agentId, path, content);
+      await superagentService.writeSandboxFile(agentId, sanitizeSandboxFilePath(path), content);
       await loadFiles(agentId);
     } catch (error) {
       showAlert(nativeAdapters, 'Save failed', getErrorMessage(error));
@@ -725,11 +766,17 @@ export function useSuperagentRuntime({
         return [];
       }
 
+      const writtenPaths: string[] = [];
       for (const file of files) {
-        await superagentService.writeSandboxFile(agentId, file.name, file.content);
+        const safeName = 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)) {
         return [];
@@ -760,19 +807,31 @@ export 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]);
 
@@ -781,12 +840,14 @@ export 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]);
 
@@ -805,14 +866,16 @@ export 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]);
 
@@ -821,18 +884,20 @@ export 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]);
 
@@ -841,20 +906,22 @@ export 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]);
 
@@ -873,20 +940,25 @@ export 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 = useCallback(async ({code, phoneNumber}: SuperagentIMessageCodeShareInput) => {
     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));
     }
@@ -901,7 +973,11 @@ export function useSuperagentRuntime({
   }, [nativeAdapters]);
 
   const onShareLineCode = useCallback(async ({addFriendUrl, code}: SuperagentLineCodeShareInput) => {
-    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,
@@ -909,7 +985,11 @@ export function useSuperagentRuntime({
   }, [nativeAdapters]);
 
   const onShareIMessageCode = useCallback(async ({code, phoneNumber}: SuperagentIMessageCodeShareInput) => {
-    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),
@@ -944,26 +1024,38 @@ export 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 (!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);
 
-      if (!flow.cancelled) {
+      // 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));
@@ -1022,6 +1114,7 @@ export function useSuperagentRuntime({
   }, [loadConnectors, nativeAdapters, superagentService]);
 
   return {
+    activeAgentId,
     agents,
     apiClient,
     availableConnectors,
@@ -1033,7 +1126,12 @@ export 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,
@@ -1086,7 +1184,10 @@ export 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,
@@ -1103,25 +1204,32 @@ async function waitForConnectorAuthorization(
   connectorId: string,
   connectionId: string,
   flow: ConnectorFlow,
-) {
+): Promise<boolean> {
+  // 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.');
@@ -1138,26 +1246,55 @@ async function openAllowedExternalUrl(
     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: SuperagentNativeRuntimeAdapters, title: string, message?: string) {
-  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.
+  Alert.alert(title, message);
 }
 
 async function confirmAction(
   nativeAdapters: SuperagentNativeRuntimeAdapters,
   input: Parameters<NonNullable<SuperagentNativeRuntimeAdapters['confirm']>>[0],
 ) {
-  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<boolean>((resolve) => {
+    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: string, path: string) {