v1.17: Fix 60-second VNet timeout with polling-based content generation

- Changed from SSE streaming to polling architecture for content generation
- Added /api/generate/start endpoint that returns task_id immediately
- Added /api/generate/status/<task_id> endpoint for polling results
- Frontend now polls every 1 second instead of waiting on SSE stream
- Each poll request completes quickly, avoiding VNet integration timeout
- Added background task execution with in-memory task storage
- Added proper async client cleanup in image generation
- Preserved original /api/generate SSE endpoint for backward compatibility
- Updated server.js with extended timeouts and keep-alive settings

Root cause: Azure VNet integration has a hardcoded 60-second idle timeout
that killed SSE connections before gpt-image-1 could complete (40-90s).
The polling approach bypasses this by using quick request/response cycles.

Author: hunterjam

content-gen/src/app.py

@@ -1,4 +1,3 @@
-"""
 """Image Content Agent - Generates marketing images via DALL-E 3 or gpt-image-1.
 
 Provides the generate_image function used by the orchestrator
@@ -196,24 +195,28 @@ async def _generate_dalle_image(
             api_version=app_settings.azure_openai.preview_api_version,
         )
 
-        response = await client.images.generate(
-            model=app_settings.azure_openai.dalle_model,
-            prompt=full_prompt,
-            size=size,
-            quality=quality,
-            n=1,
-            response_format="b64_json"
-        )
-        
-        image_data = response.data[0]
-        
-        return {
-            "success": True,
-            "image_base64": image_data.b64_json,
-            "prompt_used": full_prompt,
-            "revised_prompt": getattr(image_data, 'revised_prompt', None),
-            "model": "dall-e-3",
-        }
+        try:
+            response = await client.images.generate(
+                model=app_settings.azure_openai.dalle_model,
+                prompt=full_prompt,
+                size=size,
+                quality=quality,
+                n=1,
+                response_format="b64_json"
+            )
+            
+            image_data = response.data[0]
+            
+            return {
+                "success": True,
+                "image_base64": image_data.b64_json,
+                "prompt_used": full_prompt,
+                "revised_prompt": getattr(image_data, 'revised_prompt', None),
+                "model": "dall-e-3",
+            }
+        finally:
+            # Properly close the async client to avoid unclosed session warnings
+            await client.close()
 
     except Exception as e:
         logger.exception(f"Error generating DALL-E image: {e}")
@@ -327,25 +330,50 @@ async def _generate_gpt_image(
             api_version=app_settings.azure_openai.preview_api_version,
         )
 
-        # gpt-image-1 API call
-        response = await client.images.generate(
-            model="gpt-image-1",
-            prompt=full_prompt,
-            size=size,
-            quality=quality,
-            n=1,
-            response_format="b64_json"
-        )
-        
-        image_data = response.data[0]
-        
-        return {
-            "success": True,
-            "image_base64": image_data.b64_json,
-            "prompt_used": full_prompt,
-            "revised_prompt": getattr(image_data, 'revised_prompt', None),
-            "model": "gpt-image-1",
-        }
+        try:
+            # gpt-image-1 API call - note: gpt-image-1 doesn't support response_format parameter
+            # It returns base64 data directly in the response
+            response = await client.images.generate(
+                model="gpt-image-1",
+                prompt=full_prompt,
+                size=size,
+                quality=quality,
+                n=1,
+            )
+            
+            image_data = response.data[0]
+            
+            # gpt-image-1 returns b64_json directly without needing response_format parameter
+            image_base64 = getattr(image_data, 'b64_json', None)
+            
+            # If no b64_json, try to get URL and fetch the image
+            if not image_base64 and hasattr(image_data, 'url') and image_data.url:
+                import aiohttp
+                async with aiohttp.ClientSession() as session:
+                    async with session.get(image_data.url) as resp:
+                        if resp.status == 200:
+                            import base64
+                            image_bytes = await resp.read()
+                            image_base64 = base64.b64encode(image_bytes).decode('utf-8')
+            
+            if not image_base64:
+                return {
+                    "success": False,
+                    "error": "No image data returned from gpt-image-1",
+                    "prompt_used": full_prompt,
+                    "model": "gpt-image-1",
+                }
+            
+            return {
+                "success": True,
+                "image_base64": image_base64,
+                "prompt_used": full_prompt,
+                "revised_prompt": getattr(image_data, 'revised_prompt', None),
+                "model": "gpt-image-1",
+            }
+        finally:
+            # Properly close the async client to avoid unclosed session warnings
+            await client.close()
 
     except Exception as e:
         logger.exception(f"Error generating gpt-image-1 image: {e}")

content-gen/src/backend/agents/image_content_agent.py

@@ -803,9 +803,38 @@ async def generate_content(
                     )
 
                     if image_result.get("success"):
-                        results["image_base64"] = image_result.get("image_base64")
+                        image_base64 = image_result.get("image_base64")
                         results["image_revised_prompt"] = image_result.get("revised_prompt")
                         logger.info("DALL-E image generated successfully")
+                        
+                        # Save to blob storage immediately to avoid returning huge base64
+                        # This prevents timeout issues with large responses
+                        try:
+                            from backend.services.blob_service import BlobStorageService
+                            import os
+                            from datetime import datetime
+                            
+                            blob_service = BlobStorageService()
+                            # Generate a unique conversation-like ID for this generation
+                            gen_id = datetime.utcnow().strftime("%Y%m%d%H%M%S")
+                            logger.info(f"Saving image to blob storage (size: {len(image_base64)} bytes)...")
+                            
+                            blob_url = await blob_service.save_generated_image(
+                                conversation_id=f"gen_{gen_id}",
+                                image_base64=image_base64
+                            )
+                            
+                            if blob_url:
+                                # Store the blob URL - will be converted to proxy URL by app.py
+                                results["image_blob_url"] = blob_url
+                                logger.info(f"Image saved to blob: {blob_url}")
+                            else:
+                                # Fallback to base64 if blob save fails
+                                results["image_base64"] = image_base64
+                                logger.warning("Blob save returned None, falling back to base64")
+                        except Exception as blob_error:
+                            logger.warning(f"Failed to save to blob, falling back to base64: {blob_error}")
+                            results["image_base64"] = image_base64
                     else:
                         logger.warning(f"DALL-E image generation failed: {image_result.get('error')}")
                         results["image_error"] = image_result.get("error")
@@ -855,6 +884,12 @@ async def generate_content(
             logger.exception(f"Error generating content: {e}")
             results["error"] = str(e)
 
+        # Log results summary before returning
+        logger.info(f"Orchestrator returning results with keys: {list(results.keys())}")
+        has_image = bool(results.get("image_base64"))
+        image_size = len(results.get("image_base64", "")) if has_image else 0
+        logger.info(f"Orchestrator results: has_image={has_image}, image_size={image_size}, has_error={bool(results.get('error'))}")
+        
         return results
 
 

content-gen/src/backend/orchestrator.py

@@ -1,12 +1,21 @@
 const express = require('express');
 const { createProxyMiddleware } = require('http-proxy-middleware');
 const path = require('path');
+const http = require('http');
 
 const app = express();
 const PORT = process.env.PORT || 8080;
 
 // Backend API URL (ACI private IP in VNet)
-const BACKEND_URL = process.env.BACKEND_URL || 'http://10.0.4.4:8000';
+const BACKEND_URL = process.env.BACKEND_URL || 'http://10.0.4.5:8000';
+
+// Create HTTP agent with extended keep-alive timeout for long-running SSE connections
+const httpAgent = new http.Agent({
+    keepAlive: true,
+    keepAliveMsecs: 300000,  // 5 minutes keep-alive
+    maxSockets: 100,
+    timeout: 600000  // 10 minutes socket timeout
+});
 
 // Proxy API requests to backend
 app.use('/api', createProxyMiddleware({
@@ -15,22 +24,30 @@ app.use('/api', createProxyMiddleware({
     pathRewrite: {
         '^/api': '/api'
     },
-    // Increase timeout for long-running requests (5 minutes)
-    proxyTimeout: 300000,
-    timeout: 300000,
+    agent: httpAgent,
+    // Increase timeout for long-running requests (10 minutes)
+    proxyTimeout: 600000,
+    timeout: 600000,
     // Support streaming responses (SSE)
     onProxyRes: (proxyRes, req, res) => {
         // Disable buffering for streaming responses
         if (proxyRes.headers['content-type']?.includes('text/event-stream')) {
             res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
             res.setHeader('X-Accel-Buffering', 'no');
+            res.setHeader('Connection', 'keep-alive');
             res.flushHeaders();
         }
+        // Log response for debugging
+        console.log(`Proxy response: ${req.method} ${req.path} -> ${proxyRes.statusCode}`);
+    },
+    onProxyReq: (proxyReq, req, res) => {
+        // Log request for debugging
+        console.log(`Proxy request: ${req.method} ${req.path}`);
     },
     onError: (err, req, res) => {
-        console.error('Proxy error:', err);
+        console.error('Proxy error:', err.message);
         if (!res.headersSent) {
-            res.status(502).json({ error: 'Backend service unavailable' });
+            res.status(502).json({ error: 'Backend service unavailable', details: err.message });
         }
     }
 }));
@@ -43,7 +60,15 @@ app.get('*', (req, res) => {
     res.sendFile(path.join(__dirname, 'static', 'index.html'));
 });
 
-app.listen(PORT, () => {
+// Create server with extended timeouts for SSE
+const server = app.listen(PORT, () => {
     console.log(`Frontend server running on port ${PORT}`);
     console.log(`Proxying API requests to ${BACKEND_URL}`);
 });
+
+// Extend server timeouts for long-running SSE connections
+server.keepAliveTimeout = 620000;  // 10 minutes + buffer
+server.headersTimeout = 630000;    // Slightly higher than keepAliveTimeout
+server.timeout = 0;                // Disable request timeout (handled by proxy)
+
+console.log('Server timeouts configured for SSE streaming');

content-gen/src/frontend-server/frontend-deploy.zip

@@ -5,7 +5,7 @@
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Content Generation Accelerator</title>
-    <script type="module" crossorigin src="/assets/index-BwzhOPU_.js"></script>
+    <script type="module" crossorigin src="/assets/index-CQ3D5apY.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-D9ems1Py.css">
   </head>
   <body>

content-gen/src/frontend-server/server.js

@@ -154,7 +154,8 @@ export async function* streamGenerateContent(
   conversationId?: string,
   userId?: string
 ): AsyncGenerator<AgentResponse> {
-  const response = await fetch(`${API_BASE}/generate`, {
+  // Use polling-based approach for reliability with long-running tasks
+  const startResponse = await fetch(`${API_BASE}/generate/start`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({
@@ -166,40 +167,68 @@ export async function* streamGenerateContent(
     }),
   });
 
-  if (!response.ok) {
-    throw new Error(`Content generation failed: ${response.statusText}`);
-  }
-
-  const reader = response.body?.getReader();
-  if (!reader) {
-    throw new Error('No response body');
+  if (!startResponse.ok) {
+    throw new Error(`Content generation failed to start: ${startResponse.statusText}`);
   }
 
-  const decoder = new TextDecoder();
-  let buffer = '';
-
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split('\n\n');
-    buffer = lines.pop() || '';
-
-    for (const line of lines) {
-      if (line.startsWith('data: ')) {
-        const data = line.slice(6);
-        if (data === '[DONE]') {
-          return;
-        }
-        try {
-          yield JSON.parse(data) as AgentResponse;
-        } catch {
-          console.error('Failed to parse SSE data:', data);
-        }
+  const startData = await startResponse.json();
+  const taskId = startData.task_id;
+  
+  console.log(`Generation started with task ID: ${taskId}`);
+  
+  // Yield initial status
+  yield {
+    type: 'status',
+    content: 'Generation started...',
+    is_final: false,
+  } as AgentResponse;
+  
+  // Poll for completion
+  let attempts = 0;
+  const maxAttempts = 120; // 2 minutes max with 1-second polling
+  const pollInterval = 1000; // 1 second
+  
+  while (attempts < maxAttempts) {
+    await new Promise(resolve => setTimeout(resolve, pollInterval));
+    attempts++;
+    
+    try {
+      const statusResponse = await fetch(`${API_BASE}/generate/status/${taskId}`);
+      if (!statusResponse.ok) {
+        throw new Error(`Failed to get task status: ${statusResponse.statusText}`);
+      }
+      
+      const statusData = await statusResponse.json();
+      console.log(`Task ${taskId} status: ${statusData.status} (attempt ${attempts})`);
+      
+      if (statusData.status === 'completed') {
+        // Yield the final result
+        yield {
+          type: 'agent_response',
+          content: JSON.stringify(statusData.result),
+          is_final: true,
+        } as AgentResponse;
+        return;
+      } else if (statusData.status === 'failed') {
+        throw new Error(statusData.error || 'Generation failed');
+      } else if (statusData.status === 'running' && attempts % 5 === 0) {
+        // Send heartbeat status every 5 seconds
+        yield {
+          type: 'heartbeat',
+          content: `Generating content... (${attempts}s)`,
+          is_final: false,
+        } as AgentResponse;
+      }
+    } catch (error) {
+      console.error(`Error polling task ${taskId}:`, error);
+      // Continue polling on transient errors
+      if (attempts >= maxAttempts) {
+        throw error;
       }
     }
   }
+  
+  throw new Error('Generation timed out after 2 minutes');
 }
 
 /**

content-gen/src/frontend-server/static/index.html

@@ -184,10 +184,9 @@ export function ProductReview({
               <>
                 <strong>Looking good!</strong> You can continue to refine your selection:
                 <ul style={{ margin: '8px 0 0 0', paddingLeft: '16px' }}>
-                  <li>"Add the Arctic Frost paint to the selection"</li>
+                  <li>"Add the Blue Ash paint to the selection"</li>
                   <li>"Remove the second product"</li>
                   <li>"Show me more blue paints"</li>
-                  <li>"Replace with products for outdoor use"</li>
                 </ul>
                 <div style={{ marginTop: '8px' }}>
                   When you're satisfied, click <strong>Generate Content</strong> to create your marketing materials.
@@ -197,10 +196,9 @@ export function ProductReview({
               <>
                 <strong>Let's find the right products!</strong> Try saying:
                 <ul style={{ margin: '8px 0 0 0', paddingLeft: '16px' }}>
-                  <li>"Show me exterior paints"</li>
-                  <li>"I need paint for a kitchen renovation"</li>
+                  <li>"Show me what paints are available"</li>
                   <li>"Find products with blue tones"</li>
-                  <li>"Select SnowVeil and Ocean Mist"</li>
+                  <li>"Select Snow Veil and Silver Shore"</li>
                 </ul>
               </>
             )}