feat: Convert image generation and specific service calls to asynchronous operations with timeouts using `AsyncOpenAI` and `asyncio.to_thread`.

services/generator.py

@@ -2058,7 +2058,8 @@ CONCEPT: {concept.get('name', 'Custom Concept')}
         
         # Step 1: Researcher
         print("🔍 Step 1: Researching psychology triggers, angles, and concepts...")
-        researcher_output = third_flow_service.researcher(
+        researcher_output = await asyncio.to_thread(
+            third_flow_service.researcher,
             target_audience=target_audience,
             offer=offer,
             niche=niche_display
@@ -2085,7 +2086,8 @@ CONCEPT: {concept.get('name', 'Custom Concept')}
         # Step 3: Creative Director
         print(f"🎨 Step 3: Creating {num_strategies} creative strategy/strategies...")
         print(f"📋 Parameters: num_strategies={num_strategies}, num_images={num_images}")
-        creative_strategies = third_flow_service.creative_director(
+        creative_strategies = await asyncio.to_thread(
+            third_flow_service.creative_director,
             researcher_output=researcher_output,
             book_knowledge=book_knowledge,
             ads_knowledge=ads_knowledge,

services/image.py

@@ -15,7 +15,8 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 import replicate
 import httpx
-from openai import OpenAI
+from openai import AsyncOpenAI
+import asyncio
 from config import settings
 
 
@@ -141,7 +142,7 @@ class ImageService:
         # Initialize OpenAI client for gpt-image-1.5 support
         self.openai_client = None
         if hasattr(settings, 'openai_api_key') and settings.openai_api_key:
-            self.openai_client = OpenAI(api_key=settings.openai_api_key)
+            self.openai_client = AsyncOpenAI(api_key=settings.openai_api_key)
     
     def _fetch_image(self, url: str) -> Optional[bytes]:
         """Fetch image from URL with retry logic."""
@@ -161,7 +162,7 @@ class ImageService:
                 if attempt == RETRY_ATTEMPTS - 1:
                     print(f"Failed to fetch image from {url}: {e}")
                     return None
-                time.sleep(1)
+                time.sleep(1) # Sync fetch so sync sleep is fine here or use asyncio.sleep
         return None
     
     async def load_image(
@@ -294,15 +295,19 @@ class ImageService:
                 print("Generating image with gpt-image-1.5")
                 size_str = f"{width}x{height}"
                 
-                result = self.openai_client.images.generate(
-                    model="gpt-image-1.5",
-                    prompt=prompt,
-                    quality="auto",
-                    background="auto",
-                    moderation="auto",
-                    size=size_str,
-                    output_format="jpeg",
-                    output_compression=90,
+                # Use a timeout for OpenAI image generation
+                result = await asyncio.wait_for(
+                    self.openai_client.images.generate(
+                        model="gpt-image-1.5",
+                        prompt=prompt,
+                        quality="auto",
+                        background="auto",
+                        moderation="auto",
+                        size=size_str,
+                        output_format="jpeg",
+                        output_compression=90,
+                    ),
+                    timeout=120.0 
                 )
                 
                 if result.data and len(result.data) > 0:
@@ -313,6 +318,9 @@ class ImageService:
                         return image_bytes, "gpt-image-1.5", None
                 
                 raise Exception("No image data returned from OpenAI API")
+            except asyncio.TimeoutError:
+                print("Timed out generating image with gpt-image-1.5")
+                raise Exception("Timeout: Image generation with gpt-image-1.5 took too long")
                 
             except Exception as e:
                 print(f"OpenAI image generation failed: {e}")
@@ -358,8 +366,16 @@ class ImageService:
                 try:
                     print(f"Generating image with {current_model} (attempt {attempt + 1})")
                     
-                    # Use official Replicate client
-                    output = self.client.run(cfg["id"], input=input_data)
+                    # Use official Replicate client - offload blocking call to thread and add timeout
+                    try:
+                        # Wrap the blocking call in a thread and add a 3-minute timeout
+                        output = await asyncio.wait_for(
+                            asyncio.to_thread(self.client.run, cfg["id"], input=input_data),
+                            timeout=180.0  # 3 minutes timeout
+                        )
+                    except asyncio.TimeoutError:
+                        print(f"Timed out generating image with {current_model} after 180 seconds")
+                        raise Exception(f"Timeout: Image generation with {current_model} took too long")
                     
                     # Extract image bytes and URL
                     image_bytes, image_url = self._extract_image_from_output(output)
@@ -372,7 +388,7 @@ class ImageService:
                     last_error = e
                     if attempt < RETRY_ATTEMPTS - 1:
                         print(f"Attempt {attempt + 1} failed: {e}, retrying...")
-                        time.sleep(2 ** attempt)  # Exponential backoff
+                        await asyncio.sleep(2 ** attempt)  # Exponential backoff (use await for async sleep)
                     continue
             
             # Model failed, try next in fallback chain
@@ -409,7 +425,6 @@ class ImageService:
             except Exception as e:
                 last_error = e
                 if attempt < max_retries:
-                    import asyncio
                     await asyncio.sleep(2)
                     continue