background tasks for quicker return

routers/user_models.py

@@ -149,80 +149,39 @@ async def _check_and_decrement_credits(user_id: str):
     new_credits = credit_data["num_of_available_gens"] - 1
     supabase.from_("User_Credit_Account").update({"num_of_available_gens": new_credits}).eq("user_id", user_id).execute()
 
-@router.post("/text-to-3d")
-async def text_to_3d(prompt: TextPrompt, current_user: User = Depends(get_current_active_user)):
-    """
-    Create a Meshy Text-to-3D generation job.
-
-    The endpoint performs the minimum work required to *start* the generation:
-    1. Persists an initial *Generated_Models* row (status = IN_PROGRESS).
-    2. Optionally reframes the user prompt via OpenAI.
-    3. Submits the request to Meshy and stores the returned task id.
-
-    No long-running background polling is started here – the front-end must
-    later call the */refresh/{generated_model_id}* endpoint to sync the final
-    status back into Supabase.
-    """
-
-    # Credit check and decrement
-    await _check_and_decrement_credits(current_user.id)
-
-    generated_model_id: Optional[int] = None
-
-    # 1. Insert initial DB record
+# Background task for text-to-3d processing
+async def _process_text_to_3d_background(generated_model_id: int, user_id: str, original_prompt: str):
+    """Background task to handle OpenAI reframing and Meshy API call for text-to-3d"""
     try:
-        insert_res = supabase.from_("Generated_Models").insert({
-            "status": "IN_PROGRESS",
-            "user_id": current_user.id,
-            "meshy_api_job_id": None,
-            "model_name": f"{prompt.text[:50]}{'...' if len(prompt.text) > 50 else ''}",
-            "prompts_and_models_config": {
-                "generation_type": "text_to_3d",
-                "original_prompt": prompt.text,
-                "status": "initializing",
-                "stage": "reframing_prompt",
-            },
-        }).execute()
-        generated_model_id = insert_res.data[0]["generated_model_id"] if insert_res.data else None
-    except Exception as ex:
-        logging.error(f"Failed to create initial model DB record: {ex}")
-
-    # 2. Reframe prompt via OpenAI
-    if True:
+        # 1. Reframe prompt via OpenAI
+        reframed_prompt = original_prompt  # Default fallback
+        
         openai_key = os.getenv("OPENAI_API_KEY")
-        if not openai_key:
-            raise HTTPException(status_code=500, detail="OPENAI_API_KEY not configured")
-
-        try:
-            async with httpx.AsyncClient(timeout=30.0) as client:
-                oai_resp = await client.post(
-                    "https://api.openai.com/v1/chat/completions",
-                    headers={"Authorization": f"Bearer {openai_key}"},
-                    json={
-                        "model": "gpt-4o-mini",
-                        "messages": [
-                            {"role": "system", "content": "REPLY ONLY WITH NEW PROMPT, no other text. IF USER PROMPT CONTAINS HARMFUL CONTENT, CHANGE IT TO SOMETHING SAFE and somewhat related. Rephrase the user description to simple and short."},
-                            {"role": "user", "content": prompt.text},
-                        ],
-                    },
-                )
-        except Exception as ex:
-            raise HTTPException(status_code=502, detail=f"Failed to contact OpenAI: {ex}")
-
-        if oai_resp.status_code != 200:
-            raise HTTPException(status_code=oai_resp.status_code, detail=oai_resp.text)
-
-        reframed_prompt = oai_resp.json()["choices"][0]["message"]["content"]
-
-    reframed_prompt = prompt.text
-
-    # 3. Update DB with reframed prompt (if record exists)
-    if generated_model_id:
+        if openai_key:
+            try:
+                async with httpx.AsyncClient(timeout=30.0) as client:
+                    oai_resp = await client.post(
+                        "https://api.openai.com/v1/chat/completions",
+                        headers={"Authorization": f"Bearer {openai_key}"},
+                        json={
+                            "model": "gpt-4o-mini",
+                            "messages": [
+                                {"role": "system", "content": "REPLY ONLY WITH NEW PROMPT, no other text. IF USER PROMPT CONTAINS HARMFUL CONTENT, CHANGE IT TO SOMETHING SAFE and somewhat related. Rephrase the user description to simple and short."},
+                                {"role": "user", "content": original_prompt},
+                            ],
+                        },
+                    )
+                    if oai_resp.status_code == 200:
+                        reframed_prompt = oai_resp.json()["choices"][0]["message"]["content"]
+            except Exception as ex:
+                logging.warning(f"OpenAI reframing failed, using original prompt: {ex}")
+
+        # 2. Update DB with reframed prompt
         try:
             supabase.from_("Generated_Models").update({
                 "prompts_and_models_config": {
                     "generation_type": "text_to_3d",
-                    "original_prompt": prompt.text,
+                    "original_prompt": original_prompt,
                     "reframed_prompt": reframed_prompt,
                     "status": "processing",
                     "stage": "creating_3d_model",
@@ -231,62 +190,161 @@ async def text_to_3d(prompt: TextPrompt, current_user: User = Depends(get_curren
         except Exception as ex:
             logging.warning(f"Failed to update DB with reframed prompt: {ex}")
 
-    # 4. Send request to Meshy
-    meshy_key = os.getenv("MESHY_API_KEY")
-    if not meshy_key:
-        raise HTTPException(status_code=500, detail="MESHY_API_KEY not configured")
+        # 3. Send request to Meshy
+        meshy_key = os.getenv("MESHY_API_KEY")
+        if not meshy_key:
+            logging.error("MESHY_API_KEY not configured")
+            return
 
-    meshy_payload = {
-        "mode": "preview",
-        "prompt": reframed_prompt,
-        "ai_model": "meshy-5",
-    }
+        meshy_payload = {
+            "mode": "preview",
+            "prompt": reframed_prompt,
+            "ai_model": "meshy-5",
+        }
 
-    async with httpx.AsyncClient(timeout=30.0) as client:
-        meshy_resp = await client.post(
-            "https://api.meshy.ai/openapi/v2/text-to-3d",
-            headers={"Authorization": f"Bearer {meshy_key}"},
-            json=meshy_payload,
-        )
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            meshy_resp = await client.post(
+                "https://api.meshy.ai/openapi/v2/text-to-3d",
+                headers={"Authorization": f"Bearer {meshy_key}"},
+                json=meshy_payload,
+            )
 
-    if meshy_resp.status_code not in (200, 201, 202):
-        raise HTTPException(status_code=meshy_resp.status_code, detail=meshy_resp.text)
+        if meshy_resp.status_code not in (200, 201, 202):
+            logging.error(f"Meshy API failed: {meshy_resp.status_code} - {meshy_resp.text}")
+            return
 
-    meshy_data = meshy_resp.json()
-    meshy_task_id = meshy_data.get("result") or meshy_data.get("id") or meshy_data.get("task_id")
+        meshy_data = meshy_resp.json()
+        meshy_task_id = meshy_data.get("result") or meshy_data.get("id") or meshy_data.get("task_id")
 
-    if not meshy_task_id:
-        raise HTTPException(status_code=500, detail="No task ID received from Meshy API")
+        if not meshy_task_id:
+            logging.error("No task ID received from Meshy API")
+            return
 
-    # 5. Finalize DB record
-    if generated_model_id:
+        # 4. Finalize DB record
         try:
             supabase.from_("Generated_Models").update({
                 "meshy_api_job_id": meshy_task_id,
                 "prompts_and_models_config": {
                     "generation_type": "text_to_3d",
-                    "original_prompt": prompt.text,
+                    "original_prompt": original_prompt,
                     "reframed_prompt": reframed_prompt,
                     "status": "processing",
                     "stage": "generating",
                     "meshy_response": meshy_data,
                 },
             }).eq("generated_model_id", generated_model_id).execute()
+            logging.info(f"Successfully started text-to-3d generation for model {generated_model_id}")
+        except Exception as ex:
+            logging.error(f"Failed to update DB with Meshy taskId: {ex}")
+
+    except Exception as ex:
+        logging.error(f"Background processing failed for text-to-3d model {generated_model_id}: {ex}")
+
+# Background task for image-to-3d processing
+async def _process_image_to_3d_background(generated_model_id: int, payload: Dict[str, Any], generation_type: str):
+    """Background task to handle Meshy API call for image-to-3d"""
+    try:
+        # Send request to Meshy
+        meshy_key = os.getenv("MESHY_API_KEY")
+        if not meshy_key:
+            logging.error("MESHY_API_KEY not configured")
+            return
+
+        # Determine the correct Meshy endpoint
+        if generation_type == "multi_image_to_3d":
+            meshy_endpoint = "https://api.meshy.ai/openapi/v1/multi-image-to-3d"
+        else:
+            meshy_endpoint = "https://api.meshy.ai/openapi/v1/image-to-3d"
+
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            meshy_resp = await client.post(
+                meshy_endpoint,
+                headers={"Authorization": f"Bearer {meshy_key}"},
+                json=payload,
+            )
+
+        if meshy_resp.status_code not in (200, 201, 202):
+            logging.error(f"Meshy API failed: {meshy_resp.status_code} - {meshy_resp.text}")
+            return
+
+        meshy_data = meshy_resp.json()
+        meshy_task_id = meshy_data.get("result") or meshy_data.get("id") or meshy_data.get("task_id")
+
+        if not meshy_task_id:
+            logging.error("No task ID received from Meshy API")
+            return
+
+        # Update DB record with Meshy task ID
+        try:
+            # Get current config to preserve it
+            current_record = supabase.from_("Generated_Models").select("prompts_and_models_config").eq("generated_model_id", generated_model_id).single().execute()
+            current_config = current_record.data.get("prompts_and_models_config", {}) if current_record.data else {}
+            
+            # Update config with Meshy response
+            updated_config = {**current_config}
+            updated_config.update({
+                "status": "processing",
+                "stage": "generating",
+                "meshy_response": meshy_data,
+            })
+
+            supabase.from_("Generated_Models").update({
+                "meshy_api_job_id": meshy_task_id,
+                "prompts_and_models_config": updated_config,
+            }).eq("generated_model_id", generated_model_id).execute()
+            
+            logging.info(f"Successfully started {generation_type} generation for model {generated_model_id}")
         except Exception as ex:
-            logging.warning(f"Failed to update DB with Meshy taskId: {ex}")
+            logging.error(f"Failed to update DB with Meshy taskId: {ex}")
+
+    except Exception as ex:
+        logging.error(f"Background processing failed for {generation_type} model {generated_model_id}: {ex}")
+
+@router.post("/text-to-3d")
+async def text_to_3d(prompt: TextPrompt, background_tasks: BackgroundTasks, current_user: User = Depends(get_current_active_user)):
+    """
+    Create a Meshy Text-to-3D generation job.
 
-    # 6. (Simplified) – No background polling. The newly-created record will
-    # be refreshed only when the front-end explicitly calls the *refresh* API
-    # endpoint. This keeps the generation step lightweight and avoids long-
-    # running background tasks.
+    Returns immediately after creating the database record. All processing 
+    (OpenAI reframing, Meshy API call) happens in the background.
+    """
+
+    # Credit check and decrement
+    await _check_and_decrement_credits(current_user.id)
 
-    return {
-        "generated_model_id": generated_model_id,
-        "meshy_task_id": meshy_task_id,
-        "status": "processing",
-        "original_prompt": prompt.text,
-        "reframed_prompt": reframed_prompt,
-    }
+    # Insert initial DB record and return immediately
+    try:
+        insert_res = supabase.from_("Generated_Models").insert({
+            "status": "IN_PROGRESS",
+            "user_id": current_user.id,
+            "meshy_api_job_id": None,
+            "model_name": f"{prompt.text[:50]}{'...' if len(prompt.text) > 50 else ''}",
+            "prompts_and_models_config": {
+                "generation_type": "text_to_3d",
+                "original_prompt": prompt.text,
+                "status": "initializing",
+                "stage": "reframing_prompt",
+            },
+        }).execute()
+        generated_model_id = insert_res.data[0]["generated_model_id"] if insert_res.data else None
+        
+        if not generated_model_id:
+            raise HTTPException(status_code=500, detail="Failed to create model record")
+        
+        # Add background task for processing
+        background_tasks.add_task(_process_text_to_3d_background, generated_model_id, current_user.id, prompt.text)
+        
+        # Return immediately
+        return {
+            "generated_model_id": generated_model_id,
+            "status": "initializing",
+            "original_prompt": prompt.text,
+            "message": "Generation started. Use the progress_update endpoint to check status."
+        }
+        
+    except Exception as ex:
+        logging.error(f"Failed to create initial model DB record: {ex}")
+        raise HTTPException(status_code=500, detail=f"Failed to start generation: {ex}")
 
 # NEW: Image to 3D generation endpoint
 @router.post("/image-to-3d")
@@ -294,19 +352,13 @@ async def image_to_3d(request: ImageTo3DRequest, background_tasks: BackgroundTas
     """
     Create a Meshy Image-to-3D generation job.
 
-    This mirrors the *text_to_3d* workflow but skips prompt reframing. The steps are:
-    1. Deduct one credit.
-    2. Persist an initial *Generated_Models* row (status = IN_PROGRESS).
-    3. Submit the image to Meshy and store the returned task id.
-    4. Return the identifiers so the front-end can poll the *progress_update* endpoint.
+    Returns immediately after creating the database record. Meshy API call happens in the background.
     """
 
     # 1. Credit check and decrement
     await _check_and_decrement_credits(current_user.id)
 
-    generated_model_id: Optional[int] = None
-
-    # 2. Insert initial DB record
+    # 2. Insert initial DB record and return immediately
     try:
         insert_res = supabase.from_("Generated_Models").insert({
             "status": "IN_PROGRESS",
@@ -321,73 +373,44 @@ async def image_to_3d(request: ImageTo3DRequest, background_tasks: BackgroundTas
             },
         }).execute()
         generated_model_id = insert_res.data[0]["generated_model_id"] if insert_res.data else None
+        
+        if not generated_model_id:
+            raise HTTPException(status_code=500, detail="Failed to create model record")
+
+        # Build payload by including all non-None fields from the request model
+        payload: Dict[str, Any] = {k: v for k, v in request.dict().items() if v is not None}
+
+        # Add background task for Meshy API processing
+        background_tasks.add_task(_process_image_to_3d_background, generated_model_id, payload, "image_to_3d")
+
+        # Return immediately
+        return {
+            "generated_model_id": generated_model_id,
+            "status": "initializing",
+            "input_image_url": request.image_url,
+            "message": "Generation started. Use the progress_update endpoint to check status."
+        }
+        
     except Exception as ex:
         logging.error(f"Failed to create initial model DB record: {ex}")
-
-    # 3. Send request to Meshy
-    meshy_key = os.getenv("MESHY_API_KEY")
-    if not meshy_key:
-        raise HTTPException(status_code=500, detail="MESHY_API_KEY not configured")
-
-    # Build payload by including all non-None fields from the request model
-    payload: Dict[str, Any] = {k: v for k, v in request.dict().items() if v is not None}
-
-    async with httpx.AsyncClient(timeout=30.0) as client:
-        meshy_resp = await client.post(
-            "https://api.meshy.ai/openapi/v1/image-to-3d",
-            headers={"Authorization": f"Bearer {meshy_key}"},
-            json=payload,
-        )
-
-    if meshy_resp.status_code not in (200, 201, 202):
-        raise HTTPException(status_code=meshy_resp.status_code, detail=meshy_resp.text)
-
-    meshy_data = meshy_resp.json()
-    meshy_task_id = meshy_data.get("result") or meshy_data.get("id") or meshy_data.get("task_id")
-
-    if not meshy_task_id:
-        raise HTTPException(status_code=500, detail="No task ID received from Meshy API")
-
-    # 4. Finalize DB record
-    if generated_model_id:
-        try:
-            supabase.from_("Generated_Models").update({
-                "meshy_api_job_id": meshy_task_id,
-                "prompts_and_models_config": {
-                    "generation_type": "image_to_3d",
-                    "input_image_url": request.image_url,
-                    "status": "processing",
-                    "stage": "generating",
-                    "meshy_response": meshy_data,
-                },
-            }).eq("generated_model_id", generated_model_id).execute()
-        except Exception as ex:
-            logging.warning(f"Failed to update DB with Meshy taskId: {ex}")
-
-    # 5. Return identifiers
-    return {
-        "generated_model_id": generated_model_id,
-        "meshy_task_id": meshy_task_id,
-        "status": "processing",
-        "input_image_url": request.image_url,
-    }
+        raise HTTPException(status_code=500, detail=f"Failed to start generation: {ex}")
 
 @router.post("/image-to-3d/upload")
 async def image_to_3d_upload(
+    background_tasks: BackgroundTasks,
     file: UploadFile = File(...),
     current_user: User = Depends(get_current_active_user),
 ):
     """Upload an image file and create a Meshy *Image-to-3D* task.
 
-    The raw image file is base64-encoded on the server and sent to Meshy as a
-    `data:image/<ext>;base64,<data>` Data-URI, so the front-end doesn't need to
-    perform that conversion.
+    Returns immediately after creating the database record and encoding the image.
+    Meshy API call happens in the background.
     """
 
     # 1. Credit check and decrement
     await _check_and_decrement_credits(current_user.id)
 
-    # 2. Read & encode file
+    # 2. Read & encode file (this is fast, so we do it synchronously)
     try:
         file_bytes = await file.read()
         mime_type = file.content_type or "image/png"
@@ -396,9 +419,7 @@ async def image_to_3d_upload(
     except Exception as ex:
         raise HTTPException(status_code=400, detail=f"Failed to read uploaded file: {ex}")
 
-    generated_model_id: Optional[int] = None
-
-    # 3. Insert initial DB record
+    # 3. Insert initial DB record and return immediately
     try:
         insert_res = supabase.from_("Generated_Models").insert({
             "status": "IN_PROGRESS",
@@ -413,72 +434,43 @@ async def image_to_3d_upload(
             },
         }).execute()
         generated_model_id = insert_res.data[0]["generated_model_id"] if insert_res.data else None
+        
+        if not generated_model_id:
+            raise HTTPException(status_code=500, detail="Failed to create model record")
+
+        # Build payload
+        payload: Dict[str, Any] = {
+            "image_url": data_uri,
+            "mode": "preview",
+            "ai_model": "meshy-5",
+            #"should_texture": False,
+        }
+
+        # Add background task for Meshy API processing
+        background_tasks.add_task(_process_image_to_3d_background, generated_model_id, payload, "image_to_3d")
+
+        # Return immediately
+        return {
+            "generated_model_id": generated_model_id,
+            "status": "initializing",
+            "input_image_filename": file.filename,
+            "message": "Generation started. Use the progress_update endpoint to check status."
+        }
+        
     except Exception as ex:
         logging.error(f"Failed to create initial model DB record: {ex}")
-
-    # 4. Send request to Meshy
-    meshy_key = os.getenv("MESHY_API_KEY")
-    if not meshy_key:
-        raise HTTPException(status_code=500, detail="MESHY_API_KEY not configured")
-
-    # Build payload
-    payload: Dict[str, Any] = {
-        "image_url": data_uri,
-        "mode": "preview",
-        "ai_model": "meshy-5",
-        #"should_texture": False,
-    }
-
-    async with httpx.AsyncClient(timeout=30.0) as client:
-        meshy_resp = await client.post(
-            "https://api.meshy.ai/openapi/v1/image-to-3d",
-            headers={"Authorization": f"Bearer {meshy_key}"},
-            json=payload,
-        )
-
-    if meshy_resp.status_code not in (200, 201, 202):
-        raise HTTPException(status_code=meshy_resp.status_code, detail=meshy_resp.text)
-
-    meshy_data = meshy_resp.json()
-    meshy_task_id = meshy_data.get("result") or meshy_data.get("id") or meshy_data.get("task_id")
-
-    if not meshy_task_id:
-        raise HTTPException(status_code=500, detail="No task ID received from Meshy API")
-
-    # 5. Finalize DB record
-    if generated_model_id:
-        try:
-            supabase.from_("Generated_Models").update({
-                "meshy_api_job_id": meshy_task_id,
-                "prompts_and_models_config": {
-                    "generation_type": "image_to_3d",
-                    "input_image_filename": file.filename,
-                    "status": "processing",
-                    "stage": "generating",
-                    "meshy_response": meshy_data,
-                },
-            }).eq("generated_model_id", generated_model_id).execute()
-        except Exception as ex:
-            logging.warning(f"Failed to update DB with Meshy taskId: {ex}")
-
-    # 6. Return identifiers
-    return {
-        "generated_model_id": generated_model_id,
-        "meshy_task_id": meshy_task_id,
-        "status": "processing",
-        "input_image_filename": file.filename,
-    }
+        raise HTTPException(status_code=500, detail=f"Failed to start generation: {ex}")
 
 @router.post("/multi-image-to-3d")
 async def multi_image_to_3d_upload(
+    background_tasks: BackgroundTasks,
     files: list[UploadFile] = File(...),
     current_user: User = Depends(get_current_active_user),
 ):
     """Upload multiple image files and create a Meshy *Multi-Image-to-3D* task.
 
-    The raw image files are base64-encoded on the server and sent to Meshy as
-    `data:image/<ext>;base64,<data>` Data-URIs, so the front-end doesn't need to
-    perform that conversion.
+    Returns immediately after creating the database record and encoding the images.
+    Meshy API call happens in the background.
     """
 
     # 1. Credit check and decrement
@@ -488,7 +480,7 @@ async def multi_image_to_3d_upload(
     if len(files) < 2:
         raise HTTPException(status_code=400, detail="At least 2 images are required for multi-image generation")
 
-    # 3. Read & encode all files
+    # 3. Read & encode all files (this is reasonably fast, so we do it synchronously)
     try:
         image_urls = []
         filenames = []
@@ -502,9 +494,7 @@ async def multi_image_to_3d_upload(
     except Exception as ex:
         raise HTTPException(status_code=400, detail=f"Failed to read uploaded files: {ex}")
 
-    generated_model_id: Optional[int] = None
-
-    # 4. Insert initial DB record
+    # 4. Insert initial DB record and return immediately
     try:
         insert_res = supabase.from_("Generated_Models").insert({
             "status": "IN_PROGRESS",
@@ -519,59 +509,30 @@ async def multi_image_to_3d_upload(
             },
         }).execute()
         generated_model_id = insert_res.data[0]["generated_model_id"] if insert_res.data else None
+        
+        if not generated_model_id:
+            raise HTTPException(status_code=500, detail="Failed to create model record")
+
+        # Build payload
+        payload: Dict[str, Any] = {
+            "image_urls": image_urls,
+            "mode": "preview",
+            "ai_model": "meshy-5",
+            "should_texture": False,
+        }
+
+        # Add background task for Meshy API processing
+        background_tasks.add_task(_process_image_to_3d_background, generated_model_id, payload, "multi_image_to_3d")
+
+        # Return immediately
+        return {
+            "generated_model_id": generated_model_id,
+            "status": "initializing",
+            "input_image_filenames": filenames,
+            "message": "Generation started. Use the progress_update endpoint to check status."
+        }
+        
     except Exception as ex:
         logging.error(f"Failed to create initial model DB record: {ex}")
-
-    # 5. Send request to Meshy
-    meshy_key = os.getenv("MESHY_API_KEY")
-    if not meshy_key:
-        raise HTTPException(status_code=500, detail="MESHY_API_KEY not configured")
-
-    # Build payload
-    payload: Dict[str, Any] = {
-        "image_urls": image_urls,
-        "mode": "preview",
-        "ai_model": "meshy-5",
-        "should_texture": False,
-    }
-
-    async with httpx.AsyncClient(timeout=30.0) as client:
-        meshy_resp = await client.post(
-            "https://api.meshy.ai/openapi/v1/multi-image-to-3d",
-            headers={"Authorization": f"Bearer {meshy_key}"},
-            json=payload,
-        )
-
-    if meshy_resp.status_code not in (200, 201, 202):
-        raise HTTPException(status_code=meshy_resp.status_code, detail=meshy_resp.text)
-
-    meshy_data = meshy_resp.json()
-    meshy_task_id = meshy_data.get("result") or meshy_data.get("id") or meshy_data.get("task_id")
-
-    if not meshy_task_id:
-        raise HTTPException(status_code=500, detail="No task ID received from Meshy API")
-
-    # 6. Finalize DB record
-    if generated_model_id:
-        try:
-            supabase.from_("Generated_Models").update({
-                "meshy_api_job_id": meshy_task_id,
-                "prompts_and_models_config": {
-                    "generation_type": "multi_image_to_3d",
-                    "input_image_filenames": filenames,
-                    "status": "processing",
-                    "stage": "generating",
-                    "meshy_response": meshy_data,
-                },
-            }).eq("generated_model_id", generated_model_id).execute()
-        except Exception as ex:
-            logging.warning(f"Failed to update DB with Meshy taskId: {ex}")
-
-    # 7. Return identifiers
-    return {
-        "generated_model_id": generated_model_id,
-        "meshy_task_id": meshy_task_id,
-        "status": "processing",
-        "input_image_filenames": filenames,
-    }
+        raise HTTPException(status_code=500, detail=f"Failed to start generation: {ex}")