@base44/superagent-native 0.0.1

package/lib/module/useSuperagentRuntime.js

@@ -0,0 +1,1203 @@
+"use strict";
+
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { createSuperagentNativeClient } from "./apiClient.js";
+import { DEFAULT_SANDBOX_FILE_PATHS, normalizeFilePaths } from "./fileTreeUtils.js";
+import { createSuperagentSocketClient } from "./realtimeClient.js";
+import { createSuperagentApiClient } from "./superagentApiClient.js";
+export function useSuperagentRuntime({
+  config,
+  initialAgentId,
+  nativeAdapters = {}
+}) {
+  const superagentService = useMemo(() => createSuperagentApiClient({
+    baseUrl: config.baseUrl,
+    currentUserId: config.currentUserId,
+    getAccessToken: config.getAccessToken,
+    getHeaders: config.getHeaders
+  }), [config.baseUrl, config.currentUserId, config.getAccessToken, config.getHeaders]);
+  const [agents, setAgents] = useState([]);
+  const [activeAgentId, setActiveAgentId] = useState(initialAgentId ?? null);
+  const [currentRoute, setCurrentRoute] = useState(initialAgentId ? {
+    name: 'agent',
+    agentId: initialAgentId
+  } : {
+    name: 'home'
+  });
+  const [availableConnectors, setAvailableConnectors] = useState([]);
+  const [automationCredits, setAutomationCredits] = useState({});
+  const [automations, setAutomations] = useState([]);
+  const [channelStatus, setChannelStatus] = useState({});
+  const [connectingChannelId, setConnectingChannelId] = useState(null);
+  const [collaborators, setCollaborators] = useState([]);
+  const [connectedConnectors, setConnectedConnectors] = useState([]);
+  const [connectingConnectorId, setConnectingConnectorId] = useState(null);
+  const [filePaths, setFilePaths] = useState([]);
+  const [fileLoadError, setFileLoadError] = useState(null);
+  const [fileLoadFailed, setFileLoadFailed] = useState(false);
+  const [isLoadingAgentSettings, setIsLoadingAgentSettings] = useState(false);
+  const [isLoadingChannels, setIsLoadingChannels] = useState(false);
+  const [isLoadingCollaborators, setIsLoadingCollaborators] = useState(false);
+  const [isLoadingFiles, setIsLoadingFiles] = useState(false);
+  const [isLoadingAutomations, setIsLoadingAutomations] = useState(false);
+  const [isLoadingConnectors, setIsLoadingConnectors] = useState(false);
+  const [isLoading, setIsLoading] = useState(true);
+  const [loadError, setLoadError] = useState(null);
+  const [runtimeAuthToken, setRuntimeAuthToken] = useState(null);
+  const [realtimeClient, setRealtimeClient] = useState();
+  const [secrets, setSecrets] = useState([]);
+  const connectorFlowRef = useRef(null);
+  useEffect(() => {
+    let cancelled = false;
+    async function loadAgents() {
+      setIsLoading(true);
+      setLoadError(null);
+      try {
+        const loadedAgents = await superagentService.listAgents();
+        if (cancelled) {
+          return;
+        }
+        setAgents(loadedAgents);
+        setActiveAgentId(current => current ?? initialAgentId ?? loadedAgents[0]?.id ?? null);
+      } catch (error) {
+        if (!cancelled) {
+          setLoadError(getErrorMessage(error));
+        }
+      } finally {
+        if (!cancelled) {
+          setIsLoading(false);
+        }
+      }
+    }
+    loadAgents();
+    return () => {
+      cancelled = true;
+    };
+  }, [initialAgentId, superagentService]);
+  const loadConnectors = useCallback(async agentId => {
+    setIsLoadingConnectors(true);
+    try {
+      const connectors = await superagentService.listConnectors(agentId);
+      setAvailableConnectors(connectors.availableConnectors);
+      setConnectedConnectors(connectors.connectedConnectors);
+    } catch {
+      setAvailableConnectors([]);
+      setConnectedConnectors([]);
+    } finally {
+      setIsLoadingConnectors(false);
+    }
+  }, [superagentService]);
+  const loadAutomations = useCallback(async agentId => {
+    setIsLoadingAutomations(true);
+    try {
+      const loadedAutomations = await superagentService.listAutomations(agentId);
+      setAutomations(loadedAutomations);
+    } catch {
+      setAutomations([]);
+    } finally {
+      setIsLoadingAutomations(false);
+    }
+  }, [superagentService]);
+  const loadAutomationCredits = useCallback(async agentId => {
+    try {
+      const loadedCredits = await superagentService.listAutomationCredits(agentId);
+      setAutomationCredits(loadedCredits);
+    } catch {
+      setAutomationCredits({});
+    }
+  }, [superagentService]);
+  const loadFiles = useCallback(async agentId => {
+    setIsLoadingFiles(true);
+    try {
+      const loadedFilePaths = await superagentService.listSandboxFiles(agentId);
+      const normalizedFilePaths = normalizeFilePaths(loadedFilePaths);
+      setFilePaths(normalizedFilePaths.length > 0 ? normalizedFilePaths : DEFAULT_SANDBOX_FILE_PATHS);
+      setFileLoadError(null);
+      setFileLoadFailed(false);
+    } catch (error) {
+      setFilePaths(DEFAULT_SANDBOX_FILE_PATHS);
+      setFileLoadError(getErrorMessage(error));
+      setFileLoadFailed(true);
+    } finally {
+      setIsLoadingFiles(false);
+    }
+  }, [superagentService]);
+  const loadAgentSettings = useCallback(async agentId => {
+    setIsLoadingAgentSettings(true);
+    try {
+      const loadedSecrets = await superagentService.listSecrets(agentId);
+      setSecrets(loadedSecrets);
+    } catch {
+      setSecrets([]);
+    } finally {
+      setIsLoadingAgentSettings(false);
+    }
+  }, [superagentService]);
+  const loadCollaborators = useCallback(async agentId => {
+    setIsLoadingCollaborators(true);
+    try {
+      const loadedCollaborators = await superagentService.listCollaborators(agentId);
+      setCollaborators(loadedCollaborators);
+    } catch {
+      setCollaborators([]);
+    } finally {
+      setIsLoadingCollaborators(false);
+    }
+  }, [superagentService]);
+  const resolveRuntimeToken = useCallback(async agentId => {
+    if (agentId === activeAgentId && runtimeAuthToken) {
+      return runtimeAuthToken;
+    }
+    const token = await superagentService.getRuntimeAuthToken(agentId);
+    if (agentId === activeAgentId) {
+      setRuntimeAuthToken(token);
+    }
+    return token;
+  }, [activeAgentId, runtimeAuthToken, superagentService]);
+  const loadChannels = useCallback(async agentId => {
+    setIsLoadingChannels(true);
+    try {
+      const token = await resolveRuntimeToken(agentId);
+      const status = await superagentService.getChannelStatus(agentId, token);
+      setChannelStatus(current => ({
+        ...status,
+        imessage: {
+          ...status.imessage,
+          activation: current.imessage?.activation ?? status.imessage?.activation
+        },
+        line: {
+          ...status.line,
+          activation: current.line?.activation ?? status.line?.activation
+        }
+      }));
+    } catch {
+      setChannelStatus({});
+    } finally {
+      setIsLoadingChannels(false);
+    }
+  }, [resolveRuntimeToken, superagentService]);
+  const refreshAutomations = useCallback(async agentId => {
+    await Promise.all([loadAutomations(agentId), loadAutomationCredits(agentId)]);
+  }, [loadAutomationCredits, loadAutomations]);
+  useEffect(() => {
+    if (!activeAgentId) {
+      setAvailableConnectors([]);
+      setAutomationCredits({});
+      setAutomations([]);
+      setChannelStatus({});
+      setCollaborators([]);
+      setConnectingChannelId(null);
+      setConnectedConnectors([]);
+      setFilePaths([]);
+      setSecrets([]);
+      return;
+    }
+    loadAgentSettings(activeAgentId);
+    loadCollaborators(activeAgentId);
+    loadConnectors(activeAgentId);
+    loadFiles(activeAgentId);
+    refreshAutomations(activeAgentId);
+  }, [activeAgentId, loadAgentSettings, loadCollaborators, loadConnectors, loadFiles, refreshAutomations]);
+  useEffect(() => {
+    if (!activeAgentId || !runtimeAuthToken) {
+      setChannelStatus({});
+      return;
+    }
+    loadChannels(activeAgentId);
+  }, [activeAgentId, loadChannels, runtimeAuthToken]);
+  const reloadPendingConnector = useCallback(() => {
+    const flow = connectorFlowRef.current;
+    if (!flow || flow.cancelled) {
+      return;
+    }
+    setTimeout(() => {
+      loadConnectors(flow.agentId);
+    }, 1200);
+  }, [loadConnectors]);
+  const reloadChannelsOnResume = useCallback(() => {
+    if (!activeAgentId) {
+      return;
+    }
+    setTimeout(() => {
+      loadChannels(activeAgentId);
+    }, 1200);
+  }, [activeAgentId, loadChannels]);
+  const completePendingConnectorFromCallback = useCallback(async event => {
+    const flow = connectorFlowRef.current;
+    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);
+      await loadConnectors(flow.agentId);
+      showAlert(nativeAdapters, 'Connector failed', 'OAuth authorization did not complete. Please try connecting again.');
+      return;
+    }
+    await loadConnectors(flow.agentId);
+  }, [loadConnectors, nativeAdapters]);
+  useEffect(() => {
+    return nativeAdapters.subscribeToExternalAuthCallbacks?.(completePendingConnectorFromCallback);
+  }, [completePendingConnectorFromCallback, nativeAdapters]);
+  useEffect(() => {
+    const unsubscribeResume = nativeAdapters.subscribeToAppResume?.(() => {
+      reloadPendingConnector();
+      reloadChannelsOnResume();
+    });
+    const unsubscribeDeepLinks = nativeAdapters.subscribeToDeepLinks?.(url => {
+      if (nativeAdapters.isExternalAuthCallbackUrl?.(url)) {
+        nativeAdapters.completeExternalAuthCallback?.(url);
+        reloadPendingConnector();
+      }
+    });
+    return () => {
+      unsubscribeResume?.();
+      unsubscribeDeepLinks?.();
+    };
+  }, [nativeAdapters, reloadChannelsOnResume, reloadPendingConnector]);
+  useEffect(() => {
+    return () => {
+      if (connectorFlowRef.current) {
+        connectorFlowRef.current.cancelled = true;
+      }
+    };
+  }, []);
+  const apiClient = useMemo(() => {
+    if (!activeAgentId) {
+      return undefined;
+    }
+    return createSuperagentNativeClient({
+      apiBaseUrl: `${normalizeBaseUrl(config.baseUrl)}/api/apps`,
+      appId: activeAgentId,
+      getAuthToken: config.getAccessToken,
+      getHeaders: config.getHeaders
+    });
+  }, [activeAgentId, config.baseUrl, config.getAccessToken, config.getHeaders]);
+  useEffect(() => {
+    if (!activeAgentId) {
+      setRuntimeAuthToken(null);
+      return;
+    }
+    let cancelled = false;
+    setRuntimeAuthToken(null);
+    superagentService.getRuntimeAuthToken(activeAgentId).then(token => {
+      if (!cancelled) {
+        setRuntimeAuthToken(token);
+      }
+    }).catch(() => {
+      if (!cancelled) {
+        setRuntimeAuthToken(null);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [activeAgentId, superagentService]);
+  useEffect(() => {
+    if (!activeAgentId || !runtimeAuthToken) {
+      setRealtimeClient(undefined);
+      return;
+    }
+    const socket = nativeAdapters.createRealtimeSocket?.({
+      appId: activeAgentId,
+      baseUrl: config.baseUrl,
+      token: runtimeAuthToken
+    });
+    if (!socket) {
+      setRealtimeClient(undefined);
+      return;
+    }
+    setRealtimeClient(createSuperagentSocketClient({
+      socket
+    }));
+    return () => {
+      socket.disconnect?.();
+    };
+  }, [activeAgentId, config.baseUrl, nativeAdapters, runtimeAuthToken]);
+  const onCreateAgent = useCallback(async () => {
+    const createdAgent = await superagentService.createAgent();
+    setAgents(current => [createdAgent, ...current.filter(agent => agent.id !== createdAgent.id)]);
+    setActiveAgentId(createdAgent.id);
+    setLoadError(null);
+    return createdAgent;
+  }, [superagentService]);
+  const onOpenAgent = useCallback(agentId => {
+    setActiveAgentId(agentId);
+  }, [superagentService]);
+  const onRenameAgent = useCallback(async ({
+    agentId,
+    name
+  }) => {
+    const updatedAgent = await superagentService.renameAgent(agentId, name);
+    setAgents(current => current.map(agent => agent.id === agentId ? {
+      ...agent,
+      ...updatedAgent,
+      name: updatedAgent.name || name
+    } : agent));
+    return updatedAgent;
+  }, [superagentService]);
+  const onUpdateAgentModel = useCallback(async ({
+    agentId,
+    model
+  }) => {
+    try {
+      const updatedAgent = await superagentService.updateAgentModel(agentId, model);
+      setAgents(current => current.map(agent => agent.id === agentId ? {
+        ...agent,
+        ...updatedAgent
+      } : agent));
+    } catch (error) {
+      showAlert(nativeAdapters, 'Model update failed', getErrorMessage(error));
+    }
+  }, [nativeAdapters, superagentService]);
+  const onUpdateToolPermissions = useCallback(async ({
+    agentId,
+    config
+  }) => {
+    try {
+      const updatedAgent = await superagentService.updateToolPermissions(agentId, config);
+      setAgents(current => current.map(agent => agent.id === agentId ? {
+        ...agent,
+        ...updatedAgent
+      } : agent));
+    } catch (error) {
+      showAlert(nativeAdapters, 'Permissions update failed', getErrorMessage(error));
+    }
+  }, [nativeAdapters, superagentService]);
+  const onSaveSecret = useCallback(async ({
+    agentId,
+    name,
+    value
+  }) => {
+    try {
+      await superagentService.saveSecret(agentId, name, value);
+      await loadAgentSettings(agentId);
+    } catch (error) {
+      showAlert(nativeAdapters, 'Secret save failed', getErrorMessage(error));
+    }
+  }, [loadAgentSettings, nativeAdapters, superagentService]);
+  const onDeleteSecret = useCallback(async ({
+    agentId,
+    name
+  }) => {
+    const confirmed = await confirmAction(nativeAdapters, {
+      confirmText: 'Delete',
+      destructive: true,
+      message: `Delete "${name}" permanently?`,
+      title: 'Delete secret?'
+    });
+    if (!confirmed) {
+      return;
+    }
+    try {
+      await superagentService.deleteSecret(agentId, name);
+      await loadAgentSettings(agentId);
+    } catch (error) {
+      showAlert(nativeAdapters, 'Secret delete failed', getErrorMessage(error));
+    }
+  }, [loadAgentSettings, nativeAdapters, superagentService]);
+  const onShareAgent = useCallback(async ({
+    agentId,
+    addAsGuest,
+    emails
+  }) => {
+    const result = await superagentService.inviteCollaborators(agentId, emails, addAsGuest);
+    await loadCollaborators(agentId);
+    return result;
+  }, [loadCollaborators, superagentService]);
+  const onShareAgentLink = useCallback(async ({
+    agentId
+  }) => {
+    const agent = agents.find(item => item.id === agentId);
+    const url = buildWebUrl(config.webUrl ?? config.baseUrl, `/superagent/${encodeURIComponent(agentId)}`);
+    if (nativeAdapters.share) {
+      await nativeAdapters.share({
+        message: `Open ${agent?.name || 'this Superagent'} in Base44:\n${url}`,
+        title: agent?.name || 'Superagent',
+        url
+      });
+      return;
+    }
+    if (nativeAdapters.openWebUrl) {
+      await nativeAdapters.openWebUrl(url);
+      return;
+    }
+    showAlert(nativeAdapters, 'Share unavailable', url);
+  }, [agents, config.baseUrl, config.webUrl, nativeAdapters]);
+  const onOpenWorkspaceMembers = useCallback(({
+    organizationId
+  }) => {
+    if (!organizationId) {
+      showAlert(nativeAdapters, 'Workspace unavailable', 'Open workspace settings from the web to add this person as a workspace member.');
+      return;
+    }
+    nativeAdapters.openWebUrl?.(buildWebUrl(config.webUrl ?? config.baseUrl, `/workspace/${encodeURIComponent(organizationId)}/settings/seats-members`));
+  }, [config.baseUrl, config.webUrl, nativeAdapters]);
+  const onCloneAgent = useCallback(({
+    agentId
+  }) => {
+    nativeAdapters.openWebUrl?.(buildWebUrl(config.webUrl ?? config.baseUrl, `/remix-app/${encodeURIComponent(agentId)}?clone_history=true`));
+  }, [config.baseUrl, config.webUrl, nativeAdapters]);
+  const onDeleteAgent = useCallback(async ({
+    agentId
+  }) => {
+    const agent = agents.find(item => item.id === agentId);
+    const confirmed = await confirmAction(nativeAdapters, {
+      confirmText: 'Delete',
+      destructive: true,
+      message: `Delete "${agent?.name || 'this Superagent'}" permanently?`,
+      title: 'Delete Superagent?'
+    });
+    if (!confirmed) {
+      return;
+    }
+    try {
+      await superagentService.deleteAgent(agentId);
+      setAgents(current => current.filter(item => item.id !== agentId));
+      setSecrets([]);
+      setActiveAgentId(current => current === agentId ? null : current);
+      setCurrentRoute({
+        name: 'home'
+      });
+    } catch (error) {
+      showAlert(nativeAdapters, 'Delete failed', getErrorMessage(error));
+    }
+  }, [agents, nativeAdapters, superagentService]);
+  const onToggleAutomation = useCallback(async ({
+    agentId,
+    automation
+  }) => {
+    try {
+      const updatedAutomation = await superagentService.toggleAutomation(agentId, automation);
+      setAutomations(current => current.map(item => item.id === automation.id ? {
+        ...item,
+        ...updatedAutomation
+      } : item));
+      void loadAutomationCredits(agentId);
+    } catch (error) {
+      showAlert(nativeAdapters, 'Automation failed', getErrorMessage(error));
+    }
+  }, [loadAutomationCredits, nativeAdapters, superagentService]);
+  const onArchiveAutomation = useCallback(async ({
+    agentId,
+    automation
+  }) => {
+    try {
+      const updatedAutomation = await superagentService.archiveAutomation(agentId, automation);
+      setAutomations(current => current.map(item => item.id === automation.id ? {
+        ...item,
+        ...updatedAutomation,
+        is_active: false,
+        is_archived: true
+      } : item));
+      void loadAutomationCredits(agentId);
+    } catch (error) {
+      showAlert(nativeAdapters, 'Archive failed', getErrorMessage(error));
+    }
+  }, [loadAutomationCredits, nativeAdapters, superagentService]);
+  const onRestoreAutomation = useCallback(async ({
+    agentId,
+    automation
+  }) => {
+    try {
+      const updatedAutomation = await superagentService.restoreAutomation(agentId, automation);
+      setAutomations(current => current.map(item => item.id === automation.id ? {
+        ...item,
+        ...updatedAutomation,
+        is_active: true,
+        is_archived: false
+      } : item));
+      void loadAutomationCredits(agentId);
+    } catch (error) {
+      showAlert(nativeAdapters, 'Restore failed', getErrorMessage(error));
+    }
+  }, [loadAutomationCredits, nativeAdapters, superagentService]);
+  const onDeleteAutomation = useCallback(async ({
+    agentId,
+    automation
+  }) => {
+    const confirmed = await confirmAction(nativeAdapters, {
+      confirmText: 'Delete',
+      destructive: true,
+      message: `Delete "${automation.name}" permanently?`,
+      title: 'Delete automation?'
+    });
+    if (!confirmed) {
+      return;
+    }
+    try {
+      await superagentService.deleteAutomation(agentId, automation);
+      setAutomations(current => current.filter(item => item.id !== automation.id));
+      setAutomationCredits(current => {
+        const next = {
+          ...current
+        };
+        delete next[automation.id];
+        return next;
+      });
+    } catch (error) {
+      showAlert(nativeAdapters, 'Delete failed', getErrorMessage(error));
+    }
+  }, [nativeAdapters, superagentService]);
+  const onRunAutomationNow = useCallback(async ({
+    agentId,
+    automation
+  }) => {
+    try {
+      await superagentService.runAutomationNow(agentId, automation);
+      await refreshAutomations(agentId);
+    } catch (error) {
+      showAlert(nativeAdapters, 'Run failed', getErrorMessage(error));
+    }
+  }, [nativeAdapters, refreshAutomations, superagentService]);
+  const onEditAutomation = useCallback(({
+    agentId
+  }) => {
+    nativeAdapters.openWebUrl?.(buildWebUrl(config.webUrl ?? config.baseUrl, `/superagent/${encodeURIComponent(agentId)}`));
+  }, [config.baseUrl, config.webUrl, nativeAdapters]);
+  const onOpenSandboxFile = useCallback(async ({
+    agentId,
+    path
+  }) => {
+    return superagentService.readSandboxFile(agentId, path);
+  }, [superagentService]);
+  const onSaveSandboxFile = useCallback(async ({
+    agentId,
+    content,
+    path
+  }) => {
+    try {
+      await superagentService.writeSandboxFile(agentId, path, content);
+      await loadFiles(agentId);
+    } catch (error) {
+      showAlert(nativeAdapters, 'Save failed', getErrorMessage(error));
+      throw error;
+    }
+  }, [loadFiles, nativeAdapters, superagentService]);
+  const onUploadSandboxFiles = useCallback(async ({
+    agentId
+  }) => {
+    try {
+      const files = await nativeAdapters.pickSandboxFiles?.();
+      if (!files?.length) {
+        return [];
+      }
+      for (const file of files) {
+        await superagentService.writeSandboxFile(agentId, file.name, file.content);
+      }
+      await loadFiles(agentId);
+      return files.map(file => ({
+        path: file.name
+      }));
+    } catch (error) {
+      if (nativeAdapters.isAttachmentPickerCancel?.(error)) {
+        return [];
+      }
+      showAlert(nativeAdapters, 'Upload failed', getErrorMessage(error));
+      throw error;
+    }
+  }, [loadFiles, nativeAdapters, superagentService]);
+  const onRouteChange = useCallback(route => {
+    setCurrentRoute(route);
+    if (route.name === 'agent') {
+      setActiveAgentId(route.agentId);
+    }
+  }, []);
+  const onStartLiveVoice = useCallback(async context => {
+    const session = await superagentService.createVoiceLiveSession(context.agentId, context.conversationId);
+    try {
+      await startBackendVoiceLiveSession(session, nativeAdapters.liveVoiceAudio);
+    } finally {
+      await superagentService.deleteVoiceLiveSession(context.agentId, session.sessionId).catch(() => undefined);
+    }
+  }, [nativeAdapters, superagentService]);
+  const onOpenWhatsApp = useCallback(async ({
+    agentId
+  }) => {
+    setConnectingChannelId('whatsapp');
+    try {
+      const token = await resolveRuntimeToken(agentId);
+      const connectUrl = superagentService.getWhatsAppConnectUrl(agentId, token);
+      setChannelStatus(current => ({
+        ...current,
+        whatsapp: {
+          ...current.whatsapp,
+          connectUrl
+        }
+      }));
+      await nativeAdapters.openUrl?.(connectUrl);
+    } catch (error) {
+      showAlert(nativeAdapters, 'WhatsApp setup failed', getErrorMessage(error));
+    } finally {
+      setConnectingChannelId(null);
+    }
+  }, [nativeAdapters, resolveRuntimeToken, superagentService]);
+  const onSetupTelegram = useCallback(async ({
+    agentId,
+    token
+  }) => {
+    setConnectingChannelId('telegram');
+    try {
+      const runtimeToken = await resolveRuntimeToken(agentId);
+      const telegram = await superagentService.setupTelegram(agentId, runtimeToken, token);
+      setChannelStatus(current => ({
+        ...current,
+        telegram
+      }));
+    } finally {
+      setConnectingChannelId(null);
+    }
+  }, [resolveRuntimeToken, superagentService]);
+  const onDisconnectTelegram = useCallback(async ({
+    agentId
+  }) => {
+    const confirmed = await confirmAction(nativeAdapters, {
+      confirmText: 'Disconnect',
+      destructive: true,
+      message: 'The Telegram bot webhook will be removed from this Superagent.',
+      title: 'Disconnect Telegram?'
+    });
+    if (!confirmed) {
+      return;
+    }
+    setConnectingChannelId('telegram');
+    try {
+      const token = await resolveRuntimeToken(agentId);
+      await superagentService.disconnectTelegram(agentId, token);
+      setChannelStatus(current => ({
+        ...current,
+        telegram: {
+          connected: false
+        }
+      }));
+    } catch (error) {
+      showAlert(nativeAdapters, 'Telegram disconnect failed', getErrorMessage(error));
+    } finally {
+      setConnectingChannelId(null);
+    }
+  }, [nativeAdapters, resolveRuntimeToken, superagentService]);
+  const onGenerateLineCode = useCallback(async ({
+    agentId
+  }) => {
+    setConnectingChannelId('line');
+    try {
+      const token = await resolveRuntimeToken(agentId);
+      const activation = await superagentService.generateLineCode(agentId, token);
+      setChannelStatus(current => ({
+        ...current,
+        line: {
+          ...current.line,
+          activation,
+          connected: false
+        }
+      }));
+    } catch (error) {
+      showAlert(nativeAdapters, 'LINE setup failed', getErrorMessage(error));
+    } finally {
+      setConnectingChannelId(null);
+    }
+  }, [nativeAdapters, resolveRuntimeToken, superagentService]);
+  const onGenerateIMessageCode = useCallback(async ({
+    agentId
+  }) => {
+    setConnectingChannelId('imessage');
+    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
+        }
+      }));
+      return activation;
+    } catch (error) {
+      showAlert(nativeAdapters, 'iMessage setup failed', getErrorMessage(error));
+      throw error;
+    } finally {
+      setConnectingChannelId(null);
+    }
+  }, [nativeAdapters, resolveRuntimeToken, superagentService]);
+  const onDisconnectIMessage = useCallback(async ({
+    agentId
+  }) => {
+    const confirmed = await confirmAction(nativeAdapters, {
+      confirmText: 'Disconnect',
+      destructive: true,
+      message: 'Existing iMessage users will need to reconnect with a new activation code.',
+      title: 'Disconnect iMessage?'
+    });
+    if (!confirmed) {
+      return;
+    }
+    setConnectingChannelId('imessage');
+    try {
+      const token = await resolveRuntimeToken(agentId);
+      const imessage = await superagentService.disconnectIMessage(agentId, token);
+      setChannelStatus(current => ({
+        ...current,
+        imessage
+      }));
+    } catch (error) {
+      showAlert(nativeAdapters, 'iMessage disconnect failed', getErrorMessage(error));
+    } finally {
+      setConnectingChannelId(null);
+    }
+  }, [nativeAdapters, resolveRuntimeToken, superagentService]);
+  const onOpenIMessage = useCallback(async ({
+    code,
+    phoneNumber
+  }) => {
+    try {
+      await nativeAdapters.openUrl?.(buildIMessageUrl(phoneNumber, code));
+    } catch (error) {
+      showAlert(nativeAdapters, 'iMessage link unavailable', getErrorMessage(error));
+    }
+  }, [nativeAdapters]);
+  const onOpenTelegram = useCallback(async ({
+    url
+  }) => {
+    await openAllowedExternalUrl(nativeAdapters, url, ['t.me', 'telegram.me'], 'Telegram link unavailable');
+  }, [nativeAdapters]);
+  const onOpenLine = useCallback(async ({
+    url
+  }) => {
+    await openAllowedExternalUrl(nativeAdapters, url, ['line.me'], 'LINE link unavailable');
+  }, [nativeAdapters]);
+  const onShareLineCode = useCallback(async ({
+    addFriendUrl,
+    code
+  }) => {
+    await nativeAdapters.share?.({
+      message: `LINE activation code: ${code}\n${addFriendUrl}`,
+      title: 'LINE activation code',
+      url: addFriendUrl
+    });
+  }, [nativeAdapters]);
+  const onShareIMessageCode = useCallback(async ({
+    code,
+    phoneNumber
+  }) => {
+    await nativeAdapters.share?.({
+      message: `Text ${code} to ${phoneNumber} to connect this Superagent on iMessage.`,
+      title: 'iMessage activation code',
+      url: buildIMessageUrl(phoneNumber, code)
+    });
+  }, [nativeAdapters]);
+  const onConnectConnector = useCallback(async ({
+    accessMode,
+    agentId,
+    connectorId,
+    forceReconnect,
+    scopes
+  }) => {
+    if (connectorFlowRef.current) {
+      connectorFlowRef.current.cancelled = true;
+    }
+    const flow = {
+      agentId,
+      cancelled: false,
+      connectorId
+    };
+    connectorFlowRef.current = flow;
+    setConnectingConnectorId(connectorId);
+    try {
+      const connection = await superagentService.initiateConnectorConnection(agentId, connectorId, {
+        accessMode,
+        forceReconnect,
+        scopes
+      });
+      if (connection.error) {
+        throw new Error(connection.error_message || connection.error);
+      }
+      if (connection.already_authorized) {
+        connectorFlowRef.current = null;
+        setConnectingConnectorId(null);
+        await loadConnectors(agentId);
+        return 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) {
+        connectorFlowRef.current = null;
+        setConnectingConnectorId(null);
+        await loadConnectors(agentId);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      if (!flow.cancelled) {
+        connectorFlowRef.current = null;
+        setConnectingConnectorId(null);
+        showAlert(nativeAdapters, 'Connector failed', getErrorMessage(error));
+        await loadConnectors(agentId);
+      }
+      return false;
+    }
+  }, [loadConnectors, nativeAdapters, superagentService]);
+  const onCancelConnectorConnection = useCallback(({
+    agentId,
+    connectorId
+  }) => {
+    const flow = connectorFlowRef.current;
+    if (flow && flow.agentId === agentId && flow.connectorId === connectorId) {
+      flow.cancelled = true;
+      connectorFlowRef.current = null;
+    }
+    setConnectingConnectorId(null);
+    loadConnectors(agentId);
+  }, [loadConnectors]);
+  const onDisconnectConnector = useCallback(async ({
+    agentId,
+    connectorId
+  }) => {
+    const confirmed = await confirmAction(nativeAdapters, {
+      confirmText: 'Disconnect',
+      destructive: true,
+      message: 'The agent will stop using this connected account.',
+      title: 'Disconnect connector?'
+    });
+    if (!confirmed) {
+      return;
+    }
+    try {
+      await superagentService.disconnectConnector(agentId, connectorId);
+      await loadConnectors(agentId);
+    } catch (error) {
+      showAlert(nativeAdapters, 'Disconnect failed', getErrorMessage(error));
+    }
+  }, [loadConnectors, nativeAdapters, superagentService]);
+  const onRemoveConnector = useCallback(async ({
+    agentId,
+    connectorId
+  }) => {
+    const confirmed = await confirmAction(nativeAdapters, {
+      confirmText: 'Remove',
+      destructive: true,
+      message: 'This removes the connector authorization from this agent.',
+      title: 'Remove connector?'
+    });
+    if (!confirmed) {
+      return;
+    }
+    try {
+      await superagentService.removeConnector(agentId, connectorId);
+      await loadConnectors(agentId);
+    } catch (error) {
+      showAlert(nativeAdapters, 'Remove failed', getErrorMessage(error));
+    }
+  }, [loadConnectors, nativeAdapters, superagentService]);
+  return {
+    agents,
+    apiClient,
+    availableConnectors,
+    automationCredits,
+    automations,
+    channelStatus,
+    collaborators,
+    connectingChannelId,
+    connectingConnectorId,
+    connectedConnectors,
+    currentRoute,
+    currentUserAvatarUrl: config.currentUserAvatarUrl,
+    currentUserName: config.currentUserName,
+    fileLoadError,
+    fileLoadFailed,
+    filePaths,
+    isLoadingAgentSettings,
+    isLoadingChannels,
+    isLoadingCollaborators,
+    isLoadingConnectors,
+    isLoadingAutomations,
+    isLoadingFiles,
+    isLoading,
+    latestMessages: [],
+    loadError,
+    messagesByAgentId: {},
+    onAgentMessageDone: nativeAdapters.onAgentMessageDone,
+    onCancelConnectorConnection,
+    onArchiveAutomation,
+    onCloneAgent,
+    onConnectConnector,
+    onCreateAgent,
+    onDeleteAgent,
+    onDeleteAutomation,
+    onDeleteSecret,
+    onDisconnectConnector,
+    onDisconnectIMessage,
+    onDisconnectTelegram,
+    onEditAutomation,
+    onGenerateLineCode,
+    onGenerateIMessageCode,
+    onOpenIMessage,
+    onOpenLine,
+    onOpenAgent,
+    onOpenTelegram,
+    onOpenWhatsApp,
+    onOpenSandboxFile,
+    onOpenWorkspaceMembers,
+    onRemoveConnector,
+    onRenameAgent,
+    onRefreshAgentSettings: loadAgentSettings,
+    onRefreshAutomations: refreshAutomations,
+    onRefreshCollaborators: loadCollaborators,
+    onRefreshChannels: loadChannels,
+    onRefreshFiles: loadFiles,
+    onRestoreAutomation,
+    onRouteChange,
+    onRunAutomationNow,
+    onSaveSandboxFile,
+    onSaveSecret,
+    onShareAgent,
+    onShareAgentLink,
+    onShareIMessageCode,
+    onShareLineCode,
+    onStartLiveVoice,
+    onSetupTelegram,
+    onToggleAutomation,
+    onUpdateAgentModel,
+    onUpdateToolPermissions,
+    onUploadSandboxFiles,
+    realtimeClient,
+    secrets
+  };
+}
+async function waitForConnectorAuthorization(superagentService, agentId, connectorId, connectionId, flow) {
+  const maxAttempts = 40;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (flow.cancelled) {
+      return;
+    }
+    await delay(3000);
+    if (flow.cancelled) {
+      return;
+    }
+    const status = await superagentService.getConnectorConnectionStatus(agentId, connectorId, connectionId);
+    if (status === 'ACTIVE') {
+      return;
+    }
+    if (status === 'FAILED') {
+      throw new Error('OAuth connection failed.');
+    }
+  }
+  throw new Error('Connection timed out after 2 minutes.');
+}
+async function openAllowedExternalUrl(nativeAdapters, url, allowedHosts, fallbackMessage) {
+  if (!isAllowedExternalUrl(url, allowedHosts)) {
+    showAlert(nativeAdapters, fallbackMessage, 'The backend returned a channel link that cannot be opened safely.');
+    return;
+  }
+  try {
+    await nativeAdapters.openUrl?.(url);
+  } catch (error) {
+    showAlert(nativeAdapters, fallbackMessage, getErrorMessage(error));
+  }
+}
+function showAlert(nativeAdapters, title, message) {
+  nativeAdapters.alert?.(title, message);
+}
+async function confirmAction(nativeAdapters, input) {
+  if (!nativeAdapters.confirm) {
+    return true;
+  }
+  return nativeAdapters.confirm(input);
+}
+function buildWebUrl(baseUrl, path) {
+  return `${normalizeBaseUrl(baseUrl)}${path.startsWith('/') ? path : `/${path}`}`;
+}
+function buildIMessageUrl(phoneNumber, code) {
+  return `sms:${encodeURIComponent(phoneNumber)}?body=${encodeURIComponent(code)}`;
+}
+function normalizeBaseUrl(url) {
+  return url.trim().replace(/\/+$/, '');
+}
+function isAllowedExternalUrl(url, allowedHosts) {
+  try {
+    const parsedUrl = new URL(url);
+    if (parsedUrl.protocol !== 'https:') {
+      return false;
+    }
+    return allowedHosts.some(host => parsedUrl.hostname === host || parsedUrl.hostname.endsWith(`.${host}`));
+  } catch {
+    return false;
+  }
+}
+function delay(ms) {
+  return new Promise(resolve => {
+    setTimeout(resolve, ms);
+  });
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : 'Failed to load Superagents';
+}
+const GEMINI_LIVE_INPUT_SAMPLE_RATE = 16000;
+const GEMINI_LIVE_INPUT_MIME_TYPE = `audio/pcm;rate=${GEMINI_LIVE_INPUT_SAMPLE_RATE}`;
+function startBackendVoiceLiveSession(session, audio) {
+  if (!audio?.startAudioCapture) {
+    throw new Error('Native Live Voice audio callbacks are not installed in this app build.');
+  }
+  return new Promise((resolve, reject) => {
+    const socket = new WebSocket(session.websocketUrl, ['base44-voice']);
+    let capture;
+    let captureStarted = false;
+    let setupComplete = false;
+    let settled = false;
+    const finish = async error => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(setupTimeout);
+      try {
+        if (!error && socket.readyState === WebSocket.OPEN) {
+          socket.send(JSON.stringify({
+            realtimeInput: {
+              audioStreamEnd: true
+            }
+          }));
+        }
+        await capture?.stop?.();
+        await audio.stopAudioCapture?.();
+        await audio.stopAudioPlayback?.();
+      } catch {
+        // Cleanup should not hide the original Live Voice error.
+      }
+      if (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING) {
+        socket.close();
+      }
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    };
+    const startCapture = async () => {
+      if (captureStarted || settled) return;
+      captureStarted = true;
+      const canUseMicrophone = await audio.requestMicrophonePermission?.();
+      if (canUseMicrophone === false) {
+        await finish(new Error('Microphone access denied. Please allow microphone access to use Live Voice.'));
+        return;
+      }
+      await audio.prepareAudioSession?.();
+      capture = await audio.startAudioCapture({
+        mimeType: GEMINI_LIVE_INPUT_MIME_TYPE,
+        onAudioChunk(chunk) {
+          if (settled || socket.readyState !== WebSocket.OPEN) return;
+          socket.send(JSON.stringify({
+            realtimeInput: {
+              audio: {
+                data: chunk.data,
+                mimeType: chunk.mimeType ?? GEMINI_LIVE_INPUT_MIME_TYPE
+              }
+            }
+          }));
+        },
+        onError(error) {
+          finish(error);
+        },
+        onStop() {
+          finish();
+        },
+        sampleRate: GEMINI_LIVE_INPUT_SAMPLE_RATE
+      });
+    };
+    const setupTimeout = setTimeout(() => {
+      finish(new Error('Live Voice setup timed out.'));
+    }, 60000);
+    socket.onopen = () => {
+      socket.send(JSON.stringify({
+        base44Auth: {
+          streamToken: session.streamToken
+        }
+      }));
+    };
+    socket.onmessage = event => {
+      const payload = parseSocketPayload(event.data);
+      if (payload && ('setupComplete' in payload || 'setup_complete' in payload)) {
+        setupComplete = true;
+        clearTimeout(setupTimeout);
+        startCapture().catch(error => finish(error instanceof Error ? error : new Error('Failed to start Live Voice audio')));
+      }
+      if (payload && isGeminiLiveInterrupted(payload)) {
+        audio.stopAudioPlayback?.();
+      }
+      for (const chunk of getGeminiLiveAudioChunks(payload)) {
+        audio.playAudioChunk?.(chunk);
+      }
+    };
+    socket.onerror = () => {
+      finish(new Error('Failed to connect to Live Voice'));
+    };
+    socket.onclose = event => {
+      if (!setupComplete) {
+        finish(new Error(getLiveVoiceCloseMessage(event)));
+        return;
+      }
+      finish();
+    };
+  });
+}
+function getLiveVoiceCloseMessage(event) {
+  const reason = event.reason?.trim();
+  if (reason) {
+    return `Live Voice connection closed: ${event.code ?? 'unknown'} ${reason}`;
+  }
+  return `Live Voice connection closed: ${event.code ?? 'unknown'}`;
+}
+function parseSocketPayload(data) {
+  if (typeof data !== 'string') {
+    return null;
+  }
+  try {
+    const payload = JSON.parse(data);
+    return payload && typeof payload === 'object' ? payload : null;
+  } catch {
+    return null;
+  }
+}
+function getGeminiLiveAudioChunks(payload) {
+  const serverContent = getRecord(payload, 'serverContent') ?? getRecord(payload, 'server_content');
+  const modelTurn = getRecord(serverContent, 'modelTurn') ?? getRecord(serverContent, 'model_turn');
+  const parts = modelTurn?.parts;
+  if (!Array.isArray(parts)) {
+    return [];
+  }
+  return parts.flatMap(part => {
+    const partRecord = asRecord(part);
+    const inlineData = getRecord(partRecord, 'inlineData') ?? getRecord(partRecord, 'inline_data');
+    const data = inlineData?.data;
+    if (typeof data !== 'string' || data.length === 0) {
+      return [];
+    }
+    const mimeType = inlineData?.mimeType;
+    return [{
+      data,
+      mimeType: typeof mimeType === 'string' ? mimeType : undefined
+    }];
+  });
+}
+function isGeminiLiveInterrupted(payload) {
+  const serverContent = getRecord(payload, 'serverContent') ?? getRecord(payload, 'server_content');
+  return serverContent?.interrupted === true;
+}
+function getRecord(value, key) {
+  return asRecord(value?.[key]);
+}
+function asRecord(value) {
+  return value && typeof value === 'object' ? value : null;
+}
+//# sourceMappingURL=useSuperagentRuntime.js.map