@onairos/react-native 3.1.2 → 3.1.4

package/lib/module/components/TrainingModal.js

@@ -1,5 +1,5 @@
 import React, { useEffect, useRef, useState } from 'react';
-import { View, Text, StyleSheet, TouchableOpacity, Dimensions, Modal, TouchableWithoutFeedback, SafeAreaView, Image } from 'react-native';
+import { View, Text, StyleSheet, TouchableOpacity, Dimensions, Modal, TouchableWithoutFeedback, SafeAreaView, Image, Alert } from 'react-native';
 import Icon from 'react-native-vector-icons/MaterialIcons';
 import { io } from 'socket.io-client';
 import { COLORS } from '../constants';
@@ -22,10 +22,13 @@ export const TrainingModal = ({
   const [socketConnected, setSocketConnected] = useState(false);
   const [trainingStatus, setTrainingStatus] = useState('Initializing...');
   const [hasError, setHasError] = useState(false);
+  const [errorCode, setErrorCode] = useState(null);
   const [isTrainingComplete, setIsTrainingComplete] = useState(false);
   const [userTraits, setUserTraits] = useState(null);
   const [inferenceResults, setInferenceResults] = useState(null);
   const [internalProgress, setInternalProgress] = useState(0);
+  const [isEnochSDK, setIsEnochSDK] = useState(false); // Determine if using Enoch SDK
+  const [trainingResults, setTrainingResults] = useState(null);
 
   // Use internal progress if available, otherwise fall back to prop progress
   const currentProgress = internalProgress > 0 ? internalProgress / 100 : progress;
@@ -40,115 +43,193 @@ export const TrainingModal = ({
     name: username || 'mobile_user'
   };
 
-  // Start Enoch training via API
-  const startEnochTraining = async socketId => {
+  // Check if we should use Enoch SDK (based on modelKey or other criteria)
+  useEffect(() => {
+    // For now, default to clean training unless specified
+    // In real implementation, this would be determined by SDK type
+    setIsEnochSDK((modelKey === null || modelKey === void 0 ? void 0 : modelKey.includes('enoch')) || false);
+  }, [modelKey]);
+
+  // Start training with new API schema
+  const startTraining = async socketId => {
     try {
       setTrainingStatus('Starting training...');
       setInternalProgress(10);
+      setHasError(false);
+      setErrorCode(null);
       if (!userToken) {
         throw new Error('No authentication token available');
       }
-      console.log('🚀 Starting Enoch training with socketId:', socketId);
-      console.log('🔍 Production mode: Using live training API');
 
-      // Prepare user data for training
+      // Determine endpoint based on SDK type
+      const endpoint = isEnochSDK ? '/mobile-training/enoch' : '/mobile-training/clean';
+      console.log(`🚀 Starting training with endpoint: ${endpoint}`);
+      console.log('🔍 Production mode: Using new training API schema');
+
+      // Prepare training data in new format
       const trainingData = {
-        socketId,
-        username: (userInfo === null || userInfo === void 0 ? void 0 : userInfo.username) || (userInfo === null || userInfo === void 0 ? void 0 : userInfo.name) || username || 'mobile_user',
-        email: (userInfo === null || userInfo === void 0 ? void 0 : userInfo.email) || null,
-        modelKey: modelKey || null,
-        userId: (userInfo === null || userInfo === void 0 ? void 0 : userInfo.id) || null
+        Info: {
+          username: (userInfo === null || userInfo === void 0 ? void 0 : userInfo.username) || (userInfo === null || userInfo === void 0 ? void 0 : userInfo.name) || username || 'mobile_user',
+          // Mock connected platforms - in real implementation this would come from props
+          connectedPlatforms: ['youtube', 'instagram', 'reddit'] // TODO: Get from actual connections
+        }
       };
       console.log('📤 Sending training data:', trainingData);
 
-      // Call the actual training API - backend confirmed this is working
-      const response = await fetch('https://api2.onairos.uk/enoch/trainModel/mobile', {
+      // Call the new training API
+      const response = await fetch(`https://api2.onairos.uk${endpoint}`, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
-          'Authorization': `Bearer ${userToken || 'temp-token'}` // Backend has JWT auth working
+          'Authorization': `Bearer ${userToken}` // JWT token authentication
         },
         body: JSON.stringify(trainingData)
       });
       const result = await response.json();
       if (result.success) {
         console.log('🚀 Training Started:', result.message);
-        setTrainingStatus('Training model...');
+        setTrainingStatus('Training initiated...');
         setInternalProgress(20);
       } else {
         console.error('Training start failed:', result.error);
-        setTrainingStatus(`Error: ${result.error}`);
-        setHasError(true);
 
-        // In production mode, don't fallback to simulation on API failure
-        console.error('🚨 Production mode: Training failed, not falling back to simulation');
+        // Handle specific error codes from new schema
+        if (result.code) {
+          setErrorCode(result.code);
+          handleTrainingError(result.code, result.error);
+        } else {
+          setTrainingStatus(`Error: ${result.error}`);
+          setHasError(true);
+        }
       }
     } catch (error) {
       console.error('Training start error:', error);
       setTrainingStatus(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
       setHasError(true);
+    }
+  };
 
-      // In production mode, show the actual error
-      console.error('🚨 Production mode: Training failed with error:', error);
+  // Handle training errors with specific error codes
+  const handleTrainingError = (code, message) => {
+    console.error(`Training Error [${code}]:`, message);
+    setHasError(true);
+    switch (code) {
+      case 'PIN_REQUIRED':
+        setTrainingStatus('PIN setup required');
+        Alert.alert('PIN Required', 'Please set up your PIN first before training.', [{
+          text: 'Cancel',
+          style: 'cancel'
+        }, {
+          text: 'Set PIN',
+          onPress: () => {
+            // TODO: Navigate to PIN setup
+            console.log('Navigate to PIN setup');
+          }
+        }]);
+        break;
+      case 'CONNECTIONS_REQUIRED':
+        setTrainingStatus('No connected accounts');
+        Alert.alert('Connections Required', 'Please connect at least one social media account before training.', [{
+          text: 'Cancel',
+          style: 'cancel'
+        }, {
+          text: 'Connect',
+          onPress: () => {
+            // TODO: Navigate to connections
+            console.log('Navigate to connections');
+          }
+        }]);
+        break;
+      case 'INSUFFICIENT_DATA':
+        setTrainingStatus('Insufficient data for training');
+        Alert.alert('Insufficient Data', 'We need more interaction data to train your model effectively. Please use your connected platforms more and try again.', [{
+          text: 'OK',
+          style: 'default'
+        }]);
+        break;
+      case 'ENCRYPTION_REQUIRED':
+        setTrainingStatus('Model encryption failed');
+        Alert.alert('Encryption Error', 'Failed to encrypt your model. Please try again.', [{
+          text: 'OK',
+          style: 'default'
+        }]);
+        break;
+      default:
+        setTrainingStatus(`Error: ${message}`);
+        Alert.alert('Training Error', message || 'An unexpected error occurred during training.', [{
+          text: 'OK',
+          style: 'default'
+        }]);
     }
   };
 
   // Simulate training progress for test mode
   const simulateTraining = () => {
-    var _stages$currentStage;
-    console.log('🧪 Starting simulated training...');
-    setTrainingStatus('Initializing training...');
-    setInternalProgress(10);
+    var _phases$currentPhase;
+    console.log('🧪 Starting simulated training with new schema phases...');
+    setTrainingStatus('Validating Requirements');
+    setInternalProgress(5);
 
-    // Fast training for test mode (shorter delays)
-    const baseDelay = 800;
-    const stages = [{
-      progress: 20,
-      status: 'Analyzing data patterns...',
-      delay: baseDelay
+    // Simulate all phases from the new schema
+    const phases = [{
+      progress: 10,
+      status: 'Validating Requirements',
+      delay: 1000
     }, {
-      progress: 35,
-      status: 'Building neural network...',
-      delay: baseDelay
+      progress: 25,
+      status: 'Training Model',
+      delay: 2000
     }, {
       progress: 50,
-      status: 'Training model...',
-      delay: baseDelay
+      status: 'Training Model',
+      delay: 2000
     }, {
       progress: 65,
-      status: 'Optimizing parameters...',
-      delay: baseDelay
+      status: 'Model Trained - Running Test Inference',
+      delay: 1500
     }, {
       progress: 80,
-      status: 'Running test inference...',
-      delay: baseDelay
+      status: 'Encrypting and Compressing Model',
+      delay: 1000
     }, {
       progress: 95,
-      status: 'Finalizing model...',
-      delay: baseDelay
+      status: 'Uploading Encrypted Model to ARDrive',
+      delay: 1500
     }, {
       progress: 100,
       status: 'Complete!',
-      delay: 300
+      delay: 500
     }];
-    let currentStage = 0;
+    let currentPhase = 0;
     const progressInterval = setInterval(() => {
-      if (currentStage < stages.length) {
-        const stage = stages[currentStage];
-        setInternalProgress(stage.progress);
-        setTrainingStatus(stage.status);
-        if (stage.progress === 100) {
+      if (currentPhase < phases.length) {
+        const phase = phases[currentPhase];
+        setInternalProgress(phase.progress);
+        setTrainingStatus(phase.status);
+        if (phase.progress === 100) {
           setIsTrainingComplete(true);
           clearInterval(progressInterval);
 
+          // Mock completion results
+          const mockResults = {
+            completed: true,
+            message: "Model trained, encrypted, and stored successfully",
+            storage: "ARDrive",
+            encryption: true,
+            inference: isEnochSDK,
+            // Only Enoch SDK runs inference
+            modelUrl: `https://arweave.net/mock_tx_${Date.now()}`
+          };
+          setTrainingResults(mockResults);
+
           // Auto-complete after a short delay
           setTimeout(() => {
             onComplete && onComplete();
-          }, 800);
+          }, 1000);
         }
-        currentStage++;
+        currentPhase++;
       }
-    }, ((_stages$currentStage = stages[currentStage]) === null || _stages$currentStage === void 0 ? void 0 : _stages$currentStage.delay) || baseDelay);
+    }, ((_phases$currentPhase = phases[currentPhase]) === null || _phases$currentPhase === void 0 ? void 0 : _phases$currentPhase.delay) || 1000);
 
     // Cleanup interval on unmount
     return () => clearInterval(progressInterval);
@@ -160,16 +241,17 @@ export const TrainingModal = ({
     console.log('Setting up socket connection for training...');
     console.log('🧑‍💻 User info available:', userInfo);
     console.log('🧪 Test mode:', test);
+    console.log('🔧 Using Enoch SDK:', isEnochSDK);
 
     // If test mode is enabled, use simulation instead of real API
     if (test) {
-      console.log('🧪 Test mode enabled - Using simulated training');
+      console.log('🧪 Test mode enabled - Using simulated training with new schema');
       setSocketConnected(true);
       simulateTraining();
       return;
     }
 
-    // Initialize real socket connection - backend confirmed this is working
+    // Initialize real socket connection
     try {
       console.log('🔌 Production mode: Initializing real socket connection');
 
@@ -179,14 +261,14 @@ export const TrainingModal = ({
         autoConnect: false
       });
 
-      // Socket event listeners
+      // Socket event listeners for new schema
       socketRef.current.on('connect', () => {
         var _socketRef$current;
         console.log('✅ Socket connected for training');
         setSocketConnected(true);
         const socketId = (_socketRef$current = socketRef.current) === null || _socketRef$current === void 0 ? void 0 : _socketRef$current.id;
         if (socketId) {
-          startEnochTraining(socketId);
+          startTraining(socketId);
         }
       });
       socketRef.current.on('disconnect', () => {
@@ -198,38 +280,88 @@ export const TrainingModal = ({
         setTrainingStatus('Connection failed');
         setHasError(true);
       });
+
+      // Handle training updates with new schema phases
+      socketRef.current.on('trainingUpdate', data => {
+        console.log('📡 Training update received:', data);
+        if (data.error) {
+          if (data.code) {
+            setErrorCode(data.code);
+            handleTrainingError(data.code, data.error);
+          } else {
+            console.error('Training update error:', data.error);
+            setTrainingStatus(`Error: ${data.error}`);
+            setHasError(true);
+          }
+        } else {
+          // Handle different status phases
+          if (data.status) {
+            setTrainingStatus(data.status);
+
+            // Update progress based on phase
+            switch (data.status) {
+              case 'Validating Requirements':
+                setInternalProgress(10);
+                break;
+              case 'Training Model':
+                setInternalProgress(data.percent || 40);
+                break;
+              case 'Model Trained - Running Test Inference':
+                setInternalProgress(65);
+                break;
+              case 'Encrypting and Compressing Model':
+                setInternalProgress(80);
+                break;
+              case 'Uploading Encrypted Model to ARDrive':
+                setInternalProgress(90);
+                break;
+              default:
+                if (data.percent) {
+                  setInternalProgress(data.percent);
+                }
+            }
+          }
+          if (data.progress) {
+            setInternalProgress(data.progress);
+          }
+        }
+      });
+
+      // Handle training completion with new schema
       socketRef.current.on('trainingCompleted', data => {
         console.log('✅ Training Complete:', data);
-        setTrainingStatus('Running test inference...');
-        setInternalProgress(60);
+        if (data.completed && data.storage === 'ARDrive' && data.encryption === true) {
+          setTrainingStatus('Training completed successfully!');
+          setIsTrainingComplete(true);
+          setInternalProgress(100);
+          setTrainingResults(data);
+
+          // Display results
+          console.log('✅ Model URL:', data.modelUrl);
+          console.log('✅ Storage:', data.storage);
+          console.log('✅ Encrypted:', data.encryption);
+          console.log('✅ Inference:', data.inference);
+
+          // Auto-complete after a short delay
+          setTimeout(() => {
+            onComplete && onComplete();
+          }, 1500);
+        } else {
+          console.error('Training completion missing required fields:', data);
+          setTrainingStatus('Training completed with warnings');
+          setHasError(true);
+        }
       });
+
+      // Legacy handlers for backward compatibility
       socketRef.current.on('inferenceCompleted', data => {
         console.log('🧠 Inference Complete:', data);
-        setTrainingStatus('Uploading to S3...');
-        setInternalProgress(80);
         setUserTraits(data.traits);
         setInferenceResults(data.inferenceResults);
       });
       socketRef.current.on('modelStandby', data => {
-        console.log('🎉 All Complete:', data);
-        setIsTrainingComplete(true);
-        setTrainingStatus('Complete!');
-        setInternalProgress(100);
-
-        // Auto-complete after a short delay
-        setTimeout(() => {
-          onComplete && onComplete();
-        }, 1500);
-      });
-      socketRef.current.on('trainingUpdate', data => {
-        if (data.error) {
-          console.error('Training update error:', data.error);
-          setTrainingStatus(`Error: ${data.error}`);
-          setHasError(true);
-        } else if (data.progress) {
-          setInternalProgress(data.progress);
-          setTrainingStatus(data.status || 'Training in progress...');
-        }
+        console.log('🎉 Model Ready:', data);
+        // This is handled by trainingCompleted now
       });
 
       // Connect to socket
@@ -248,7 +380,47 @@ export const TrainingModal = ({
         socketRef.current = null;
       }
     };
-  }, [visible, userInfo, test]);
+  }, [visible, userInfo, test, isEnochSDK]);
+
+  // Render error details for specific error codes
+  const renderErrorDetails = () => {
+    if (!hasError || !errorCode) return null;
+    const errorDetails = {
+      'PIN_REQUIRED': {
+        icon: 'lock',
+        title: 'PIN Setup Required',
+        description: 'Set up your PIN to secure your AI model'
+      },
+      'CONNECTIONS_REQUIRED': {
+        icon: 'link',
+        title: 'Connect Accounts',
+        description: 'Connect at least one social media account'
+      },
+      'INSUFFICIENT_DATA': {
+        icon: 'data-usage',
+        title: 'More Data Needed',
+        description: 'We need more interaction data to train effectively'
+      },
+      'ENCRYPTION_REQUIRED': {
+        icon: 'security',
+        title: 'Encryption Failed',
+        description: 'Failed to encrypt your model securely'
+      }
+    };
+    const details = errorDetails[errorCode];
+    if (!details) return null;
+    return /*#__PURE__*/React.createElement(View, {
+      style: styles.errorDetailsContainer
+    }, /*#__PURE__*/React.createElement(Icon, {
+      name: details.icon,
+      size: 32,
+      color: "#FF6B6B"
+    }), /*#__PURE__*/React.createElement(Text, {
+      style: styles.errorTitle
+    }, details.title), /*#__PURE__*/React.createElement(Text, {
+      style: styles.errorDescription
+    }, details.description));
+  };
   return /*#__PURE__*/React.createElement(Modal, {
     visible: visible,
     transparent: true,
@@ -273,7 +445,7 @@ export const TrainingModal = ({
     resizeMode: "contain"
   }), /*#__PURE__*/React.createElement(Text, {
     style: styles.title
-  }, "Training Your AI"), /*#__PURE__*/React.createElement(View, {
+  }, isEnochSDK ? 'Training AI with Inference' : 'Training Your AI'), /*#__PURE__*/React.createElement(View, {
     style: styles.progressContainer
   }, /*#__PURE__*/React.createElement(View, {
     style: styles.progressBar
@@ -293,7 +465,41 @@ export const TrainingModal = ({
     color: "#FF6B6B"
   }), /*#__PURE__*/React.createElement(Text, {
     style: styles.errorText
-  }, "Training encountered an error")), /*#__PURE__*/React.createElement(View, {
+  }, "Training encountered an error")), renderErrorDetails(), isTrainingComplete && trainingResults && /*#__PURE__*/React.createElement(View, {
+    style: styles.resultsContainer
+  }, /*#__PURE__*/React.createElement(Icon, {
+    name: "check-circle",
+    size: 32,
+    color: "#4CAF50"
+  }), /*#__PURE__*/React.createElement(Text, {
+    style: styles.resultsTitle
+  }, "Training Complete!"), /*#__PURE__*/React.createElement(View, {
+    style: styles.resultsDetails
+  }, /*#__PURE__*/React.createElement(View, {
+    style: styles.resultItem
+  }, /*#__PURE__*/React.createElement(Icon, {
+    name: "cloud-done",
+    size: 16,
+    color: "#666"
+  }), /*#__PURE__*/React.createElement(Text, {
+    style: styles.resultText
+  }, "Storage: ", trainingResults.storage)), /*#__PURE__*/React.createElement(View, {
+    style: styles.resultItem
+  }, /*#__PURE__*/React.createElement(Icon, {
+    name: "security",
+    size: 16,
+    color: "#666"
+  }), /*#__PURE__*/React.createElement(Text, {
+    style: styles.resultText
+  }, "Encrypted: ", trainingResults.encryption ? 'Yes' : 'No')), trainingResults.inference && /*#__PURE__*/React.createElement(View, {
+    style: styles.resultItem
+  }, /*#__PURE__*/React.createElement(Icon, {
+    name: "psychology",
+    size: 16,
+    color: "#666"
+  }), /*#__PURE__*/React.createElement(Text, {
+    style: styles.resultText
+  }, "Inference: Completed")))), /*#__PURE__*/React.createElement(View, {
     style: styles.footer
   }, /*#__PURE__*/React.createElement(TouchableOpacity, {
     style: styles.cancelButton,
@@ -362,7 +568,8 @@ const styles = StyleSheet.create({
   statusText: {
     fontSize: 14,
     color: COLORS.text.secondary,
-    marginBottom: 24
+    marginBottom: 24,
+    textAlign: 'center'
   },
   progressContainer: {
     width: '100%',
@@ -439,12 +646,63 @@ const styles = StyleSheet.create({
   errorContainer: {
     flexDirection: 'row',
     alignItems: 'center',
-    marginBottom: 24
+    marginBottom: 16
   },
   errorText: {
     fontSize: 14,
     color: '#FF6B6B',
     marginLeft: 8
+  },
+  errorDetailsContainer: {
+    alignItems: 'center',
+    marginBottom: 24,
+    padding: 16,
+    backgroundColor: '#FFF5F5',
+    borderRadius: 12,
+    borderWidth: 1,
+    borderColor: '#FFEBEE'
+  },
+  errorTitle: {
+    fontSize: 16,
+    fontWeight: '600',
+    color: '#FF6B6B',
+    marginTop: 8,
+    marginBottom: 4
+  },
+  errorDescription: {
+    fontSize: 14,
+    color: '#666',
+    textAlign: 'center'
+  },
+  resultsContainer: {
+    alignItems: 'center',
+    marginBottom: 24,
+    padding: 16,
+    backgroundColor: '#F5F5F5',
+    borderRadius: 12,
+    borderWidth: 1,
+    borderColor: '#E0E0E0'
+  },
+  resultsTitle: {
+    fontSize: 16,
+    fontWeight: '600',
+    color: '#4CAF50',
+    marginTop: 8,
+    marginBottom: 12
+  },
+  resultsDetails: {
+    alignItems: 'flex-start',
+    width: '100%'
+  },
+  resultItem: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    marginBottom: 4
+  },
+  resultText: {
+    fontSize: 14,
+    color: '#666',
+    marginLeft: 8
   }
 });
 //# sourceMappingURL=TrainingModal.js.map