hunyuan model

main.py

@@ -230,7 +230,7 @@ async def sync_supabase_user(request: SyncUserRequest, supabase_token: str = Dep
                 # Initialize credits for new user
                 supabase.from_("User_Credit_Account").insert({
                     "user_id": supabase_user["id"],
-                    "num_of_available_gens": 3  # Give new users 3 free credits
+                    "num_of_available_gens": 0
                 }).execute()
                 logging.info("User credits initialized successfully")
             except Exception as create_error:
@@ -300,7 +300,7 @@ async def complete_profile(request: CompleteProfileRequest, current_user: User =
     if not credit.data:
         supabase.from_("User_Credit_Account").insert({
             "user_id": current_user.id,
-            "num_of_available_gens": 3
+            "num_of_available_gens": 0
         }).execute()
     return {"message": "Profile completed and credits initialized."}
 

routers/user_models.py

@@ -1,16 +1,13 @@
-from fastapi import APIRouter, Depends, HTTPException, Request, BackgroundTasks, UploadFile, File, Form
+from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks, UploadFile, File, Form
 from fastapi.responses import JSONResponse
 from auth import get_current_active_user, User, supabase
 import logging
 import httpx
 import os
-import json
 from typing import Optional, Dict, Any
-from sse_starlette.sse import EventSourceResponse
-import asyncio
 from pydantic import BaseModel
-from utils.pubsub import pubsub as inmem_pubsub
 import base64
+from services.hunyuan_service import _hunyuan_image_to_3d
 
 router = APIRouter(
     prefix="/user/models",
@@ -18,18 +15,6 @@ router = APIRouter(
     dependencies=[Depends(get_current_active_user)]
 )
 
-"""
-Endpoints already taken:
-get user/models
-get user/models/{task_id}
-delete user/models/{generated_model_id}
-post user/models/{task_id}/refresh
-post user/models/{generated_model_id}/refresh
-post user/models/refresh/{generated_model_id}
-delete user/models/{generated_model_id}
-"""
-
-# Example endpoint - you can add new user/models endpoints here
 @router.get("/progress_update/{generated_model_id}")
 async def refresh_generated_model(generated_model_id: str, current_user: User = Depends(get_current_active_user)):
     """
@@ -51,6 +36,24 @@ async def refresh_generated_model(generated_model_id: str, current_user: User =
         generation_type = prompts_config.get("generation_type")
         should_texture = prompts_config.get("should_texture", False)
 
+        # Special handling for Hunyuan generation (doesn't use Meshy API)
+        if generation_type == "hunyuan_image_to_3d":
+            return {
+                "task_id": generated_model_id,
+                "status": generated_model.get("status", "IN_PROGRESS"),
+                "progress": 100 if generated_model.get("status") == "COMPLETED" else 50,
+                "model_urls": None,  # Hunyuan files are stored in Model_Files table
+                "thumbnail_url": None,
+                "texture_urls": None,
+                "created_at": generated_model.get("created_at"),
+                "started_at": generated_model.get("created_at"),
+                "finished_at": generated_model.get("updated_at") if generated_model.get("status") == "COMPLETED" else None,
+                "task_error": None,
+                "database_updated": True,
+                "generation_type": "hunyuan_image_to_3d",
+                "message": "Hunyuan generation completed. Check Model_Files table for 3D mesh file." if generated_model.get("status") == "COMPLETED" else "Hunyuan generation in progress..."
+            }
+
         meshy_task_id = generated_model.get("meshy_api_job_id")
         if not meshy_task_id:
             raise HTTPException(status_code=400, detail="Meshy task id missing for this model")
@@ -428,6 +431,65 @@ async def _process_text_to_3d_background(
     except Exception as ex:
         logging.error(f"Background processing failed for text-to-3d model {generated_model_id}: {ex}")
 
+# CREDITS ARE NOT DECREMENTED HERE / DECREMENT BEFORE CALLING THIS FUNCTION
+async def _process_hunyuan_image_to_3d_background(generated_model_id: int, image_url: str, user_id: str):
+    """Background task to handle Hunyuan API call for image-to-3d"""
+    try:
+        hunyuan_response = _hunyuan_image_to_3d(image_url)
+
+        if not hunyuan_response:
+            logging.error(f"Hunyuan API failed for model {generated_model_id}")
+            return
+
+        # Extract mesh URL from response
+        mesh_url = hunyuan_response.get("output", {}).get("mesh") if "output" in hunyuan_response else hunyuan_response.get("mesh")
+        
+        if not mesh_url:
+            logging.error(f"No mesh URL found in Hunyuan response for model {generated_model_id}")
+            return
+
+        # Download the mesh file
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            mesh_response = await client.get(mesh_url)
+            
+            if mesh_response.status_code != 200:
+                logging.error(f"Failed to download mesh file from {mesh_url}: {mesh_response.status_code}")
+                return
+            
+            mesh_data = mesh_response.content
+            
+        # Determine file format from URL or default to .glb
+        file_name = mesh_url.split("/")[-1] if "/" in mesh_url else f"hunyuan_model_{generated_model_id}.glb"
+        if "." not in file_name:
+            file_name += ".glb"
+        
+        file_format = file_name.split(".")[-1].lower()
+        file_size = len(mesh_data)
+
+        # Update DB record with Hunyuan response
+        supabase.from_("Generated_Models").update({
+            "status": "COMPLETED",
+            "updated_at": "now()",
+            "prompts_and_models_config": hunyuan_response,
+        }).eq("generated_model_id", generated_model_id).execute()
+
+        # Insert the mesh file into Model_Files table
+        supabase.from_("Model_Files").insert({
+            "user_id": user_id,
+            "generated_model_id": generated_model_id,
+            "model_data": mesh_data,
+            "file_name": file_name,
+            "file_format": file_format,
+            "file_size": file_size,
+            "metadata": f"Hunyuan3D generated mesh file. Original URL: {mesh_url}",
+            "is_preview_file": False,
+        }).execute()
+
+        logging.info(f"Successfully completed Hunyuan image-to-3d generation for model {generated_model_id}")
+        
+    except Exception as ex:
+        logging.error(f"Background processing failed for Hunyuan image-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"""
@@ -552,6 +614,67 @@ async def text_to_3d(prompt: TextPrompt, background_tasks: BackgroundTasks, curr
         logging.error(f"Failed to create initial model DB record: {ex}")
         raise HTTPException(status_code=500, detail=f"Failed to start generation: {ex}")
 
+@router.post("/image-to-3d")
+async def image_to_3d(
+    background_tasks: BackgroundTasks,
+    image_url: str,
+    current_user: User = Depends(get_current_active_user),
+):
+    """
+    Create a Hunyuan3D Image-to-3D generation job using Replicate API.
+
+    Returns immediately after creating the database record. Hunyuan API call 
+    and mesh file download happen in the background.
+    """
+    
+    # Credit check and decrement - Hunyuan generation costs 2 credits
+    await _check_and_decrement_credits(current_user.id, 2)
+
+    # 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"Hunyuan 3D from {image_url.split('/')[-1] if '/' in image_url else 'image'}",
+            "prompts_and_models_config": {
+                "generation_type": "hunyuan_image_to_3d",
+                "input_image_url": image_url,
+                "status": "initializing",
+                "stage": "processing_image",
+            },
+        }).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 Hunyuan processing
+        background_tasks.add_task(
+            _process_hunyuan_image_to_3d_background,
+            generated_model_id,
+            image_url,
+            current_user.id,
+        )
+        
+        # Return immediately with explicit headers
+        response_data = {
+            "generated_model_id": generated_model_id,
+            "status": "initializing",
+            "input_image_url": image_url,
+            "message": "Hunyuan 3D generation started. Use the progress_update endpoint to check status."
+        }
+        
+        logging.info(f"Returning response for hunyuan image-to-3d: {response_data}")
+        
+        response = JSONResponse(content=response_data, status_code=200)
+        # Allowed header; avoids disallowed connection-specific headers under HTTP/2
+        response.headers["Cache-Control"] = "no-cache"
+        return response
+        
+    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}")
 
 @router.post("/image-to-3d/upload")
 async def image_to_3d_upload(
@@ -564,7 +687,7 @@ async def image_to_3d_upload(
 
     Returns immediately after creating the database record and encoding the image.
     Meshy API call happens in the background.
-    """
+    """:
 
     # 1. Credit check and decrement – texture generation costs 3 credits
     credit_cost = 3 if should_texture else 1
@@ -718,6 +841,81 @@ async def multi_image_to_3d_upload(
         logging.error(f"Failed to create initial model DB record: {ex}")
         raise HTTPException(status_code=500, detail=f"Failed to start generation: {ex}")
 
+@router.get("/{generated_model_id}/file")
+async def get_model_file(
+    generated_model_id: str,
+    current_user: User = Depends(get_current_active_user)
+):
+    """
+    Get the model file info for a generated model belonging to the current user.
+    """
+    try:
+        # First check if the model exists and belongs to the user
+        model_check = supabase.from_("Generated_Models").select("generated_model_id, user_id, model_name").eq("generated_model_id", generated_model_id).eq("user_id", current_user.id).single().execute()
+        
+        if not model_check.data:
+            raise HTTPException(status_code=404, detail="Model not found or you do not have permission to access it.")
+        
+        # Get the single model file for this generated model
+        file_result = supabase.from_("Model_Files").select("model_file_id, file_name, file_format, file_size, metadata, is_preview_file, created_at").eq("generated_model_id", generated_model_id).eq("user_id", current_user.id).single().execute()
+        
+        if not file_result.data:
+            raise HTTPException(status_code=404, detail="No model file found for this generated model.")
+        
+        return {
+            "generated_model_id": generated_model_id,
+            "model_name": model_check.data.get("model_name"),
+            "file": file_result.data
+        }
+        
+    except HTTPException:
+        # Re-raise HTTP exceptions as-is
+        raise
+    except Exception as e:
+        logging.error(f"Failed to get model file for {generated_model_id}: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+@router.get("/{generated_model_id}/download")
+async def download_model_file(
+    generated_model_id: str,
+    current_user: User = Depends(get_current_active_user)
+):
+    """
+    Download the model file for a generated model.
+    """
+    try:
+        # First check if the model exists and belongs to the user
+        model_check = supabase.from_("Generated_Models").select("generated_model_id, user_id, model_name").eq("generated_model_id", generated_model_id).eq("user_id", current_user.id).single().execute()
+        
+        if not model_check.data:
+            raise HTTPException(status_code=404, detail="Model not found or you do not have permission to access it.")
+        
+        # Get the model file and verify ownership
+        file_result = supabase.from_("Model_Files").select("*").eq("generated_model_id", generated_model_id).eq("user_id", current_user.id).single().execute()
+        
+        if not file_result.data:
+            raise HTTPException(status_code=404, detail="No model file found for this generated model.")
+        
+        file_data = file_result.data
+        
+        from fastapi.responses import Response
+        
+        return Response(
+            content=file_data["model_data"],
+            media_type="application/octet-stream",
+            headers={
+                "Content-Disposition": f"attachment; filename={file_data['file_name']}",
+                "Content-Length": str(file_data["file_size"])
+            }
+        )
+        
+    except HTTPException:
+        # Re-raise HTTP exceptions as-is
+        raise
+    except Exception as e:
+        logging.error(f"Failed to download model file for {generated_model_id}: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
 @router.delete("/{generated_model_id}")
 async def delete_model(
     generated_model_id: str,

services/hunyuan_service.py

@@ -0,0 +1,60 @@
+from auth import supabase
+from fastapi import HTTPException
+import requests
+import os
+
+REPLICATE_API_TOKEN = os.getenv("REPLICATE_API_TOKEN")
+
+def _credit_check_decrement(user_id: str, cost: int = 1) -> bool:
+
+    user_credit = (
+        supabase.from_("User_Credit_Account")
+        .select("num_of_available_gens")
+        .eq("user_id", user_id)
+        .single()
+        .execute()
+    )
+
+    if not user_credit.data:
+        raise HTTPException(status_code=403, detail="No credit account")
+        return False
+
+    available_credits = user_credit.data["num_of_available_gens"]
+
+    if available_credits < cost:
+        raise HTTPException(status_code=403, detail="Not enough credits")
+        return False
+    
+    supabase.from_("User_Credit_Account").update({"num_of_available_gens": available_credits - cost}).eq("user_id", user_id).execute()
+
+    return True
+
+def _hunyuan_image_to_3d(image_url: str) -> dict:
+    if not REPLICATE_API_TOKEN:
+        raise HTTPException(status_code=500, detail="REPLICATE_API_TOKEN not configured")
+    
+    payload = {
+        "version": "b1b9449a1277e10402781c5d41eb30c0a0683504fb23fab591ca9dfc2aabe1cb",
+        "input": {
+            "image": image_url,
+            "steps": 50,
+            "guidance_scale": 5.5,
+            "octree_resolution": 256,
+            "remove_background": True,
+        }
+    }
+
+    response = requests.post(
+        "https://api.replicate.com/v1/predictions",
+        headers={
+            "Authorization": f"Bearer {REPLICATE_API_TOKEN}",
+            "Content-Type": "application/json",
+            "Prefer": "wait"
+        },
+        json=payload,
+    )
+
+    if response.status_code != 200:
+        raise HTTPException(status_code=response.status_code, detail=f"Replicate API error: {response.text}")
+    
+    return response.json()

subscription_integration_example.py

@@ -1,193 +0,0 @@
-# Example: Integrating Subscriptions with Existing Credit System
-# Add these functions to your main.py or create a separate utils module
-
-from datetime import datetime, timedelta
-from auth import supabase
-import logging
-
-async def check_user_access_permissions(user_id: str) -> dict:
-    """
-    Enhanced function to check if user can access AI generation features.
-    Checks both one-time credits and active subscriptions.
-    """
-    try:
-        # Check for active subscription first
-        subscription_record = supabase.from_("User_Subscriptions").select("*").eq("user_id", user_id).eq("status", "active").execute()
-        
-        has_active_subscription = bool(subscription_record.data)
-        
-        # Get current credits
-        credit_record = supabase.from_("User_Credit_Account").select("num_of_available_gens").eq("user_id", user_id).execute()
-        current_credits = credit_record.data[0]["num_of_available_gens"] if credit_record.data else 0
-        
-        # Determine access level
-        if has_active_subscription:
-            subscription = subscription_record.data[0]
-            return {
-                "can_generate": True,
-                "access_type": "subscription",
-                "subscription_plan": subscription["plan"],
-                "credits": current_credits,
-                "subscription_active": True,
-                "period_end": subscription["current_period_end"]
-            }
-        elif current_credits > 0:
-            return {
-                "can_generate": True,
-                "access_type": "credits",
-                "subscription_plan": None,
-                "credits": current_credits,
-                "subscription_active": False,
-                "period_end": None
-            }
-        else:
-            return {
-                "can_generate": False,
-                "access_type": None,
-                "subscription_plan": None,
-                "credits": 0,
-                "subscription_active": False,
-                "period_end": None
-            }
-    
-    except Exception as e:
-        logging.error(f"Error checking user access: {str(e)}")
-        return {
-            "can_generate": False,
-            "access_type": None,
-            "subscription_plan": None,
-            "credits": 0,
-            "subscription_active": False,
-            "period_end": None,
-            "error": str(e)
-        }
-
-async def check_and_decrement_credits_enhanced(user_id: str) -> bool:
-    """
-    Enhanced version of your existing credit checking function.
-    Prioritizes subscription access over one-time credits.
-    """
-    try:
-        access_info = await check_user_access_permissions(user_id)
-        
-        if not access_info["can_generate"]:
-            return False
-        
-        if access_info["access_type"] == "subscription":
-            # User has active subscription - allow generation without decrementing credits
-            # Credits accumulate for subscription users as a bonus
-            logging.info(f"User {user_id} using subscription access ({access_info['subscription_plan']})")
-            return True
-        
-        elif access_info["access_type"] == "credits":
-            # User using one-time credits - decrement as before
-            current_credits = access_info["credits"]
-            if current_credits > 0:
-                new_credits = current_credits - 1
-                supabase.from_("User_Credit_Account").update({"num_of_available_gens": new_credits}).eq("user_id", user_id).execute()
-                logging.info(f"User {user_id} used 1 credit. Remaining: {new_credits}")
-                return True
-        
-        return False
-    
-    except Exception as e:
-        logging.error(f"Error in credit check: {str(e)}")
-        return False
-
-# New endpoint to add to main.py
-from fastapi import Depends
-from auth import get_current_active_user, User
-
-@app.get("/user/access-info", tags=["User"])
-async def get_user_access_info(current_user: User = Depends(get_current_active_user)):
-    """
-    Get comprehensive user access information including subscription and credits.
-    """
-    access_info = await check_user_access_permissions(current_user.id)
-    return access_info
-
-@app.get("/user/subscription-status", tags=["User"])
-async def get_subscription_status(current_user: User = Depends(get_current_active_user)):
-    """
-    Get detailed subscription status for the user.
-    """
-    try:
-        # Get subscription details
-        subscription_record = supabase.from_("User_Subscriptions").select("*").eq("user_id", current_user.id).order("created_at", desc=True).limit(1).execute()
-        
-        if not subscription_record.data:
-            return {
-                "has_subscription": False,
-                "subscription": None,
-                "next_billing_date": None,
-                "can_upgrade": True
-            }
-        
-        subscription = subscription_record.data[0]
-        
-        # Get payment history
-        payment_history = supabase.from_("Subscription_Payment_History").select("*").eq("user_id", current_user.id).order("payment_date", desc=True).limit(5).execute()
-        
-        return {
-            "has_subscription": subscription["status"] in ["active", "cancel_at_period_end"],
-            "subscription": subscription,
-            "next_billing_date": subscription["current_period_end"],
-            "can_upgrade": subscription["status"] == "active",
-            "recent_payments": payment_history.data,
-            "subscription_plan_details": SUBSCRIPTION_PLANS.get(subscription["plan"]) if subscription["plan"] in SUBSCRIPTION_PLANS else None
-        }
-    
-    except Exception as e:
-        logging.error(f"Error getting subscription status: {str(e)}")
-        raise HTTPException(status_code=500, detail="Failed to get subscription status")
-
-# Usage tracking for subscription users
-async def track_subscription_usage(user_id: str, feature_used: str):
-    """
-    Track usage for subscription users (for analytics and potential usage limits).
-    """
-    try:
-        # Get user's active subscription
-        subscription_record = supabase.from_("User_Subscriptions").select("*").eq("user_id", user_id).eq("status", "active").execute()
-        
-        if subscription_record.data:
-            subscription_id = subscription_record.data[0]["stripe_subscription_id"]
-            
-            # Log usage (you might want to create a separate Usage_Tracking table)
-            usage_data = {
-                "user_id": user_id,
-                "subscription_id": subscription_id,
-                "feature_used": feature_used,
-                "timestamp": datetime.now().isoformat(),
-                "billing_period_start": subscription_record.data[0]["current_period_start"],
-                "billing_period_end": subscription_record.data[0]["current_period_end"]
-            }
-            
-            # You can log this to a separate table or your existing logging system
-            logging.info(f"Subscription usage tracked: {usage_data}")
-    
-    except Exception as e:
-        logging.error(f"Error tracking subscription usage: {str(e)}")
-
-# Updated version of your existing generation endpoints
-# Replace your existing check_and_decrement_credits calls with check_and_decrement_credits_enhanced
-
-# Example for one of your endpoints:
-@app.post("/req-img-to-3d-enhanced", tags=["Image-to-3D"])
-async def req_img_to_3d_enhanced(
-    image: UploadFile = File(...),
-    settings: Settings = Depends(get_settings),
-    current_user: User = Depends(get_current_active_user)
-):
-    """
-    Enhanced version that works with both subscriptions and credits.
-    """
-    # Check access permissions
-    if not await check_and_decrement_credits_enhanced(current_user.id):
-        raise HTTPException(status_code=402, detail="Insufficient credits or no active subscription")
-    
-    # Track usage for subscription users
-    await track_subscription_usage(current_user.id, "image_to_3d")
-    
-    # Rest of your existing logic...
-    # ... existing image processing code ... 

utils/pubsub.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from collections import defaultdict
-from typing import Dict, List, Any
-
-
-class InMemoryPubSub:
-    """A minimal in-process pub/sub helper.
-
-    Subscribers are simply *asyncio.Queue* instances.  Each task_id can have
-    many subscribers (e.g. multiple browser tabs connected to the same SSE
-    stream).  The publisher pushes a message **dict** (already JSON-serialisable)
-    and every subscriber receives it.
-
-    NOTE: This works only inside a single Python process.  If you run several
-    Uvicorn/Gunicorn workers the events won't be shared between them.  Use a
-    proper external broker (Redis, NATS, …) for multi-process deployments.
-    """
-
-    def __init__(self) -> None:
-        self._subscribers: Dict[str, List[asyncio.Queue]] = defaultdict(list)
-        self._lock = asyncio.Lock()  # protect subscriber mutations
-
-    async def publish(self, task_id: str, message: Any) -> None:
-        """Broadcast *message* to every subscriber listening to *task_id*."""
-        # Work on a snapshot to avoid race conditions if someone unsubscribes
-        async with self._lock:
-            queues = list(self._subscribers.get(task_id, []))
-        for queue in queues:
-            await queue.put(message)
-
-    async def subscribe(self, task_id: str) -> asyncio.Queue:
-        """Return a brand-new *asyncio.Queue* subscribed to *task_id*."""
-        queue: asyncio.Queue = asyncio.Queue()
-        async with self._lock:
-            self._subscribers[task_id].append(queue)
-        return queue
-
-    async def unsubscribe(self, task_id: str, queue: asyncio.Queue) -> None:
-        """Remove *queue* from *task_id* subscriptions and cleanup."""
-        async with self._lock:
-            if task_id in self._subscribers and queue in self._subscribers[task_id]:
-                self._subscribers[task_id].remove(queue)
-                if not self._subscribers[task_id]:
-                    del self._subscribers[task_id]
-
-
-# Global singleton used across the code-base
-pubsub = InMemoryPubSub()
-
-__all__ = ["pubsub", "InMemoryPubSub"] 

utils/worker.py

@@ -1,96 +0,0 @@
-import os, asyncio, logging
-import httpx
-from auth import supabase  # re-use existing Supabase client
-from utils.pubsub import pubsub as inmem_pubsub
-
-# ---------------------------------------------------------------------------
-# Real Meshy Text-to-3D polling task – executed as FastAPI BackgroundTask
-# ---------------------------------------------------------------------------
-
-async def poll_meshy_task(generated_model_id: int, meshy_task_id: str):
-    """Poll Meshy API every few seconds, publish progress to in-memory pub/sub and update DB.
-
-    Parameters
-    ----------
-    generated_model_id : int
-        Primary-key id of our *Generated_Models* row. Used as the public
-        task identifier for SSE consumers.
-    meshy_task_id : str
-        UUID returned by Meshy when the generation request was created.
-    """
-
-    meshy_api_key = os.getenv("MESHY_API_KEY")
-    if not meshy_api_key:
-        logging.error("MESHY_API_KEY env-var missing – cannot poll Meshy API")
-        return
-
-    headers = {"Authorization": f"Bearer {meshy_api_key}"}
-
-    last_progress = -1  # to avoid spamming identical values
-
-    async with httpx.AsyncClient(timeout=30.0) as client:
-        while True:
-            try:
-                resp = await client.get(
-                    f"https://api.meshy.ai/openapi/v2/text-to-3d/{meshy_task_id}",
-                    headers=headers,
-                )
-            except Exception as exc:
-                logging.warning(f"Meshy API request failed: {exc}; retrying in 30s")
-                await asyncio.sleep(30)
-                continue
-
-            if resp.status_code != 200:
-                # Meshy returned an error – notify and abort.
-                data = {
-                    "taskId": str(generated_model_id),
-                    "progress": max(last_progress, 0),
-                    "status": "failed",
-                    "error": f"Meshy API error {resp.status_code}",
-                }
-                await inmem_pubsub.publish(str(generated_model_id), data)
-                break
-
-            payload = resp.json()
-            status = payload.get("status", "UNKNOWN")
-            progress = payload.get("progress", 0)
-
-            # Publish progress updates (avoid duplicates)
-            if progress != last_progress or status in ("SUCCEEDED", "FAILED"):
-                await inmem_pubsub.publish(str(generated_model_id), {
-                    "taskId": str(generated_model_id),
-                    "progress": progress,
-                    "status": status.lower(),
-                    "model_urls": payload.get("model_urls"),
-                    "thumbnail_url": payload.get("thumbnail_url"),
-                })
-                last_progress = progress
-
-            # Handle terminal states
-            if status == "SUCCEEDED":
-                try:
-                    supabase.from_("Generated_Models").update({
-                        "prompts_and_models_config": payload,
-                        "status": "COMPLETED",
-                        "updated_at": "now()",
-                    }).eq("generated_model_id", generated_model_id).execute()
-                except Exception as exc:
-                    logging.warning(f"Failed to update DB on success: {exc}")
-                break
-
-            if status == "FAILED":
-                try:
-                    supabase.from_("Generated_Models").update({
-                        "prompts_and_models_config": payload,
-                        "status": "FAILED",
-                        "updated_at": "now()",
-                    }).eq("generated_model_id", generated_model_id).execute()
-                except Exception as exc:
-                    logging.warning(f"Failed to update DB on failure: {exc}")
-                break
-
-            # Sleep between polls
-            await asyncio.sleep(5)
-
-# Provide explicit __all__ for clarity
-__all__ = ["poll_meshy_task"]