@onairos/react-native 3.0.47 → 3.0.50

package/src/components/UniversalOnboarding.tsx

@@ -24,7 +24,7 @@ import { TrainingModal } from './TrainingModal';
 import { OAuthWebView } from './onboarding/OAuthWebView';
 import { useConnections } from '../hooks/useConnections';
 import { COLORS, DEEP_LINK_CONFIG } from '../constants';
-import { initiateOAuth, initiateNativeAuth, hasNativeSDK, isOAuthCallback, testApiConnectivity } from '../services/platformAuthService';
+import { initiateOAuth, initiateNativeAuth, hasNativeSDK, isOAuthCallback, testApiConnectivity, handleOAuthCallbackUrl, refreshYouTubeTokens } from '../services/platformAuthService';
 import type { UniversalOnboardingProps, ConnectionStatus } from '../types';
 import {
   init as opacityInit,
@@ -45,6 +45,9 @@ export const UniversalOnboarding: React.FC<UniversalOnboardingProps> = ({
   debug = false,
   test = false,
   preferredPlatform,
+  inferenceData,
+  auto = false,
+  partner,
 }) => {
   const [step, setStep] = useState<'connect' | 'pin' | 'training' | 'oauth' | 'success'>('connect');
   const [connections, setConnections] = useState<ConnectionStatus>({});
@@ -119,6 +122,13 @@ export const UniversalOnboarding: React.FC<UniversalOnboardingProps> = ({
       // Debug mode for Expo Go
       if (debug || Platform.OS === 'web') {
         console.log('Debug mode enabled - Using mock data for onboarding');
+        console.log('Configuration:', {
+          auto,
+          partner,
+          hasInferenceData: !!inferenceData,
+          inferenceDataType: typeof inferenceData,
+        });
+        
         // Pre-populate with mock connections in debug mode
         if (test || Platform.OS === 'web') {
           setConnections({
@@ -264,12 +274,11 @@ export const UniversalOnboarding: React.FC<UniversalOnboardingProps> = ({
             throw new Error('Invalid or empty Instagram profile data returned from Opacity SDK');
           }
         } else {
-          // For all other platforms (non-Instagram), use existing authentication methods
-          // Check if platform has a native SDK
+          // For all other platforms (non-Instagram), check if they have native SDK
           if (hasNativeSDK(platformId)) {
             console.log(`📱 Using native SDK for ${platformId}`);
             // Use native SDK for authentication
-            const success = await initiateNativeAuth(platformId);
+            const success = await initiateNativeAuth(platformId, username);
             if (success) {
               console.log(`✅ Native authentication successful for ${platformId}`);
               // Update platform toggle state
@@ -283,11 +292,15 @@ export const UniversalOnboarding: React.FC<UniversalOnboardingProps> = ({
                 ...prev,
                 [platformId]: { userName: username, connected: true }
               }));
+            } else {
+              throw new Error(`Native authentication failed for ${platformId}`);
             }
           } else {
+            // Use OAuth WebView flow
             console.log(`🌐 Initiating OAuth flow for ${platformId}`);
-            // Use OAuth flow through proxy server
+            
             const oauthUrl = await initiateOAuth(platformId, username, AppName);
+            
             if (oauthUrl) {
               console.log(`✅ Received OAuth URL for ${platformId}:`, oauthUrl);
               setCurrentPlatform(platformId);
@@ -295,7 +308,7 @@ export const UniversalOnboarding: React.FC<UniversalOnboardingProps> = ({
               setStep('oauth');
             } else {
               console.error(`❌ No OAuth URL returned for ${platformId}`);
-              Alert.alert('Error', 'Failed to get authorization URL for this platform. Please try again.');
+              throw new Error(`Failed to get authorization URL for ${platformId}. Please try again.`);
             }
           }
         }
@@ -347,10 +360,35 @@ export const UniversalOnboarding: React.FC<UniversalOnboardingProps> = ({
    * Handles OAuth callback URLs
    */
   const handleOAuthCallback = useCallback((url: string) => {
-    console.log('OAuth callback received:', url);
-    // Handle the OAuth callback here
-    // This would typically extract the authorization code and complete the OAuth flow
-  }, []);
+    console.log('🔗 OAuth callback received:', url);
+    
+    const result = handleOAuthCallbackUrl(url);
+    
+    if (result.success && result.platform && result.code) {
+      console.log(`✅ OAuth successful for ${result.platform}`);
+      
+      // Update connections state
+      setConnections(prev => ({
+        ...prev,
+        [result.platform!]: { userName: username, connected: true }
+      }));
+      
+      // Update platform toggles
+      setPlatformToggles(prev => ({
+        ...prev,
+        [result.platform!]: true
+      }));
+      
+      // Close OAuth window and return to connect step
+      setOauthUrl('');
+      setCurrentPlatform('');
+      setStep('connect');
+      
+      console.log(`🎉 ${result.platform} successfully connected via OAuth`);
+    } else {
+      console.error('❌ OAuth callback failed or incomplete');
+    }
+  }, [username]);
 
   /**
    * Handles completion of the OAuth flow
@@ -427,6 +465,8 @@ export const UniversalOnboarding: React.FC<UniversalOnboardingProps> = ({
         username,
         timestamp: Date.now(),
         appName: AppName,
+        inferenceData: auto ? inferenceData : undefined,
+        partner,
       };
       
       // Store session data in secure storage for future use
@@ -455,23 +495,41 @@ export const UniversalOnboarding: React.FC<UniversalOnboardingProps> = ({
       });
       if (progress >= 1) {
         clearInterval(interval);
-        // Close overlay and call the original onResolved callback
-        onComplete('https://api2.onairos.uk', 'dummy-token', {
+        
+        // Prepare completion data
+        const completionData = {
           pin: userPin,
           connections,
           platformToggles,
           selectedTier,
           tierData: requestData?.[selectedTier],
-          sessionSaved: true, // Indicate that session was saved
-        });
+          sessionSaved: true,
+          // Add inference data if auto mode is enabled
+          ...(auto && inferenceData && { inferenceData }),
+          // Add partner info for special partners
+          ...(partner && { partner: partner === 'couplebible' ? 'CoupleBible' : partner }),
+        };
+        
+        console.log('Completion data prepared:', completionData);
+        
+        // Close overlay and call the original onComplete callback
+        onComplete('https://api2.onairos.uk', 'dummy-token', completionData);
       }
     }, 1000); // Update every 1 second
-  }, [connections, onComplete, selectedTier, requestData, platformToggles, username, AppName]);
+  }, [connections, onComplete, selectedTier, requestData, platformToggles, username, AppName, auto, inferenceData, partner]);
 
   const canProceedToPin = useCallback(() => {
     // Check if at least one platform is toggled on
-    return Object.values(platformToggles).some(value => value === true);
-  }, [platformToggles]);
+    const hasPlatformConnected = Object.values(platformToggles).some(value => value === true);
+    
+    // If auto mode is enabled and partner is not "couplebible", require inferenceData
+    if (auto && partner !== 'couplebible' && !inferenceData) {
+      console.warn('Auto mode enabled but no inference data provided (and partner is not couplebible)');
+      return false;
+    }
+    
+    return hasPlatformConnected;
+  }, [platformToggles, auto, partner, inferenceData]);
 
   const handleProceed = () => {
     console.log('Proceeding to next step');

package/src/index.ts

@@ -70,6 +70,13 @@ export {
   storePlatformConnection,
 } from './services/oauthService';
 
+export {
+  updateGoogleClientIds,
+  refreshYouTubeTokens,
+  hasNativeSDK,
+  testApiConnectivity,
+} from './services/platformAuthService';
+
 // Export API and Services
 export { onairosApi } from './api';
 export { OAuthService } from './services/oauthService';

package/src/services/platformAuthService.ts

@@ -1,5 +1,5 @@
 import { Platform, Linking } from 'react-native';
-import { DEEP_LINK_CONFIG } from '../constants';
+import AsyncStorage from '@react-native-async-storage/async-storage';
 
 // Define types for platform auth configuration
 interface PlatformAuthConfig {
@@ -7,20 +7,28 @@ interface PlatformAuthConfig {
   nativeSDKPackage?: string;
   authEndpoint: string;
   color: string;
+  clientId?: string;
+  redirectUri?: string;
+  scope?: string;
+  responseType?: string;
 }
 
 // Configuration for each platform's authentication
-const PLATFORM_AUTH_CONFIG: Record<string, PlatformAuthConfig> = {
+let PLATFORM_AUTH_CONFIG: Record<string, PlatformAuthConfig> = {
   instagram: {
     hasNativeSDK: false, // Instagram uses OAuth WebView flow
     authEndpoint: 'https://api2.onairos.uk/instagram/authorize',
     color: '#E1306C',
   },
   youtube: {
-    hasNativeSDK: true, // YouTube uses Google Sign-In SDK
+    hasNativeSDK: true, // Native Google Sign-In SDK enabled
     nativeSDKPackage: '@react-native-google-signin/google-signin',
     authEndpoint: 'https://api2.onairos.uk/youtube/authorize',
     color: '#FF0000',
+    clientId: '1030678346906-lovkuds2ouqmoc8eu5qpo98spa6edv4o.apps.googleusercontent.com',
+    redirectUri: 'onairosevents://auth/callback',
+    scope: 'https://www.googleapis.com/auth/youtube.readonly',
+    responseType: 'code',
   },
   reddit: {
     hasNativeSDK: false,
@@ -197,64 +205,190 @@ export const initiateOAuth = async (platform: string, username: string, appName?
  * @param platform The platform to authenticate with
  * @returns A Promise that resolves to the authentication result
  */
-export const initiateNativeAuth = async (platform: string): Promise<boolean> => {
-  try {
-    // Currently only YouTube (Google Sign-In) is supported
-    if (platform === 'youtube') {
-      console.log('Initiating native Google Sign-In for YouTube');
+export const initiateNativeAuth = async (platform: string, username?: string): Promise<boolean> => {
+  if (platform === 'youtube') {
+    console.log('🔗 Initiating native Google Sign-In for YouTube');
+    try {
+      // Import Google Sign-In dynamically to avoid errors if not installed
+      const { GoogleSignin, statusCodes } = require('@react-native-google-signin/google-signin');
+      
+      // Configure Google Sign-In
+      await GoogleSignin.configure({
+        webClientId: '1030678346906-lovkuds2ouqmoc8eu5qpo98spa6edv4o.apps.googleusercontent.com', // Replace with your web client ID
+        iosClientId: '1030678346906-lovkuds2ouqmoc8eu5qpo98spa6edv4o.apps.googleusercontent.com', // Replace with your iOS client ID
+        scopes: ['https://www.googleapis.com/auth/youtube.readonly'],
+        offlineAccess: true, // CRITICAL: This ensures we get refresh tokens
+        hostedDomain: '',
+        forceCodeForRefreshToken: true, // CRITICAL: Force refresh token on first sign-in
+        accountName: '', // Clear to avoid conflicts
+      });
+      
+      // Check if Google Play Services are available
+      await GoogleSignin.hasPlayServices();
+      
+      // Sign in with Google
+      const userInfo = await GoogleSignin.signIn();
+      console.log('✅ Google Sign-In successful:', userInfo.user?.email);
+      
+      // Get access token for API calls
+      const tokens = await GoogleSignin.getTokens();
+      console.log('🔑 Got Google tokens');
+      
+      // Get current user info with refresh token
+      const currentUser = await GoogleSignin.getCurrentUser();
+      console.log('👤 Current user info:', currentUser?.user?.email);
       
+      // Extract refresh token from server auth code
+      let refreshToken = null;
+      if (currentUser?.serverAuthCode) {
+        console.log('🔄 Server auth code available for refresh token');
+        refreshToken = currentUser.serverAuthCode;
+      }
+      
+      if (!refreshToken) {
+        console.warn('⚠️ No refresh token available - token refresh may fail later');
+      } else {
+        console.log('✅ Refresh token available for YouTube connection');
+      }
+      
+      // Fetch YouTube channel information
+      let channelName = 'Unknown Channel';
+      let channelId = null;
       try {
-        // Import Google Sign-In dynamically to avoid errors if not installed
-        const { GoogleSignin, statusCodes } = require('@react-native-google-signin/google-signin');
-        
-        // Configure Google Sign-In
-        await GoogleSignin.configure({
-          scopes: ['https://www.googleapis.com/auth/youtube.readonly'],
-          webClientId: 'YOUR_ACTUAL_WEB_CLIENT_ID.apps.googleusercontent.com', // Replace with your actual web client ID
-          offlineAccess: true,
-          hostedDomain: '',
-          forceCodeForRefreshToken: true,
+        console.log('📺 Fetching YouTube channel information...');
+        const channelResponse = await fetch('https://www.googleapis.com/youtube/v3/channels?part=snippet&mine=true', {
+          headers: {
+            'Authorization': `Bearer ${tokens.accessToken}`,
+            'Accept': 'application/json'
+          }
         });
         
-        // Check if device supports Google Play Services
-        await GoogleSignin.hasPlayServices();
-        
-        // Sign in
-        const userInfo = await GoogleSignin.signIn();
-        console.log('Google Sign-In successful:', userInfo);
-        
-        // Get access token
-        const tokens = await GoogleSignin.getTokens();
-        console.log('Google tokens:', tokens);
-        
-        // Here you would typically send the tokens to your backend
-        // to associate the YouTube account with the user
-        
-        return true;
-      } catch (error: any) {
-        console.error('Google Sign-In error:', error);
-        
-        const { statusCodes: StatusCodes } = require('@react-native-google-signin/google-signin');
-        
-        if (error.code === StatusCodes.SIGN_IN_CANCELLED) {
-          console.log('User cancelled the sign-in flow');
-        } else if (error.code === StatusCodes.IN_PROGRESS) {
-          console.log('Sign-in is in progress already');
-        } else if (error.code === StatusCodes.PLAY_SERVICES_NOT_AVAILABLE) {
-          console.log('Play services not available or outdated');
-        } else {
-          console.log('Some other error happened');
+        if (channelResponse.ok) {
+          const channelData = await channelResponse.json();
+          if (channelData.items && channelData.items.length > 0) {
+            channelName = channelData.items[0].snippet.title;
+            channelId = channelData.items[0].id;
+            console.log('✅ YouTube channel found:', channelName);
+          }
         }
+      } catch (channelError) {
+        console.log('⚠️ Error fetching YouTube channel info:', channelError);
+        channelName = userInfo.user?.name || userInfo.user?.email || 'Unknown Channel';
+      }
+      
+      // Get authentication info
+      let authToken = await AsyncStorage.getItem('onairos_jwt_token') || 
+                     await AsyncStorage.getItem('enoch_token') || 
+                     await AsyncStorage.getItem('auth_token');
+      const storedUsername = await AsyncStorage.getItem('onairos_username');
+      const finalUsername = storedUsername || username || userInfo.user?.email || 'youtube_user';
+      
+      // Create auth token if needed
+      if (!authToken || authToken.trim().length < 20) {
+        console.log('🔐 Creating authentication token for YouTube...');
         
+        try {
+          const fallbackEmail = userInfo.user?.email || `${finalUsername}@youtube.temp`;
+          
+          // Create user accounts and get JWT token
+          const onairosSignupResponse = await fetch('https://api2.onairos.uk/register/enoch', {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+              email: fallbackEmail,
+              username: finalUsername,
+              name: finalUsername
+            })
+          });
+          
+          if (onairosSignupResponse.ok) {
+            const onairosResponseData = await onairosSignupResponse.json();
+            
+            // Extract token from response
+            authToken = onairosResponseData.token || onairosResponseData.data?.token || onairosResponseData.jwt;
+            
+            if (authToken) {
+              // Store tokens
+              await AsyncStorage.setItem('onairos_jwt_token', authToken);
+              await AsyncStorage.setItem('enoch_token', authToken);
+              await AsyncStorage.setItem('auth_token', authToken);
+              await AsyncStorage.setItem('onairos_username', onairosResponseData.username || finalUsername);
+              
+              console.log('✅ Successfully created and stored authentication token');
+            }
+          }
+        } catch (tokenError) {
+          console.warn('⚠️ Error creating auth token:', tokenError);
+        }
+      }
+      
+      console.log('🔗 Linking YouTube data to user:', finalUsername);
+      console.log('📺 YouTube channel name:', channelName);
+      
+      // Send tokens to backend for YouTube data processing
+      const backendResponse = await fetch('https://api2.onairos.uk/youtube/native-auth', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...(authToken && { 'Authorization': `Bearer ${authToken}` })
+        },
+        body: JSON.stringify({
+          session: {
+            username: finalUsername,
+            platform: 'youtube',
+            timestamp: new Date().toISOString(),
+            channelName: channelName,
+            channelId: channelId
+          },
+          googleUser: userInfo.user,
+          accessToken: tokens.accessToken,
+          idToken: tokens.idToken,
+          refreshToken: refreshToken, // CRITICAL: Include refresh token
+          serverAuthCode: currentUser?.serverAuthCode,
+          userAccountInfo: {
+            username: finalUsername,
+            email: userInfo.user?.email,
+            authToken: authToken,
+            channelName: channelName,
+            channelId: channelId,
+            userIdentifier: authToken ? `user-${authToken.substring(0, 10)}` : `youtube-${userInfo.user?.email}`,
+            googleId: userInfo.user?.id,
+          },
+          tokenExpiry: new Date(Date.now() + 3600 * 1000).toISOString(), // 1 hour from now
+          requestRefreshToken: true
+        })
+      });
+      
+      if (backendResponse.ok) {
+        const responseData = await backendResponse.json();
+        console.log('✅ YouTube connection processed by backend:', responseData);
+        return true;
+      } else {
+        const errorData = await backendResponse.text();
+        console.error('❌ Backend processing failed:', backendResponse.status, errorData);
         return false;
       }
+      
+    } catch (error: any) {
+      console.error('❌ Google Sign-In error:', error);
+      
+      const { statusCodes: StatusCodes } = require('@react-native-google-signin/google-signin');
+      
+      if (error.code === StatusCodes.SIGN_IN_CANCELLED) {
+        console.log('User cancelled Google Sign-In');
+      } else if (error.code === StatusCodes.IN_PROGRESS) {
+        console.log('Google Sign-In already in progress');
+      } else if (error.code === StatusCodes.PLAY_SERVICES_NOT_AVAILABLE) {
+        console.log('Google Play Services not available');
+      }
+      
+      return false;
     }
-    
-    throw new Error(`Native authentication not supported for ${platform}`);
-  } catch (error) {
-    console.error(`Error initiating native auth for ${platform}:`, error);
-    throw error;
   }
+
+  return false;
 };
 
 /**
@@ -313,3 +447,169 @@ export const testApiConnectivity = async (): Promise<{ success: boolean; error?:
     return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
   }
 };
+
+/**
+ * 🔄 REFRESH GOOGLE TOKENS
+ */
+export const refreshGoogleTokens = async (): Promise<{ accessToken: string; idToken?: string } | null> => {
+  try {
+    console.log('🔄 Attempting to refresh Google tokens...');
+    
+    const { GoogleSignin } = require('@react-native-google-signin/google-signin');
+    
+    const currentUser = await GoogleSignin.getCurrentUser();
+    if (!currentUser) {
+      console.log('❌ User not signed in to Google, cannot refresh tokens');
+      return null;
+    }
+    
+    const tokens = await GoogleSignin.getTokens();
+    console.log('✅ Successfully refreshed Google tokens');
+    
+    return {
+      accessToken: tokens.accessToken,
+      idToken: tokens.idToken
+    };
+  } catch (error) {
+    console.error('❌ Failed to refresh Google tokens:', error);
+    
+    // If refresh fails, try to sign in again
+    try {
+      console.log('🔄 Refresh failed, attempting re-authentication...');
+      const { GoogleSignin } = require('@react-native-google-signin/google-signin');
+      const userInfo = await GoogleSignin.signIn();
+      const tokens = await GoogleSignin.getTokens();
+      
+      console.log('✅ Re-authentication successful');
+      return {
+        accessToken: tokens.accessToken,
+        idToken: tokens.idToken
+      };
+    } catch (signInError) {
+      console.error('❌ Re-authentication also failed:', signInError);
+      return null;
+    }
+  }
+};
+
+/**
+ * 🔄 REFRESH YOUTUBE TOKENS
+ */
+export const refreshYouTubeTokens = async (): Promise<boolean> => {
+  try {
+    console.log('🔄 Refreshing YouTube tokens...');
+    
+    // Get fresh tokens from Google SDK
+    const freshTokens = await refreshGoogleTokens();
+    if (!freshTokens) {
+      console.error('❌ Failed to get fresh tokens from Google SDK');
+      return false;
+    }
+    
+    // Get current user info
+    const { GoogleSignin } = require('@react-native-google-signin/google-signin');
+    const currentUser = await GoogleSignin.getCurrentUser();
+    if (!currentUser) {
+      console.error('❌ No current Google user found');
+      return false;
+    }
+    
+    // Get stored auth token
+    const authToken = await AsyncStorage.getItem('onairos_jwt_token') || 
+                     await AsyncStorage.getItem('enoch_token') || 
+                     await AsyncStorage.getItem('auth_token');
+    
+    if (!authToken) {
+      console.error('❌ No auth token found for YouTube refresh');
+      return false;
+    }
+    
+    // Send refreshed tokens to backend
+    const refreshResponse = await fetch('https://api2.onairos.uk/youtube/refresh-token', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${authToken}`
+      },
+      body: JSON.stringify({
+        accessToken: freshTokens.accessToken,
+        idToken: freshTokens.idToken,
+        refreshToken: currentUser.serverAuthCode,
+        userEmail: currentUser.user?.email,
+        tokenExpiry: new Date(Date.now() + 3600 * 1000).toISOString(),
+        timestamp: new Date().toISOString()
+      })
+    });
+    
+    if (refreshResponse.ok) {
+      const responseData = await refreshResponse.json();
+      console.log('✅ YouTube tokens refreshed successfully:', responseData);
+      return true;
+    } else {
+      const errorData = await refreshResponse.text();
+      console.error('❌ YouTube token refresh failed:', refreshResponse.status, errorData);
+      return false;
+    }
+  } catch (error) {
+    console.error('❌ Error refreshing YouTube tokens:', error);
+    return false;
+  }
+};
+
+/**
+ * 🎯 ENHANCED OAUTH CALLBACK HANDLER
+ */
+export const handleOAuthCallbackUrl = (url: string): { platform?: string; code?: string; success: boolean } => {
+  try {
+    console.log('🔍 Processing OAuth callback URL:', url);
+    
+    // Parse the URL
+    const parsedUrl = new URL(url);
+    
+    // Extract platform and code
+    const platform = parsedUrl.searchParams.get('platform') || 
+                    parsedUrl.pathname.split('/').find(segment => 
+                      ['instagram', 'youtube', 'reddit', 'pinterest', 'email'].includes(segment)
+                    );
+    
+    const code = parsedUrl.searchParams.get('code');
+    const error = parsedUrl.searchParams.get('error');
+    
+    if (error) {
+      console.error('❌ OAuth error in callback:', error);
+      return { success: false };
+    }
+    
+    if (code && platform) {
+      console.log(`✅ OAuth callback processed: ${platform} with code: ${code.substring(0, 10)}...`);
+      return { platform, code, success: true };
+    }
+    
+    console.warn('⚠️ OAuth callback missing platform or code');
+    return { success: false };
+  } catch (error) {
+    console.error('❌ Error processing OAuth callback:', error);
+    return { success: false };
+  }
+};
+
+/**
+ * 🔧 UPDATE GOOGLE CLIENT IDS
+ * Allows apps to configure their own Google client IDs
+ */
+export const updateGoogleClientIds = (config: {
+  webClientId?: string;
+  iosClientId?: string;
+}) => {
+  console.log('🔧 Updating Google client IDs configuration');
+  
+  if (config.webClientId || config.iosClientId) {
+    // Update the YouTube configuration
+    PLATFORM_AUTH_CONFIG.youtube = {
+      ...PLATFORM_AUTH_CONFIG.youtube,
+      clientId: config.webClientId || PLATFORM_AUTH_CONFIG.youtube.clientId,
+    };
+    
+    console.log('✅ Google client IDs updated successfully');
+  }
+};

package/src/types.ts

@@ -21,6 +21,9 @@ export interface UniversalOnboardingProps {
   buttonType?: 'default' | 'pill';
   buttonForm?: 'signup' | 'login';
   preferredPlatform?: string;
+  inferenceData?: any; // Data used for AI inference API requests
+  auto?: boolean; // If true, use inferenceData for automatic API requests
+  partner?: string; // Partner identifier (e.g., "couplebible")
 }
 
 export interface ConnectionStatus {
@@ -56,7 +59,9 @@ export interface OnairosButtonProps {
   preferredPlatform?: string;
   testMode?: boolean;
   autoFetch?: boolean;
-  inferenceData?: any;
+  inferenceData?: any; // Data used for AI inference API requests
+  auto?: boolean; // If true, use inferenceData for automatic API requests
+  partner?: string; // Partner identifier (e.g., "couplebible")
   textLayout?: 'left' | 'right' | 'center';
   textColor?: string;
   proofMode?: boolean;