@base44/superagent-native 0.0.1

package/src/types.ts

@@ -0,0 +1,514 @@
+import type { ComponentType, ReactNode } from 'react';
+import type { ProviderProps } from 'react-native-paper';
+
+export type SuperagentToolCall = {
+  id?: string;
+  name: string;
+  arguments?: Record<string, unknown> | string;
+  arguments_string?: string;
+  results?: string | Record<string, unknown>;
+  status?: string;
+  user_input?: unknown;
+  grouped?: boolean;
+  toolCalls?: SuperagentToolCall[];
+  [key: string]: unknown;
+};
+
+export type SuperagentReplyTo = {
+  messageId?: string;
+  content: string;
+};
+
+export type SuperagentAgent = {
+  id: string;
+  name: string;
+  description?: string;
+  emoji?: string | null;
+  logoUrl?: string;
+  model?: SuperagentModelChoice | string | null;
+  organizationId?: string | null;
+  toolsPermissionConfig?: SuperagentToolPermissionConfig;
+  avatarIndex?: number | null;
+  updatedAt?: string;
+};
+
+export type SuperagentModelChoice =
+  | 'default'
+  | 'claude_sonnet_4'
+  | 'claude_sonnet_4_5'
+  | 'claude_sonnet_4_6'
+  | 'claude_opus_4_5'
+  | 'claude_opus_4_6'
+  | 'claude_3_7'
+  | 'gemini_2_5_pro'
+  | 'gemini_2_5_flash'
+  | 'gemini_3_pro'
+  | 'gemini_3_1_pro'
+  | 'gpt_5'
+  | 'gpt_5_4'
+  | 'minimax_m2p5'
+  | 'glm_5'
+  | 'deepseek_v3'
+  | 'kimi_k2p5';
+
+export type SuperagentToolPermissionConfig = {
+  auto_approved_operations?: string[];
+  connector_guards?: Record<string, string>;
+};
+
+export type SuperagentSecret = {
+  name: string;
+  value: string;
+};
+
+export type SuperagentCollaborator = {
+  email: string;
+  full_name?: string | null;
+  id: string;
+  is_guest?: boolean;
+  is_owner?: boolean;
+  is_pending?: boolean;
+  profile_image_url?: string | null;
+};
+
+export type SuperagentAgentActionInput = {
+  agentId: string;
+};
+
+export type SuperagentShareAgentInput = SuperagentAgentActionInput & {
+  addAsGuest?: boolean;
+  emails: string[];
+};
+
+export type SuperagentOpenWorkspaceMembersInput = SuperagentAgentActionInput & {
+  organizationId?: string | null;
+};
+
+export type SuperagentInviteCollaboratorResult = {
+  email: string;
+  error?: string;
+  error_code?: string;
+  has_pending_invitation?: boolean;
+  success: boolean;
+};
+
+export type SuperagentInviteCollaboratorsResult = {
+  results: SuperagentInviteCollaboratorResult[];
+};
+
+export type SuperagentModelUpdateInput = SuperagentAgentActionInput & {
+  model: SuperagentModelChoice | string;
+};
+
+export type SuperagentSecretSaveInput = SuperagentAgentActionInput & SuperagentSecret;
+
+export type SuperagentSecretDeleteInput = SuperagentAgentActionInput & {
+  name: string;
+};
+
+export type SuperagentToolPermissionsUpdateInput = SuperagentAgentActionInput & {
+  config: SuperagentToolPermissionConfig;
+};
+
+export type SuperagentMessage = {
+  id?: string;
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  createdAt?: string;
+  created_at?: number | string;
+  fileUrls?: string[];
+  file_urls?: string[];
+  hidden?: boolean;
+  metadata?: {
+    created_date?: number | string | Date;
+    [key: string]: unknown;
+  };
+  replyTo?: SuperagentReplyTo;
+  additional_message_params?: {
+    reply_to?: {
+      message_id?: string;
+      content?: string;
+    };
+  } & Record<string, unknown>;
+  toolCalls?: SuperagentToolCall[];
+  tool_calls?: SuperagentToolCall[];
+};
+
+export type SuperagentRoute = { name: 'home' } | { name: 'create-agent' } | { name: 'agent'; agentId: string };
+
+export type SuperagentEditorTab =
+  | 'chat' | 'integrations' | 'tasks' | 'files' | 'channels' | 'agent_settings';
+
+export type SuperagentConversation = {
+  id: string;
+  messages?: SuperagentMessage[];
+};
+
+export type SuperagentRealtimeHandlers = {
+  onMessage?: (message: SuperagentMessage) => void;
+  onConversation?: (conversation: SuperagentConversation) => void;
+  onAgentDone?: () => void;
+  onReconnect?: () => void;
+  onError?: (error: unknown) => void;
+};
+
+export type SuperagentRealtimeClient = {
+  subscribeToConversation(conversationId: string, handlers: SuperagentRealtimeHandlers): () => void;
+};
+
+export type SuperagentPaginatedMessages = {
+  messages: SuperagentMessage[];
+  has_more?: boolean;
+  hasMore?: boolean;
+};
+
+export type QueuedSuperagentMessage = {
+  id: string;
+  content: string;
+  position?: number;
+};
+
+export type SuperagentMediaAttachment = {
+  id?: string;
+  url: string;
+  name?: string;
+  mimeType?: string;
+  kind?: 'image' | 'file' | 'audio';
+  previewUri?: string;
+};
+
+export type SuperagentMediaActionContext = {
+  agentId: string;
+  conversationId: string | null;
+};
+
+export type SuperagentMediaPicker = (
+  context: SuperagentMediaActionContext,
+) => Promise<SuperagentMediaAttachment[] | SuperagentMediaAttachment | null | undefined> | SuperagentMediaAttachment[] | SuperagentMediaAttachment | null | undefined;
+
+export type SuperagentVoiceInput = (
+  context: SuperagentMediaActionContext,
+) => Promise<string | null | undefined> | string | null | undefined;
+
+export type SuperagentLiveVoiceInput = (context: SuperagentMediaActionContext) => Promise<void> | void;
+
+export type SuperagentCopyMessageInput = (message: SuperagentMessage) => Promise<void> | void;
+
+export type SuperagentConnectorAccessMode = 'read_only' | 'full_access';
+
+export type SuperagentConnectorStatus = 'active' | 'disconnected' | 'expired';
+
+export type SuperagentConnectorAccessModeConfig = {
+  fullAccess: string[];
+  readOnly: string[];
+};
+
+export type SuperagentConnector = {
+  accountIdentifier?: string | null;
+  accessMode?: SuperagentConnectorAccessMode | null;
+  accessModes?: SuperagentConnectorAccessModeConfig;
+  category?: string;
+  exampleScopes?: string[];
+  iconBackgroundColor?: string;
+  iconFallbackLabel?: string;
+  iconUrl?: string;
+  id: string;
+  name: string;
+  requiresConnectionConfig?: boolean;
+  scopes?: string[];
+  status?: SuperagentConnectorStatus;
+  subtitle?: string;
+  supportsReadOnly?: boolean;
+};
+
+export type SuperagentConnectorActionInput = {
+  accessMode?: SuperagentConnectorAccessMode;
+  agentId: string;
+  connectorId: string;
+  forceReconnect?: boolean;
+  scopes?: string[];
+};
+
+export type SuperagentChannelId = 'whatsapp' | 'telegram' | 'line' | 'imessage';
+
+export type SuperagentTelegramChannelStatus = {
+  connected: boolean;
+  botLink?: string | null;
+  botName?: string | null;
+  botUsername?: string | null;
+};
+
+export type SuperagentWhatsAppChannelStatus = {
+  connected?: boolean;
+  connectUrl?: string | null;
+};
+
+export type SuperagentLineActivation = {
+  addFriendUrl: string;
+  code: string;
+};
+
+export type SuperagentLineChannelStatus = {
+  activation?: SuperagentLineActivation | null;
+  connected?: boolean;
+};
+
+export type SuperagentIMessageActivation = {
+  code: string;
+  phoneNumber: string;
+};
+
+export type SuperagentIMessageChannelStatus = {
+  activation?: SuperagentIMessageActivation | null;
+  connected?: boolean;
+  phoneNumber?: string | null;
+};
+
+export type SuperagentChannelStatus = {
+  imessage?: SuperagentIMessageChannelStatus;
+  line?: SuperagentLineChannelStatus;
+  telegram?: SuperagentTelegramChannelStatus;
+  whatsapp?: SuperagentWhatsAppChannelStatus;
+};
+
+export type SuperagentChannelActionInput = {
+  agentId: string;
+};
+
+export type SuperagentChannelUrlActionInput = SuperagentChannelActionInput & {
+  url: string;
+};
+
+export type SuperagentTelegramSetupInput = SuperagentChannelActionInput & {
+  token: string;
+};
+
+export type SuperagentLineCodeShareInput = SuperagentChannelActionInput & SuperagentLineActivation;
+export type SuperagentIMessageCodeShareInput = SuperagentChannelActionInput & SuperagentIMessageActivation;
+
+export type SuperagentAutomationType = 'scheduled' | 'entity' | 'connector';
+
+export type SuperagentAutomation = {
+  app_id?: string;
+  automation_type: SuperagentAutomationType | string;
+  consecutive_failures?: number;
+  created_date?: string;
+  description?: string;
+  ends_after_count?: number;
+  ends_on_date?: string;
+  ends_type?: 'never' | 'on' | 'after' | string;
+  entity_name?: string;
+  event_types?: string[];
+  events?: string[];
+  failed_runs?: number;
+  function_args?: Record<string, unknown>;
+  function_name?: string;
+  id: string;
+  integration_type?: string;
+  is_active?: boolean;
+  is_archived?: boolean;
+  last_run_at?: string;
+  last_run_status?: 'success' | 'failed' | string;
+  name: string;
+  one_time_date?: string;
+  repeat_interval?: number;
+  repeat_on_day_of_month?: number;
+  repeat_on_days?: number[];
+  repeat_unit?: 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | string;
+  schedule_mode?: 'recurring' | 'one-time' | string;
+  schedule_type?: 'simple' | 'cron' | string;
+  start_time?: string;
+  successful_runs?: number;
+  total_runs?: number;
+  trigger_conditions?: Record<string, unknown> | null;
+  updated_date?: string;
+  [key: string]: unknown;
+};
+
+export type SuperagentAutomationCreditsSummary = {
+  since: string | null;
+  total: number;
+};
+
+export type SuperagentAutomationActionInput = {
+  agentId: string;
+  automation: SuperagentAutomation;
+};
+
+export type SuperagentSandboxFileNode = {
+  children?: SuperagentSandboxFileNode[];
+  name: string;
+  type: 'file' | 'folder';
+};
+
+export type SuperagentSandboxFileActionInput = {
+  agentId: string;
+  path: string;
+};
+
+export type SuperagentSandboxFileContent = {
+  content: string;
+  path: string;
+};
+
+export type SuperagentSandboxFileSaveInput = SuperagentSandboxFileActionInput & {
+  content: string;
+};
+
+export type SuperagentSandboxFileUploadInput = {
+  agentId: string;
+};
+
+export type SuperagentSandboxFileUploadResult = {
+  path: string;
+};
+
+export type SuperagentRenameAgentInput = {
+  agentId: string;
+  name: string;
+};
+
+export type SuperagentNativeClientConfig = {
+  apiBaseUrl: string;
+  appId: string;
+  getAuthToken: () => Promise<string | null | undefined> | string | null | undefined;
+  getHeaders?: () => Promise<Record<string, string> | undefined> | Record<string, string> | undefined;
+};
+
+export type SuperagentNativeClient = {
+  getConversations(limit?: number): Promise<SuperagentConversation[]>;
+  getConversation(conversationId: string): Promise<SuperagentConversation>;
+  getMessages(conversationId: string, params?: { limit?: number; before?: string }): Promise<SuperagentPaginatedMessages>;
+  createConversation(metadata?: Record<string, unknown>): Promise<SuperagentConversation>;
+  addMessage(conversationId: string, message: Partial<SuperagentMessage>): Promise<unknown>;
+  stopConversation(conversationId: string): Promise<void>;
+  getQueuedMessages(conversationId: string): Promise<{ messages: QueuedSuperagentMessage[] }>;
+  editQueuedMessage(conversationId: string, messageId: string, content: string): Promise<{ ok: boolean }>;
+  deleteQueuedMessage(conversationId: string, messageId: string): Promise<{ ok: boolean }>;
+  deleteMessage(conversationId: string, messageId: string): Promise<{ message: string }>;
+  submitToolCallInput(
+    conversationId: string,
+    toolCallId: string,
+    approve: boolean,
+    extraUserInput?: unknown,
+    originRequestId?: string,
+  ): Promise<SuperagentConversation>;
+};
+
+export type SuperagentToolRendererProps = {
+  agent: SuperagentAgent;
+  conversationId: string | null;
+  message: SuperagentMessage;
+  submitToolCallInput?: (
+    toolCallId: string,
+    approve: boolean,
+    extraUserInput?: unknown,
+    originRequestId?: string,
+  ) => Promise<SuperagentConversation | null>;
+  toolCall: SuperagentToolCall;
+};
+
+export type SuperagentToolRenderer = ComponentType<SuperagentToolRendererProps>;
+
+export type SuperagentToolRenderers = Record<string, SuperagentToolRenderer>;
+
+export type SuperagentMarkdownRendererProps = {
+  content: string;
+  isUser: boolean;
+  message: SuperagentMessage;
+};
+
+export type SuperagentMarkdownRenderer = ComponentType<SuperagentMarkdownRendererProps>;
+
+export type SuperagentHomeScreenProps = {
+  agents?: SuperagentAgent[];
+  latestMessages?: SuperagentMessage[];
+  messagesByAgentId?: Record<string, SuperagentMessage[]>;
+  apiClient?: SuperagentNativeClient;
+  realtimeClient?: SuperagentRealtimeClient;
+  renderMarkdown?: SuperagentMarkdownRenderer;
+  toolRenderers?: SuperagentToolRenderers;
+  isLoading?: boolean;
+  isSendingMessage?: boolean;
+  navigationMode?: 'internal' | 'external';
+  paperTheme?: ProviderProps['theme'];
+  currentUserAvatarUrl?: string | null;
+  currentUserName?: string;
+  fileLoadError?: string | null;
+  fileLoadFailed?: boolean;
+  filePaths?: string[];
+  collaborators?: SuperagentCollaborator[];
+  headerAccessory?: ReactNode;
+  initialRoute?: SuperagentRoute;
+  isLoadingAgentSettings?: boolean;
+  isLoadingCollaborators?: boolean;
+  isLoadingFiles?: boolean;
+  secrets?: SuperagentSecret[];
+  onAgentBack?: () => void;
+  onAgentMessageDone?: () => Promise<void> | void;
+  onCreateAgent?: () => Promise<SuperagentAgent | void> | SuperagentAgent | void;
+  onOpenAgent?: (agentId: string) => void;
+  onOpenWorkspaceMembers?: (input: SuperagentOpenWorkspaceMembersInput) => Promise<void> | void;
+  onRouteChange?: (route: SuperagentRoute) => void;
+  onImportFromDrive?: SuperagentMediaPicker;
+  onPickFiles?: SuperagentMediaPicker;
+  onPickPhotos?: SuperagentMediaPicker;
+  onCopyMessage?: SuperagentCopyMessageInput;
+  automations?: SuperagentAutomation[];
+  automationCredits?: Record<string, SuperagentAutomationCreditsSummary>;
+  availableConnectors?: SuperagentConnector[];
+  channelStatus?: SuperagentChannelStatus;
+  connectedConnectors?: SuperagentConnector[];
+  connectingConnectorId?: string | null;
+  connectingChannelId?: SuperagentChannelId | null;
+  isLoadingAutomations?: boolean;
+  isLoadingChannels?: boolean;
+  isLoadingConnectors?: boolean;
+  onCancelConnectorConnection?: (input: { agentId: string; connectorId: string }) => void;
+  onConnectConnector?: (input: SuperagentConnectorActionInput) => Promise<boolean | void> | boolean | void;
+  onDisconnectConnector?: (input: SuperagentConnectorActionInput) => Promise<void> | void;
+  onArchiveAutomation?: (input: SuperagentAutomationActionInput) => Promise<void> | void;
+  onCloneAgent?: (input: SuperagentAgentActionInput) => Promise<void> | void;
+  onDeleteAgent?: (input: SuperagentAgentActionInput) => Promise<void> | void;
+  onDeleteAutomation?: (input: SuperagentAutomationActionInput) => Promise<void> | void;
+  onDeleteSecret?: (input: SuperagentSecretDeleteInput) => Promise<void> | void;
+  onEditAutomation?: (input: SuperagentAutomationActionInput) => Promise<void> | void;
+  onRemoveConnector?: (input: SuperagentConnectorActionInput) => Promise<void> | void;
+  onRenameAgent?: (input: SuperagentRenameAgentInput) => Promise<SuperagentAgent | void> | SuperagentAgent | void;
+  onRefreshAgentSettings?: (agentId: string) => Promise<void> | void;
+  onRefreshAutomations?: (agentId: string) => Promise<void> | void;
+  onRefreshCollaborators?: (agentId: string) => Promise<void> | void;
+  onRefreshFiles?: (agentId: string) => Promise<void> | void;
+  onRestoreAutomation?: (input: SuperagentAutomationActionInput) => Promise<void> | void;
+  onRunAutomationNow?: (input: SuperagentAutomationActionInput) => Promise<void> | void;
+  onOpenSandboxFile?: (input: SuperagentSandboxFileActionInput) => Promise<SuperagentSandboxFileContent> | SuperagentSandboxFileContent;
+  onDisconnectTelegram?: (input: SuperagentChannelActionInput) => Promise<void> | void;
+  onGenerateLineCode?: (input: SuperagentChannelActionInput) => Promise<void> | void;
+  onGenerateIMessageCode?: (input: SuperagentChannelActionInput) => Promise<SuperagentIMessageActivation | void> | SuperagentIMessageActivation | void;
+  onDisconnectIMessage?: (input: SuperagentChannelActionInput) => Promise<void> | void;
+  onOpenIMessage?: (input: SuperagentIMessageCodeShareInput) => Promise<void> | void;
+  onOpenLine?: (input: SuperagentChannelUrlActionInput) => Promise<void> | void;
+  onOpenTelegram?: (input: SuperagentChannelUrlActionInput) => Promise<void> | void;
+  onOpenWhatsApp?: (input: SuperagentChannelActionInput) => Promise<void> | void;
+  onRefreshChannels?: (agentId: string) => Promise<void> | void;
+  onSaveSandboxFile?: (input: SuperagentSandboxFileSaveInput) => Promise<void> | void;
+  onSaveSecret?: (input: SuperagentSecretSaveInput) => Promise<void> | void;
+  onShareAgent?: (input: SuperagentShareAgentInput) => Promise<SuperagentInviteCollaboratorsResult | void> | SuperagentInviteCollaboratorsResult | void;
+  onShareAgentLink?: (input: SuperagentAgentActionInput) => Promise<void> | void;
+  onShareIMessageCode?: (input: SuperagentIMessageCodeShareInput) => Promise<void> | void;
+  onShareLineCode?: (input: SuperagentLineCodeShareInput) => Promise<void> | void;
+  onStartLiveVoice?: SuperagentLiveVoiceInput;
+  onStartVoiceInput?: SuperagentVoiceInput;
+  onSetupTelegram?: (input: SuperagentTelegramSetupInput) => Promise<void> | void;
+  onTakePhoto?: SuperagentMediaPicker;
+  onToggleAutomation?: (input: SuperagentAutomationActionInput) => Promise<void> | void;
+  onUpdateAgentModel?: (input: SuperagentModelUpdateInput) => Promise<void> | void;
+  onUpdateToolPermissions?: (input: SuperagentToolPermissionsUpdateInput) => Promise<void> | void;
+  onUploadSandboxFiles?: (input: SuperagentSandboxFileUploadInput) => Promise<SuperagentSandboxFileUploadResult[] | void> | SuperagentSandboxFileUploadResult[] | void;
+  onSendMessage?: (params: {
+    agentId: string;
+    fileUrls?: string[];
+    message: string;
+    replyTo?: SuperagentReplyTo;
+  }) => Promise<SuperagentMessage | SuperagentMessage[] | void> | SuperagentMessage | SuperagentMessage[] | void;
+};

package/src/useSuperagentAttachmentPicker.tsx

@@ -0,0 +1,117 @@
+import React, {useCallback, useMemo, useState} from 'react';
+import type {
+  SuperagentMediaPicker,
+} from './types';
+import {AttachmentPickerStatusModal} from './AttachmentPickerStatusModal';
+import {
+  getAttachmentPickerErrorMessage,
+  pickAndUploadAttachments,
+} from './attachmentUpload';
+
+export type SuperagentAttachmentPickerMode = 'camera' | 'files' | 'photos';
+
+export type SuperagentNativeMediaItem = {
+  mimeType?: string;
+  name?: string;
+  previewUri?: string;
+  size?: number;
+  thumbnailUri?: string;
+  type?: string;
+  uploadUri?: string;
+  uri?: string;
+};
+
+export type SuperagentAttachmentPickerAdapters = {
+  isCancel?: (error: unknown) => boolean;
+  pickNativeMedia: (mode: SuperagentAttachmentPickerMode) => Promise<SuperagentNativeMediaItem[] | null | undefined>;
+};
+
+type PickerStatus = {
+  isError?: boolean;
+  message: string;
+  title: string;
+};
+
+type UseSuperagentAttachmentPickerInput = {
+  baseUrl: string;
+  getAccessToken: () => Promise<string | null | undefined> | string | null | undefined;
+  nativeAdapters: SuperagentAttachmentPickerAdapters;
+};
+
+export function useSuperagentAttachmentPicker({
+  baseUrl,
+  getAccessToken,
+  nativeAdapters,
+}: UseSuperagentAttachmentPickerInput) {
+  const [pickerStatus, setPickerStatus] = useState<PickerStatus | null>(null);
+
+  const createPicker = useCallback((mode: SuperagentAttachmentPickerMode): SuperagentMediaPicker => {
+    return async (context) => {
+      const authToken = await getAccessToken();
+      if (!authToken) {
+        setPickerStatus({
+          isError: true,
+          message: 'Sign in again before attaching files.',
+          title: 'Attachment unavailable',
+        });
+        return null;
+      }
+
+      try {
+        const attachments = await pickAndUploadAttachments({
+          authToken,
+          baseUrl,
+          context,
+          mode,
+          nativeAdapters,
+          onUploadStart: (count) => {
+            setPickerStatus({
+              message: `Uploading ${count === 1 ? 'attachment' : `${count} attachments`}...`,
+              title: 'Attaching files',
+            });
+          },
+        });
+        if (!attachments.length) {
+          return null;
+        }
+
+        setPickerStatus(null);
+        return attachments;
+      } catch (error) {
+        if (nativeAdapters.isCancel?.(error)) {
+          setPickerStatus(null);
+          return null;
+        }
+
+        setPickerStatus({
+          isError: true,
+          message: getAttachmentPickerErrorMessage(error),
+          title: 'Attachment failed',
+        });
+        return null;
+      }
+    };
+  }, [baseUrl, getAccessToken, nativeAdapters]);
+
+  const attachmentPickerModal = useMemo(() => {
+    if (!pickerStatus) {
+      return null;
+    }
+
+    return (
+      <AttachmentPickerStatusModal
+        isError={pickerStatus.isError}
+        message={pickerStatus.message}
+        onClose={() => setPickerStatus(null)}
+        title={pickerStatus.title}
+      />
+    );
+  }, [pickerStatus]);
+
+  return {
+    attachmentPickerModal,
+    onPickFiles: createPicker('files'),
+    onPickPhotos: createPicker('photos'),
+    onTakePhoto: createPicker('camera'),
+  };
+}