npm install react-native-fs
# For iOS
cd ios && pod install

# Install TensorFlow Lite
npm install @tensorflow/tfjs @tensorflow/tfjs-react-native
npm install @tensorflow/tfjs-platform-react-native

// App.js - Initialize TensorFlow
import * as tf from '@tensorflow/tfjs';
import '@tensorflow/tfjs-react-native';
import '@tensorflow/tfjs-platform-react-native';

export default function App() {
  useEffect(() => {
    // Initialize TensorFlow
    tf.ready().then(() => {
      console.log('TensorFlow.js is ready!');
    });
  }, []);

  return <YourAppContent />;
}

// hooks/useImageClassification.js
import { useState, useEffect } from 'react';
import * as tf from '@tensorflow/tfjs';
import { decodeJpeg } from '@tensorflow/tfjs-react-native';

export const useImageClassification = () => {
  const [model, setModel] = useState(null);
  const [isLoading, setIsLoading] = useState(false);

  useEffect(() => {
    loadModel();
  }, []);

  const loadModel = async () => {
    try {
      setIsLoading(true);
      
      // Load pre-trained MobileNet model
      const modelUrl = 'https://tfhub.dev/google/tfjs-model/imagenet/mobilenet_v2_130_224/classification/3/default/1';
      const loadedModel = await tf.loadLayersModel(modelUrl);
      
      setModel(loadedModel);
    } catch (error) {
      console.error('Failed to load model:', error);
    } finally {
      setIsLoading(false);
    }
  };

  const classifyImage = async (imageUri) => {
    if (!model) return null;

    try {
      // Load and preprocess image
      const response = await fetch(imageUri, {}, { isBinary: true });
      const imageData = new Uint8Array(await response.arrayBuffer());
      const imageTensor = decodeJpeg(imageData);

      // Resize to model input size (224x224)
      const resized = tf.image.resizeBilinear(imageTensor, [224, 224]);
      const normalized = resized.div(255.0);
      const batched = normalized.expandDims(0);

      // Make prediction
      const predictions = await model.predict(batched).data();
      
      // Get top 5 predictions
      const top5 = Array.from(predictions)
        .map((p, i) => ({ probability: p, classId: i }))
        .sort((a, b) => b.probability - a.probability)
        .slice(0, 5);

      // Clean up tensors
      imageTensor.dispose();
      resized.dispose();
      normalized.dispose();
      batched.dispose();

      return top5;
    } catch (error) {
      console.error('Classification error:', error);
      return null;
    }
  };

  return { classifyImage, isLoading, isReady: !!model };
};

// components/ObjectDetectionCamera.js
import React, { useRef, useState } from 'react';
import { View, StyleSheet, Dimensions } from 'react-native';
import { RNCamera } from 'react-native-camera';
import * as tf from '@tensorflow/tfjs';

const { width, height } = Dimensions.get('window');

export const ObjectDetectionCamera = () => {
  const cameraRef = useRef(null);
  const [detections, setDetections] = useState([]);
  const [model, setModel] = useState(null);

  useEffect(() => {
    loadObjectDetectionModel();
  }, []);

  const loadObjectDetectionModel = async () => {
    try {
      // Load COCO-SSD model for object detection
      const modelUrl = 'https://tfhub.dev/tensorflow/tfjs-model/ssd_mobilenet_v2/1/default/1';
      const loadedModel = await tf.loadGraphModel(modelUrl);
      setModel(loadedModel);
    } catch (error) {
      console.error('Failed to load object detection model:', error);
    }
  };

  const detectObjects = async () => {
    if (!model || !cameraRef.current) return;

    try {
      // Capture frame from camera
      const options = { quality: 0.7, base64: true, skipProcessing: true };
      const data = await cameraRef.current.takePictureAsync(options);

      // Convert image to tensor
      const imageTensor = tf.browser.fromPixels(data.uri);
      const resized = tf.image.resizeBilinear(imageTensor, [300, 300]);
      const expanded = resized.expandDims(0);

      // Run inference
      const predictions = await model.executeAsync(expanded);
      
      // Process predictions
      const boxes = await predictions[0].data();
      const scores = await predictions[1].data();
      const classes = await predictions[2].data();

      const detectedObjects = [];
      for (let i = 0; i < scores.length; i++) {
        if (scores[i] > 0.5) { // Confidence threshold
          detectedObjects.push({
            bbox: [boxes[i * 4], boxes[i * 4 + 1], boxes[i * 4 + 2], boxes[i * 4 + 3]],
            class: classes[i],
            score: scores[i],
          });
        }
      }

      setDetections(detectedObjects);

      // Clean up
      imageTensor.dispose();
      resized.dispose();
      expanded.dispose();
      predictions.forEach(p => p.dispose());
    } catch (error) {
      console.error('Object detection error:', error);
    }
  };

  return (
    <View style={styles.container}>
      <RNCamera
        ref={cameraRef}
        style={styles.camera}
        type={RNCamera.Constants.Type.back}
        onCameraReady={() => {
          // Start detection loop
          const interval = setInterval(detectObjects, 1000);
          return () => clearInterval(interval);
        }}
      />
      
      {/* Render detection boxes */}
      {detections.map((detection, index) => (
        <View
          key={index}
          style={[
            styles.boundingBox,
            {
              left: detection.bbox[1] * width,
              top: detection.bbox[0] * height,
              width: (detection.bbox[3] - detection.bbox[1]) * width,
              height: (detection.bbox[2] - detection.bbox[0]) * height,
            },
          ]}
        />
      ))}
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
  },
  camera: {
    flex: 1,
  },
  boundingBox: {
    position: 'absolute',
    borderWidth: 2,
    borderColor: '#00ff00',
    backgroundColor: 'transparent',
  },
});

// services/openai.js
import OpenAI from 'openai';

class OpenAIService {
  constructor() {
    this.client = new OpenAI({
      apiKey: process.env.OPENAI_API_KEY,
    });
  }

  async generateText(prompt, options = {}) {
    try {
      const completion = await this.client.chat.completions.create({
        model: 'gpt-4',
        messages: [{ role: 'user', content: prompt }],
        max_tokens: options.maxTokens || 150,
        temperature: options.temperature || 0.7,
        ...options,
      });

      return completion.choices[0].message.content;
    } catch (error) {
      console.error('OpenAI API error:', error);
      throw error;
    }
  }

  async analyzeImage(imageBase64, prompt) {
    try {
      const completion = await this.client.chat.completions.create({
        model: 'gpt-4-vision-preview',
        messages: [
          {
            role: 'user',
            content: [
              { type: 'text', text: prompt },
              {
                type: 'image_url',
                image_url: {
                  url: `data:image/jpeg;base64,${imageBase64}`,
                },
              },
            ],
          },
        ],
        max_tokens: 300,
      });

      return completion.choices[0].message.content;
    } catch (error) {
      console.error('Image analysis error:', error);
      throw error;
    }
  }

  async transcribeAudio(audioUri) {
    try {
      const formData = new FormData();
      formData.append('file', {
        uri: audioUri,
        type: 'audio/m4a',
        name: 'audio.m4a',
      });
      formData.append('model', 'whisper-1');

      const response = await fetch('https://api.openai.com/v1/audio/transcriptions', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
          'Content-Type': 'multipart/form-data',
        },
        body: formData,
      });

      const result = await response.json();
      return result.text;
    } catch (error) {
      console.error('Audio transcription error:', error);
      throw error;
    }
  }
}

export default new OpenAIService();

// components/SmartPhotoEnhancer.js
import React, { useState } from 'react';
import { View, Image, TouchableOpacity, Text, StyleSheet, Alert } from 'react-native';
import { launchImageLibrary } from 'react-native-image-picker';
import OpenAIService from '../services/openai';

export const SmartPhotoEnhancer = () => {
  const [selectedImage, setSelectedImage] = useState(null);
  const [enhancedImage, setEnhancedImage] = useState(null);
  const [imageAnalysis, setImageAnalysis] = useState('');
  const [isProcessing, setIsProcessing] = useState(false);

  const selectImage = () => {
    launchImageLibrary(
      {
        mediaType: 'photo',
        quality: 0.8,
        includeBase64: true,
      },
      (response) => {
        if (response.assets && response.assets[0]) {
          setSelectedImage(response.assets[0]);
        }
      }
    );
  };

  const analyzeImage = async () => {
    if (!selectedImage) return;

    setIsProcessing(true);
    try {
      const analysis = await OpenAIService.analyzeImage(
        selectedImage.base64,
        'Analyze this image and provide suggestions for enhancement. Include details about lighting, composition, and potential improvements.'
      );
      
      setImageAnalysis(analysis);
    } catch (error) {
      Alert.alert('Error', 'Failed to analyze image');
    } finally {
      setIsProcessing(false);
    }
  };

  const enhanceImage = async () => {
    if (!selectedImage) return;

    setIsProcessing(true);
    try {
      // Use AI-powered image enhancement API
      const enhancementPrompt = `Enhance this image by improving: ${imageAnalysis}`;
      
      const formData = new FormData();
      formData.append('image', {
        uri: selectedImage.uri,
        type: selectedImage.type,
        name: selectedImage.fileName,
      });
      formData.append('prompt', enhancementPrompt);

      // Replace with your preferred image enhancement API
      const response = await fetch('YOUR_IMAGE_ENHANCEMENT_API', {
        method: 'POST',
        body: formData,
        headers: {
          'Content-Type': 'multipart/form-data',
        },
      });

      const result = await response.json();
      setEnhancedImage(result.enhanced_image_url);
    } catch (error) {
      Alert.alert('Error', 'Failed to enhance image');
    } finally {
      setIsProcessing(false);
    }
  };

  return (
    <View style={styles.container}>
      <TouchableOpacity style={styles.button} onPress={selectImage}>
        <Text style={styles.buttonText}>Select Image</Text>
      </TouchableOpacity>

      {selectedImage && (
        <View style={styles.imageContainer}>
          <Image source={{ uri: selectedImage.uri }} style={styles.image} />
          
          <TouchableOpacity 
            style={styles.button} 
            onPress={analyzeImage}
            disabled={isProcessing}
          >
            <Text style={styles.buttonText}>
              {isProcessing ? 'Analyzing...' : 'Analyze Image'}
            </Text>
          </TouchableOpacity>
        </View>
      )}

      {imageAnalysis && (
        <View style={styles.analysisContainer}>
          <Text style={styles.analysisTitle}>AI Analysis:</Text>
          <Text style={styles.analysisText}>{imageAnalysis}</Text>
          
          <TouchableOpacity 
            style={styles.button} 
            onPress={enhanceImage}
            disabled={isProcessing}
          >
            <Text style={styles.buttonText}>
              {isProcessing ? 'Enhancing...' : 'Enhance Image'}
            </Text>
          </TouchableOpacity>
        </View>
      )}

      {enhancedImage && (
        <View style={styles.imageContainer}>
          <Text style={styles.title}>Enhanced Image:</Text>
          <Image source={{ uri: enhancedImage }} style={styles.image} />
        </View>
      )}
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    padding: 20,
    backgroundColor: '#f5f5f5',
  },
  button: {
    backgroundColor: '#007AFF',
    padding: 15,
    borderRadius: 8,
    alignItems: 'center',
    marginVertical: 10,
  },
  buttonText: {
    color: 'white',
    fontSize: 16,
    fontWeight: 'bold',
  },
  imageContainer: {
    marginVertical: 20,
    alignItems: 'center',
  },
  image: {
    width: 300,
    height: 300,
    borderRadius: 8,
  },
  analysisContainer: {
    backgroundColor: 'white',
    padding: 15,
    borderRadius: 8,
    marginVertical: 10,
  },
  analysisTitle: {
    fontSize: 18,
    fontWeight: 'bold',
    marginBottom: 10,
  },
  analysisText: {
    fontSize: 14,
    lineHeight: 20,
    marginBottom: 15,
  },
  title: {
    fontSize: 18,
    fontWeight: 'bold',
    marginBottom: 10,
  },
});

// hooks/useSpeechRecognition.js
import { useState, useEffect } from 'react';
import Voice from '@react-native-voice/voice';
import OpenAIService from '../services/openai';

export const useSpeechRecognition = () => {
  const [isListening, setIsListening] = useState(false);
  const [recognizedText, setRecognizedText] = useState('');
  const [error, setError] = useState(null);

  useEffect(() => {
    Voice.onSpeechStart = onSpeechStart;
    Voice.onSpeechEnd = onSpeechEnd;
    Voice.onSpeechResults = onSpeechResults;
    Voice.onSpeechError = onSpeechError;

    return () => {
      Voice.destroy().then(Voice.removeAllListeners);
    };
  }, []);

  const onSpeechStart = () => {
    setIsListening(true);
    setError(null);
  };

  const onSpeechEnd = () => {
    setIsListening(false);
  };

  const onSpeechResults = (event) => {
    if (event.value && event.value.length > 0) {
      setRecognizedText(event.value[0]);
    }
  };

  const onSpeechError = (event) => {
    setError(event.error);
    setIsListening(false);
  };

  const startListening = async () => {
    try {
      await Voice.start('en-US');
    } catch (error) {
      setError(error.message);
    }
  };

  const stopListening = async () => {
    try {
      await Voice.stop();
    } catch (error) {
      setError(error.message);
    }
  };

  const processCommand = async (text) => {
    try {
      const response = await OpenAIService.generateText(
        `Process this voice command and return a structured response: "${text}"`,
        {
          maxTokens: 100,
          temperature: 0.3,
        }
      );
      
      return response;
    } catch (error) {
      console.error('Command processing error:', error);
      return null;
    }
  };

  return {
    isListening,
    recognizedText,
    error,
    startListening,
    stopListening,
    processCommand,
  };
};

// components/AIAssistant.js
import React, { useState, useRef, useEffect } from 'react';
import { View, Text, TextInput, TouchableOpacity, ScrollView, StyleSheet } from 'react-native';
import OpenAIService from '../services/openai';

export const AIAssistant = () => {
  const [messages, setMessages] = useState([
    { role: 'assistant', content: 'Hello! How can I assist you today?' }
  ]);
  const [inputText, setInputText] = useState('');
  const [isTyping, setIsTyping] = useState(false);
  const scrollViewRef = useRef(null);

  useEffect(() => {
    scrollToBottom();
  }, [messages]);

  const scrollToBottom = () => {
    setTimeout(() => {
      scrollViewRef.current?.scrollToEnd({ animated: true });
    }, 100);
  };

  const sendMessage = async () => {
    if (!inputText.trim()) return;

    const userMessage = { role: 'user', content: inputText };
    const newMessages = [...messages, userMessage];
    setMessages(newMessages);
    setInputText('');
    setIsTyping(true);

    try {
      const conversationHistory = newMessages.map(msg => ({
        role: msg.role,
        content: msg.content,
      }));

      const response = await OpenAIService.client.chat.completions.create({
        model: 'gpt-4',
        messages: [
          {
            role: 'system',
            content: 'You are a helpful AI assistant in a mobile app. Provide concise, helpful responses.',
          },
          ...conversationHistory,
        ],
        max_tokens: 200,
        temperature: 0.7,
      });

      const assistantMessage = {
        role: 'assistant',
        content: response.choices[0].message.content,
      };

      setMessages(prev => [...prev, assistantMessage]);
    } catch (error) {
      const errorMessage = {
        role: 'assistant',
        content: 'Sorry, I encountered an error. Please try again.',
      };
      setMessages(prev => [...prev, errorMessage]);
    } finally {
      setIsTyping(false);
    }
  };

  return (
    <View style={styles.container}>
      <ScrollView ref={scrollViewRef} style={styles.messagesContainer}>
        {messages.map((message, index) => (
          <View
            key={index}
            style={[
              styles.messageContainer,
              message.role === 'user' ? styles.userMessage : styles.assistantMessage,
            ]}
          >
            <Text style={styles.messageText}>{message.content}</Text>
          </View>
        ))}
        
        {isTyping && (
          <View style={[styles.messageContainer, styles.assistantMessage]}>
            <Text style={styles.typingText}>AI is typing...</Text>
          </View>
        )}
      </ScrollView>

      <View style={styles.inputContainer}>
        <TextInput
          style={styles.textInput}
          value={inputText}
          onChangeText={setInputText}
          placeholder="Type your message..."
          multiline
          onSubmitEditing={sendMessage}
        />
        <TouchableOpacity 
          style={styles.sendButton} 
          onPress={sendMessage}
          disabled={!inputText.trim() || isTyping}
        >
          <Text style={styles.sendButtonText}>Send</Text>
        </TouchableOpacity>
      </View>
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: '#f5f5f5',
  },
  messagesContainer: {
    flex: 1,
    padding: 10,
  },
  messageContainer: {
    marginVertical: 5,
    padding: 10,
    borderRadius: 10,
    maxWidth: '80%',
  },
  userMessage: {
    backgroundColor: '#007AFF',
    alignSelf: 'flex-end',
  },
  assistantMessage: {
    backgroundColor: 'white',
    alignSelf: 'flex-start',
  },
  messageText: {
    fontSize: 16,
    color: 'black',
  },
  typingText: {
    fontSize: 16,
    color: 'gray',
    fontStyle: 'italic',
  },
  inputContainer: {
    flexDirection: 'row',
    padding: 10,
    backgroundColor: 'white',
    borderTopWidth: 1,
    borderTopColor: '#e0e0e0',
  },
  textInput: {
    flex: 1,
    borderWidth: 1,
    borderColor: '#e0e0e0',
    borderRadius: 20,
    paddingHorizontal: 15,
    paddingVertical: 10,
    marginRight: 10,
    maxHeight: 100,
  },
  sendButton: {
    backgroundColor: '#007AFF',
    paddingHorizontal: 20,
    paddingVertical: 10,
    borderRadius: 20,
    justifyContent: 'center',
  },
  sendButtonText: {
    color: 'white',
    fontWeight: 'bold',
  },
});

// utils/aiPerformance.js
export class AIPerformanceManager {
  constructor() {
    this.modelCache = new Map();
    this.maxCacheSize = 3; // Limit cached models
  }

  async loadModelWithCache(modelUrl, modelKey) {
    if (this.modelCache.has(modelKey)) {
      return this.modelCache.get(modelKey);
    }

    // Remove oldest model if cache is full
    if (this.modelCache.size >= this.maxCacheSize) {
      const firstKey = this.modelCache.keys().next().value;
      const oldModel = this.modelCache.get(firstKey);
      oldModel.dispose(); // Clean up memory
      this.modelCache.delete(firstKey);
    }

    const model = await tf.loadLayersModel(modelUrl);
    this.modelCache.set(modelKey, model);
    return model;
  }

  dispose() {
    // Clean up all cached models
    this.modelCache.forEach(model => model.dispose());
    this.modelCache.clear();
  }

  getMemoryUsage() {
    return {
      numTensors: tf.memory().numTensors,
      numBytes: tf.memory().numBytes,
      numBytesInGPU: tf.memory().numBytesInGPU || 0,
    };
  }

  logMemoryUsage(context = '') {
    const memory = this.getMemoryUsage();
    console.log(`Memory usage ${context}:`, memory);
  }
}

export const aiPerformanceManager = new AIPerformanceManager();

// utils/batchProcessor.js
export class BatchProcessor {
  constructor(batchSize = 5, processingDelay = 1000) {
    this.batchSize = batchSize;
    this.processingDelay = processingDelay;
    this.queue = [];
    this.isProcessing = false;
  }

  addToQueue(item) {
    return new Promise((resolve, reject) => {
      this.queue.push({ item, resolve, reject });
      this.processQueue();
    });
  }

  async processQueue() {
    if (this.isProcessing || this.queue.length === 0) return;

    this.isProcessing = true;

    while (this.queue.length > 0) {
      const batch = this.queue.splice(0, this.batchSize);
      
      try {
        await this.processBatch(batch);
        await new Promise(resolve => setTimeout(resolve, this.processingDelay));
      } catch (error) {
        batch.forEach(({ reject }) => reject(error));
      }
    }

    this.isProcessing = false;
  }

  async processBatch(batch) {
    // Process batch of AI requests
    const promises = batch.map(async ({ item, resolve, reject }) => {
      try {
        const result = await this.processItem(item);
        resolve(result);
      } catch (error) {
        reject(error);
      }
    });

    await Promise.all(promises);
  }

  async processItem(item) {
    // Override this method for specific processing
    throw new Error('processItem must be implemented');
  }
}

// Example usage for image classification
export class ImageClassificationBatchProcessor extends BatchProcessor {
  constructor(model) {
    super(3, 500); // Process 3 images every 500ms
    this.model = model;
  }

  async processItem(imageUri) {
    // Your image classification logic here
    return await this.classifyImage(imageUri);
  }
}

// __tests__/mocks/aiMocks.js
export const mockOpenAIService = {
  generateText: jest.fn(),
  analyzeImage: jest.fn(),
  transcribeAudio: jest.fn(),
};

export const mockTensorFlowModel = {
  predict: jest.fn(),
  executeAsync: jest.fn(),
  dispose: jest.fn(),
};

// Mock responses
export const mockImageClassificationResponse = [
  { probability: 0.85, classId: 281, className: 'tabby cat' },
  { probability: 0.12, classId: 285, className: 'Egyptian cat' },
  { probability: 0.03, classId: 282, className: 'tiger cat' },
];

export const mockTextGenerationResponse = "This is a mock AI-generated response.";

// __tests__/components/AIAssistant.test.js
import React from 'react';
import { render, fireEvent, waitFor } from '@testing-library/react-native';
import { AIAssistant } from '../components/AIAssistant';
import { mockOpenAIService, mockTextGenerationResponse } from './mocks/aiMocks';

jest.mock('../services/openai', () => mockOpenAIService);

describe('AIAssistant', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });

  it('should send message and receive AI response', async () => {
    mockOpenAIService.client = {
      chat: {
        completions: {
          create: jest.fn().mockResolvedValue({
            choices: [{ message: { content: mockTextGenerationResponse } }],
          }),
        },
      },
    };

    const { getByPlaceholderText, getByText } = render(<AIAssistant />);
    
    const input = getByPlaceholderText('Type your message...');
    const sendButton = getByText('Send');

    fireEvent.changeText(input, 'Hello AI');
    fireEvent.press(sendButton);

    await waitFor(() => {
      expect(getByText(mockTextGenerationResponse)).toBeTruthy();
    });
  });

  it('should handle API errors gracefully', async () => {
    mockOpenAIService.client = {
      chat: {
        completions: {
          create: jest.fn().mockRejectedValue(new Error('API Error')),
        },
      },
    };

    const { getByPlaceholderText, getByText } = render(<AIAssistant />);
    
    const input = getByPlaceholderText('Type your message...');
    const sendButton = getByText('Send');

    fireEvent.changeText(input, 'Hello AI');
    fireEvent.press(sendButton);

    await waitFor(() => {
      expect(getByText('Sorry, I encountered an error. Please try again.')).toBeTruthy();
    });
  });
});

// config/aiConfig.js
import Config from 'react-native-config';

export const aiConfig = {
  openai: {
    apiKey: Config.OPENAI_API_KEY,
    baseURL: Config.OPENAI_BASE_URL || 'https://api.openai.com/v1',
    maxRetries: 3,
    timeout: 30000,
  },
  tensorflow: {
    modelCacheSize: 3,
    enableWebGL: true,
    enableCPU: true,
  },
  features: {
    enableLocalInference: Config.ENABLE_LOCAL_INFERENCE === 'true',
    enableCloudFallback: Config.ENABLE_CLOUD_FALLBACK === 'true',
    batchProcessing: Config.ENABLE_BATCH_PROCESSING === 'true',
  },
};

// Environment-specific overrides
if (__DEV__) {
  aiConfig.tensorflow.modelCacheSize = 1; // Reduce memory usage in development
  aiConfig.openai.timeout = 60000; // Longer timeout for debugging
}

// utils/aiErrorHandler.js
export class AIErrorHandler {
  static async handleWithFallback(primaryFn, fallbackFn, context = '') {
    try {
      return await primaryFn();
    } catch (error) {
      console.warn(`AI operation failed in ${context}:`, error);
      
      if (fallbackFn) {
        try {
          return await fallbackFn();
        } catch (fallbackError) {
          console.error(`Fallback also failed in ${context}:`, fallbackError);
          throw fallbackError;
        }
      }
      
      throw error;
    }
  }

  static isNetworkError(error) {
    return error.code === 'NETWORK_ERROR' || 
           error.message.includes('network') ||
           error.message.includes('timeout');
  }

  static isQuotaError(error) {
    return error.code === 'QUOTA_EXCEEDED' ||
           error.status === 429;
  }

  static getRetryDelay(attempt) {
    return Math.min(1000 * Math.pow(2, attempt), 10000); // Exponential backoff
  }
}

// architecture/aiProvider.js
export class AIProvider {
  constructor() {
    this.providers = new Map();
    this.fallbackChain = [];
  }

  registerProvider(name, provider) {
    this.providers.set(name, provider);
  }

  setFallbackChain(chain) {
    this.fallbackChain = chain;
  }

  async execute(operation, ...args) {
    for (const providerName of this.fallbackChain) {
      const provider = this.providers.get(providerName);
      
      if (provider) {
        try {
          return await provider[operation](...args);
        } catch (error) {
          console.warn(`Provider ${providerName} failed:`, error);
          continue;
        }
      }
    }
    
    throw new Error('All AI providers failed');
  }
}

// Usage
const aiProvider = new AIProvider();
aiProvider.registerProvider('openai', openAIService);
aiProvider.registerProvider('local', localTensorFlowService);
aiProvider.setFallbackChain(['local', 'openai']);