feat: implement DALL-E fallback mechanism in image generation service to handle API failures and enhance error logging

backend/app/main.py

@@ -72,7 +72,7 @@ async def health_check():
 
 
 # OpenAI connection test endpoint
-@app.get("/test-openai")
+@app.get("/api/test-openai")
 async def test_openai():
     """Test OpenAI connection without making actual API calls"""
     try:

backend/app/services/image_service.py

@@ -40,6 +40,57 @@ class ImageGenerationService:
         if not os.path.exists(self.output_dir):
             os.makedirs(self.output_dir)
 
+    async def _fallback_to_dalle(self, prompt: str, size: str, n: int, model: str) -> dict:
+        """
+        Fallback to regular DALL-E when responses API is blocked
+        This sacrifices reference image capability but ensures the app works on Hugging Face
+        """
+        try:
+            logger.info("Using DALL-E fallback (reference image will be ignored)")
+
+            response = self.client.images.generate(
+                model=model,
+                prompt=prompt,
+                n=n,
+                size=size,
+                response_format="b64_json",
+            )
+
+            generated_filenames = []
+
+            for i, image_data in enumerate(response.data):
+                try:
+                    image_bytes = base64.b64decode(image_data.b64_json)
+
+                    # Generate unique filename and save
+                    filename = f"{uuid.uuid4()}.png"
+                    filepath = os.path.join(self.output_dir, filename)
+
+                    with open(filepath, "wb") as f:
+                        f.write(image_bytes)
+
+                    generated_filenames.append(filename)
+                    logger.info(f"Fallback image {i+1} saved successfully: {filename}")
+
+                except Exception as e:
+                    logger.warning(f"Failed to save fallback image {i+1}: {str(e)}")
+                    continue
+
+            if generated_filenames:
+                return {
+                    "success": True,
+                    "message": f"Generated {len(generated_filenames)}/{n} images using DALL-E fallback (reference image ignored due to network restrictions)",
+                    "filename": generated_filenames[0],
+                    "filenames": generated_filenames,
+                    "count": len(generated_filenames),
+                }
+            else:
+                raise Exception("Fallback also failed to generate any images")
+
+        except Exception as e:
+            logger.error(f"Fallback to DALL-E also failed: {str(e)}")
+            raise Exception(f"Both responses API and DALL-E fallback failed: {str(e)}")
+
     async def generate_image(
         self,
         prompt: str,
@@ -153,9 +204,9 @@ class ImageGenerationService:
                         continue
 
                 if not generated_filenames:
-                    raise Exception(
-                        "Failed to generate any images - all attempts returned text or failed"
-                    )
+                    # If responses API failed due to network restrictions, try fallback to regular DALL-E
+                    logger.warning("Responses API failed, attempting fallback to regular DALL-E")
+                    return await self._fallback_to_dalle(prompt, size, n, model)
 
                 logger.info(
                     f"Successfully generated {len(generated_filenames)}/{n} images"