Fix production AI errors with timeout and enhanced error handling

CRITICAL PRODUCTION FIXES:
- Add 25-second timeout protection for serverless functions
- Enhanced error handling for API keys, timeouts, rate limits
- Better production error messages for users
- Added Promise.race() to prevent hanging requests

NEW DEBUG ENDPOINT:
- /api/debug-ai for production diagnostics
- Environment variable verification
- Direct API connectivity testing
- Real-time system health monitoring

ENHANCED ERROR HANDLING:
- Specific messages for API key issues
- Timeout error detection and reporting
- Rate limiting error handling
- Network connectivity error messages
- All models failed scenario handling

FILES MODIFIED:
- src/app/actions.ts - Timeout protection and error handling
- src/app/api/debug-ai/route.ts - New diagnostic endpoint
- PRODUCTION_AI_FIXES.md - Comprehensive fix documentation

PRODUCTION READINESS:
- Prevents serverless function timeouts
- Clear error messages for troubleshooting
- Real-time diagnostic capabilities
- Enhanced user experience during failures

Author: Your Name

PRODUCTION_AI_FIXES.md

@@ -0,0 +1,101 @@
+# Production AI Error Fixes 🔧
+
+## Issues Identified & Fixed
+
+### 1. Serverless Function Timeout
+**Problem**: AI requests might timeout in Netlify's 30-second serverless function limit
+**Solution**: Added 25-second timeout with Promise.race() to prevent hanging requests
+```typescript
+const timeoutPromise = new Promise<never>((_, reject) => {
+  setTimeout(() => reject(new Error('AI request timeout after 25 seconds')), 25000);
+});
+const result = await Promise.race([aiPromise, timeoutPromise]);
+```
+
+### 2. Enhanced Error Handling
+**Problem**: Generic error messages don't help users understand production issues
+**Solution**: Added specific error handling for common production scenarios:
+- API key issues
+- Timeout errors  
+- Rate limiting
+- Network connectivity
+- All models failing
+
+### 3. Debug Endpoint Added
+**Problem**: Hard to diagnose AI issues in production
+**Solution**: Created `/api/debug-ai` endpoint to check:
+- Environment variables status
+- Direct API connectivity
+- System information
+- Real-time AI service health
+
+## Files Modified
+
+### `src/app/actions.ts`
+- ✅ Added timeout protection (25 seconds)
+- ✅ Enhanced error handling with specific messages
+- ✅ Better production error reporting
+
+### `src/app/api/debug-ai/route.ts` (NEW)
+- ✅ Production diagnostic endpoint
+- ✅ Environment variable checker
+- ✅ Direct API connectivity test
+- ✅ System health monitoring
+
+## Common Production Issues & Solutions
+
+### Environment Variables
+**Issue**: Environment variables not set in Netlify
+**Check**: Visit `/api/debug-ai` to verify all variables are set
+**Fix**: Add all required variables in Netlify dashboard:
+- `GROQ_API_KEY`
+- `HUGGINGFACE_API_KEY` 
+- `GOOGLE_API_KEY`
+- `NEXT_PUBLIC_FIREBASE_API_KEY`
+
+### API Key Issues
+**Issue**: Invalid or expired API keys
+**Check**: Debug endpoint tests direct API connectivity
+**Fix**: Regenerate API keys from provider dashboards
+
+### Rate Limiting
+**Issue**: Too many requests to AI providers
+**Check**: Error messages will indicate rate limiting
+**Fix**: Implement request queuing or use multiple keys
+
+### Network Timeouts
+**Issue**: Slow network in serverless environment
+**Check**: Timeout errors in logs
+**Fix**: Already implemented 25-second timeout
+
+## Testing Production AI
+
+### 1. Health Check
+```bash
+curl https://your-app.netlify.app/api/debug-ai
+```
+
+### 2. Direct Chat Test
+Use the chat interface with a simple message like "Hello"
+
+### 3. Monitor Netlify Function Logs
+Check for specific error messages in Netlify dashboard
+
+## Deployment Instructions
+
+1. **Push these fixes to GitHub**
+2. **Deploy to Netlify**
+3. **Set environment variables in Netlify dashboard**
+4. **Test with `/api/debug-ai` endpoint**
+5. **Monitor function logs for any remaining issues**
+
+## Expected Results
+
+After these fixes:
+- ✅ Better timeout handling prevents hanging requests
+- ✅ Clear error messages help identify specific issues
+- ✅ Debug endpoint provides real-time diagnostics
+- ✅ Enhanced error recovery and user feedback
+- ✅ Production-ready AI system with proper monitoring
+
+The AI system should now work reliably in production with proper error handling and diagnostics! 🚀

src/app/actions.ts

@@ -15,12 +15,36 @@ import type {
 
 function handleGenkitError(error: unknown): {error: string} {
   const message = error instanceof Error ? error.message : String(error);
-  console.error('Genkit flow failed:', error);
+  console.error('AI processing failed:', error);
 
-  // Check for the specific API key error and provide a helpful message.
+  // Check for specific error types and provide helpful messages
   if (message.includes('API key') || message.includes('API_KEY')) {
     return {
-      error: `AI processing failed. Your Groq API key is missing. Please create a free key at https://console.groq.com/keys and add it to the GROQ_API_KEY variable in your .env file.`,
+      error: `AI processing failed. API key is missing or invalid. Please check your environment variables.`,
+    };
+  }
+  
+  if (message.includes('timeout') || message.includes('TIMEOUT')) {
+    return {
+      error: `AI processing timed out. The request took too long to complete. Please try again.`,
+    };
+  }
+  
+  if (message.includes('rate limit') || message.includes('quota')) {
+    return {
+      error: `AI service is temporarily busy due to high demand. Please try again in a moment.`,
+    };
+  }
+  
+  if (message.includes('All models failed')) {
+    return {
+      error: `All AI models are currently unavailable. This may be due to high demand or maintenance. Please try again later.`,
+    };
+  }
+  
+  if (message.includes('Network') || message.includes('fetch')) {
+    return {
+      error: `Network error occurred while connecting to AI services. Please check your connection and try again.`,
     };
   }
 
@@ -37,6 +61,11 @@ export async function generateResponse(
     // This avoids the localhost URL issue and is more efficient
     const { generateWithSmartFallback } = await import('@/ai/smart-fallback');
 
+    // Add timeout for production serverless functions
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      setTimeout(() => reject(new Error('AI request timeout after 25 seconds')), 25000);
+    });
+    
     // Build system prompt based on settings
     const getToneInstructions = (tone: string) => {
       switch (tone) {
@@ -99,8 +128,8 @@ ${getTechnicalInstructions(input.settings.technicalLevel)}
       preferredModelId = input.settings.model;
     }
 
-    // Use smart fallback system directly
-    const result = await generateWithSmartFallback({
+    // Use smart fallback system directly with timeout
+    const aiPromise = generateWithSmartFallback({
       prompt: input.message,
       systemPrompt,
       history: convertedHistory,
@@ -114,6 +143,8 @@ ${getTechnicalInstructions(input.settings.technicalLevel)}
       },
     });
 
+    const result = await Promise.race([aiPromise, timeoutPromise]);
+
     return {
       content: result.response.text,
       modelUsed: result.modelUsed,

src/app/api/debug-ai/route.ts

@@ -0,0 +1,74 @@
+import { NextResponse } from 'next/server';
+
+/**
+ * AI Debug endpoint for production diagnostics
+ * Tests environment variables and API connectivity
+ */
+export async function GET() {
+  try {
+    // Check environment variables
+    const envCheck = {
+      groq: !!process.env.GROQ_API_KEY,
+      huggingface: !!process.env.HUGGINGFACE_API_KEY,
+      google: !!process.env.GOOGLE_API_KEY,
+      firebase: !!process.env.NEXT_PUBLIC_FIREBASE_API_KEY,
+    };
+
+    // Test basic Groq API connectivity
+    let groqTest: { working: boolean; error: string | null } = { working: false, error: null };
+    if (process.env.GROQ_API_KEY) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 10000);
+        
+        const response = await fetch('https://api.groq.com/openai/v1/chat/completions', {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${process.env.GROQ_API_KEY}`,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            model: 'llama-3.1-8b-instant',
+            messages: [{ role: 'user', content: 'Test' }],
+            max_tokens: 10,
+            temperature: 0.1
+          }),
+          signal: controller.signal
+        });
+        
+        clearTimeout(timeoutId);
+        
+        if (response.ok) {
+          groqTest.working = true;
+        } else {
+          const errorText = await response.text();
+          groqTest.error = `HTTP ${response.status}: ${errorText}`;
+        }
+      } catch (error) {
+        groqTest.error = error instanceof Error ? error.message : 'Unknown error';
+      }
+    }
+
+    return NextResponse.json({
+      status: 'debug-ready',
+      timestamp: new Date().toISOString(),
+      environment: process.env.NODE_ENV,
+      platform: process.platform,
+      nodeVersion: process.version,
+      envVariables: envCheck,
+      groqApiTest: groqTest,
+      message: 'AI Debug endpoint working - all systems checked'
+    });
+
+  } catch (error) {
+    console.error('Debug AI endpoint error:', error);
+    return NextResponse.json(
+      { 
+        status: 'error',
+        error: error instanceof Error ? error.message : 'Unknown error',
+        timestamp: new Date().toISOString()
+      },
+      { status: 500 }
+    );
+  }
+}