new model

create_thumbnail.py

@@ -0,0 +1,114 @@
+import argparse, io, math, os, sys
+from pathlib import Path
+from typing import Tuple
+
+import numpy as np, requests
+from PIL import Image
+import trimesh, pyrender
+from trimesh.transformations import translation_matrix, rotation_matrix  # NEW
+
+os.environ.setdefault("PYOPENGL_PLATFORM", "egl")
+
+
+def download_to_memory(url: str) -> bytes:
+    resp = requests.get(url, timeout=30)
+    resp.raise_for_status()
+    return resp.content
+
+
+def load_mesh(data: bytes) -> trimesh.Trimesh:
+    return trimesh.load(io.BytesIO(data), file_type="glb", force="mesh")
+
+
+def build_scene(mesh: trimesh.Trimesh) -> Tuple[pyrender.Scene, float]:
+    tm_mesh = pyrender.Mesh.from_trimesh(mesh, smooth=False)
+    scene = pyrender.Scene(bg_color=[1, 1, 1, 0])
+    scene.add(tm_mesh)
+
+    bb = mesh.bounding_box_oriented.extents          # fixed name
+    if not np.all(bb):
+        bb = mesh.extents
+    radius = np.linalg.norm(bb) * 0.6
+    return scene, radius
+
+
+def add_lighting(scene: pyrender.Scene, radius: float) -> None:
+    key  = pyrender.PointLight(color=np.ones(3), intensity=40.0)
+    fill = pyrender.PointLight(color=np.ones(3), intensity=20.0)
+    back = pyrender.PointLight(color=np.ones(3), intensity=10.0)
+
+    scene.add(key,  pose=translation_matrix([ radius,  radius,  radius]))
+    scene.add(fill, pose=translation_matrix([-radius,  radius,  radius]))
+    scene.add(back, pose=translation_matrix([     0, -radius, -radius]))
+
+
+def setup_camera(scene: pyrender.Scene, radius: float) -> None:
+    cam = pyrender.PerspectiveCamera(yfov=np.radians(45.0))
+    cam_pose = translation_matrix([0, 0, radius * 2.5])
+    scene.add(cam, pose=cam_pose)
+
+
+def render_thumbnail(scene: pyrender.Scene, size: int) -> Image.Image:
+    r = pyrender.OffscreenRenderer(viewport_width=size, viewport_height=size)
+    try:
+        color, _ = r.render(scene)
+    finally:
+        r.delete()
+    return Image.fromarray(color)
+
+
+def generate_thumbnail(url: str, out_path: Path, size: int = 512) -> None:
+    raw = download_to_memory(url)
+    mesh = load_mesh(raw)
+    
+    # Get mesh dimensions before any transformations
+    original_extents = mesh.extents
+    longest_dimension = np.max(original_extents)
+    
+    # Print dimension info
+    print(f"Mesh dimensions (X, Y, Z): {original_extents}")
+    print(f"Longest dimension: {longest_dimension:.4f}")
+    
+    # Scaling constant - you can use this to normalize models to a target size
+    target_size = 2.5  # Target longest dimension
+    scale_factor = target_size / longest_dimension
+    print(f"Scale factor to normalize to {target_size}: {scale_factor:.4f}")
+    
+    # Calculate radius BEFORE scaling for consistent camera/lighting positioning
+    bb = mesh.bounding_box_oriented.extents
+    if not np.all(bb):
+        bb = mesh.extents
+    fixed_radius = np.linalg.norm(bb) * 0.6
+    
+    mesh.apply_translation(-mesh.bounding_box.centroid)
+    
+    # Apply the scaling transformation
+    mesh.apply_scale(scale_factor)
+    
+    # Rotate 45 degrees to the left (around Y-axis)
+    rotation = rotation_matrix(np.radians(30), [0.3, -0.5, 0])
+    mesh.apply_transform(rotation)
+
+    # Build scene but use fixed radius for camera/lighting
+    tm_mesh = pyrender.Mesh.from_trimesh(mesh, smooth=False)
+    scene = pyrender.Scene(bg_color=[0.15, 0.15, 0.15, 1])  # Gray background
+    scene.add(tm_mesh)
+    
+    add_lighting(scene, fixed_radius)
+    setup_camera(scene, fixed_radius)
+    img = render_thumbnail(scene, size)
+
+    img.save(out_path, "PNG")
+    print(f"Saved thumbnail → {out_path.resolve()}")
+
+
+def parse_args(argv):
+    p = argparse.ArgumentParser(description="Render a GLB file to a PNG thumbnail")
+    p.add_argument("url"), p.add_argument("output")
+    p.add_argument("size", nargs="?", type=int, default=512)
+    return p.parse_args(argv)
+
+
+if __name__ == "__main__":
+    args = parse_args(sys.argv[1:])
+    generate_thumbnail(args.url, Path(args.output), args.size)

main.py

@@ -23,11 +23,7 @@ dev_mode = False
 class Settings:
     def __init__(self):
         self.mesh_api_key = os.getenv("MESHY_API_KEY")
-        if not self.mesh_api_key:
-            raise RuntimeError("MESHY_API_KEY environment variable not set")
         self.openai_api_key = os.getenv("OPENAI_API_KEY")
-        if not self.openai_api_key:
-            raise RuntimeError("OPENAI_API_KEY environment variable not set")
         self.stripe_secret_key = os.getenv("STRIPE_SECRET_KEY")
         if not self.stripe_secret_key:
             raise RuntimeError("STRIPE_SECRET_KEY environment variable not set")

requirements.txt

@@ -14,3 +14,7 @@ requests>=2.32.3
 PyJWT>=2.10.1
 sse-starlette>=1.3.2
 trimesh>=4.0.0
+replicate>=0.16.0
+pillow>=10.0.0
+pyrender>=0.1.40
+numpy>=1.21.0

routers/user_models.py

@@ -1,5 +1,5 @@
 from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks, UploadFile, File, Form
-from fastapi.responses import JSONResponse
+from fastapi.responses import JSONResponse, Response
 from auth import get_current_active_user, User, supabase
 import logging
 import httpx
@@ -7,16 +7,100 @@ import os
 from typing import Optional, Dict, Any
 from pydantic import BaseModel
 import base64
+from uuid import uuid4
 from services.hunyuan_service import _hunyuan_image_to_3d
+import io
+import numpy as np
+from PIL import Image
+import trimesh
+import pyrender
+from trimesh.transformations import translation_matrix, rotation_matrix
+
+# Set PyOpenGL platform for headless rendering
+os.environ.setdefault("PYOPENGL_PLATFORM", "egl")
+
+def generate_thumbnail_from_bytes(mesh_data: bytes, size: int = 512) -> bytes:
+    """
+    Generate a thumbnail image from 3D mesh bytes data.
+    
+    Args:
+        mesh_data: The 3D mesh file as bytes (GLB format)
+        size: Output image size in pixels (default 512x512)
+    
+    Returns:
+        PNG image data as bytes
+    """
+    try:
+        # Load mesh from bytes
+        mesh = trimesh.load(io.BytesIO(mesh_data), file_type="glb", force="mesh")
+        
+        # Get mesh dimensions before any transformations
+        original_extents = mesh.extents
+        longest_dimension = np.max(original_extents)
+        
+        # Scaling to normalize models to a target size
+        target_size = 2.5
+        scale_factor = target_size / longest_dimension if longest_dimension > 0 else 1.0
+        
+        # Calculate radius BEFORE scaling for consistent camera/lighting positioning
+        bb = mesh.bounding_box_oriented.extents
+        if not np.all(bb):
+            bb = mesh.extents
+        fixed_radius = np.linalg.norm(bb) * 0.6
+        
+        # Center the mesh
+        mesh.apply_translation(-mesh.bounding_box.centroid)
+        
+        # Apply scaling transformation
+        mesh.apply_scale(scale_factor)
+        
+        # Rotate for better viewing angle
+        rotation = rotation_matrix(np.radians(30), [0.3, -0.5, 0])
+        mesh.apply_transform(rotation)
+
+        # Build scene
+        tm_mesh = pyrender.Mesh.from_trimesh(mesh, smooth=False)
+        scene = pyrender.Scene(bg_color=[0.15, 0.15, 0.15, 1])  # Gray background
+        scene.add(tm_mesh)
+        
+        # Add lighting
+        key_light = pyrender.PointLight(color=np.ones(3), intensity=40.0)
+        fill_light = pyrender.PointLight(color=np.ones(3), intensity=20.0)
+        back_light = pyrender.PointLight(color=np.ones(3), intensity=10.0)
+
+        scene.add(key_light, pose=translation_matrix([fixed_radius, fixed_radius, fixed_radius]))
+        scene.add(fill_light, pose=translation_matrix([-fixed_radius, fixed_radius, fixed_radius]))
+        scene.add(back_light, pose=translation_matrix([0, -fixed_radius, -fixed_radius]))
+        
+        # Setup camera
+        cam = pyrender.PerspectiveCamera(yfov=np.radians(45.0))
+        cam_pose = translation_matrix([0, 0, fixed_radius * 2.5])
+        scene.add(cam, pose=cam_pose)
+        
+        # Render thumbnail
+        renderer = pyrender.OffscreenRenderer(viewport_width=size, viewport_height=size)
+        try:
+            color, _ = renderer.render(scene)
+        finally:
+            renderer.delete()
+        
+        # Convert to PIL Image and save as PNG bytes
+        img = Image.fromarray(color)
+        img_bytes = io.BytesIO()
+        img.save(img_bytes, format='PNG')
+        return img_bytes.getvalue()
+        
+    except Exception as e:
+        logging.error(f"Failed to generate thumbnail: {str(e)}")
+        raise
 
 router = APIRouter(
     prefix="/user/models",
-    tags=["User Models"],
-    dependencies=[Depends(get_current_active_user)]
+    tags=["User Models"]  # Removed global auth dependency; individual endpoints add it where needed
 )
 
-@router.get("/progress_update/{generated_model_id}")
-async def refresh_generated_model(generated_model_id: str, current_user: User = Depends(get_current_active_user)):
+@router.get("/progress_update/{generated_model_id}", dependencies=[])
+async def refresh_generated_model(generated_model_id: str):
     """
     Manual refresh endpoint.
 
@@ -25,25 +109,48 @@ async def refresh_generated_model(generated_model_id: str, current_user: User =
     For text-to-3d with texture, this handles the two-step process (preview + refine).
     """
     try:
-        # 1) Validate ownership & retrieve the record.
-        db_resp = supabase.from_("Generated_Models").select("*").eq("generated_model_id", generated_model_id).eq("user_id", current_user.id).single().execute()
+        # Handle placeholder IDs from frontend
+        if generated_model_id.startswith("placeholder_"):
+            raise HTTPException(status_code=400, detail="Invalid model ID. Model may not be ready yet or generation is still initializing.")
+        
+        # Validate that generated_model_id is a valid integer
+        try:
+            model_id_int = int(generated_model_id)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid model ID format. Expected numeric ID.")
+        
+        # 1) Validate existence & retrieve the record (removed ownership check for public access).
+        db_resp = supabase.from_("Generated_Models").select("*").eq("generated_model_id", model_id_int).limit(1).execute()  # .eq("user_id", current_user.id) - commented out for public access
 
         if not db_resp.data:
-            raise HTTPException(status_code=404, detail="Model not found or does not belong to user")
+            raise HTTPException(status_code=404, detail="Model not found")
 
-        generated_model = db_resp.data
+        generated_model = db_resp.data[0]
         prompts_config = generated_model.get("prompts_and_models_config", {})
         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":
+            # For completed Hunyuan models, provide the view URL for 3D display
+            model_urls = None
+            thumbnail_url = None
+            
+            if generated_model.get("status") == "COMPLETED":
+                model_urls = {
+                    "glb": f"/user/models/{model_id_int}/view.glb"  # Relative URL to our view endpoint with extension
+                }
+                # Check if thumbnail exists
+                thumbnail_check = supabase.from_("Model_Files").select("model_file_id").eq("generated_model_id", model_id_int).eq("is_preview_file", True).eq("file_format", "png").limit(1).execute()
+                if thumbnail_check.data:
+                    thumbnail_url = f"/user/models/{model_id_int}/thumbnail"
+            
             return {
-                "task_id": generated_model_id,
+                "task_id": model_id_int,
                 "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,
+                "model_urls": model_urls,
+                "thumbnail_url": thumbnail_url,
                 "texture_urls": None,
                 "created_at": generated_model.get("created_at"),
                 "started_at": generated_model.get("created_at"),
@@ -51,12 +158,42 @@ async def refresh_generated_model(generated_model_id: str, current_user: User =
                 "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..."
+                "message": "Hunyuan generation completed. 3D model ready for viewing." 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")
+            # Check if this model has files stored locally (similar to Hunyuan models) - removed ownership check for public access
+            file_check = supabase.from_("Model_Files").select("model_file_id, file_name, file_format").eq("generated_model_id", model_id_int).limit(1).execute()  # .eq("user_id", current_user.id) - commented out for public access
+            
+            if file_check.data:
+                # Model has local files - treat it like a Hunyuan model
+                model_urls = None
+                if generated_model.get("status") == "COMPLETED":
+                    # Determine file format for URL
+                    file_format = file_check.data[0].get("file_format", "glb").lower()
+                    model_urls = {
+                        file_format: f"/user/models/{model_id_int}/view.{file_format}"
+                    }
+                
+                return {
+                    "task_id": model_id_int,
+                    "status": generated_model.get("status", "IN_PROGRESS"),
+                    "progress": 100 if generated_model.get("status") == "COMPLETED" else 50,
+                    "model_urls": model_urls,
+                    "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": generation_type,
+                    "message": "Model completed. 3D model ready for viewing." if generated_model.get("status") == "COMPLETED" else "Model generation in progress..."
+                }
+            else:
+                # No local files and no Meshy task ID - this model might be incomplete or from old system
+                raise HTTPException(status_code=400, detail="Model has no associated files or Meshy task ID. This model may be incomplete or from an older system.")
 
         # 2) Query Meshy API for the latest status.
         meshy_api_key = os.getenv("MESHY_API_KEY")
@@ -69,7 +206,7 @@ async def refresh_generated_model(generated_model_id: str, current_user: User =
             # Special handling for text-to-3d with texture (two-step process)
             if generation_type == "text_to_3d" and should_texture:
                 return await _handle_text_to_3d_with_texture(
-                    generated_model_id, generated_model, prompts_config, 
+                    model_id_int, generated_model, prompts_config, 
                     meshy_task_id, meshy_api_key, client, headers
                 )
 
@@ -112,7 +249,7 @@ async def refresh_generated_model(generated_model_id: str, current_user: User =
             
             # Return the progress information along with update status
             return {
-                "task_id": generated_model_id,
+                "task_id": model_id_int,
                 "status": meshy_response.get("status"),
                 "progress": meshy_response.get("progress"),
                 "model_urls": meshy_response.get("model_urls"),
@@ -134,7 +271,7 @@ async def refresh_generated_model(generated_model_id: str, current_user: User =
 
 
 async def _handle_text_to_3d_with_texture(
-    generated_model_id: str,
+    generated_model_id: int,
     generated_model: Dict[str, Any],
     prompts_config: Dict[str, Any],
     preview_task_id: str,
@@ -466,6 +603,14 @@ async def _process_hunyuan_image_to_3d_background(generated_model_id: int, image
         file_format = file_name.split(".")[-1].lower()
         file_size = len(mesh_data)
 
+        # Generate thumbnail from the mesh data
+        thumbnail_data = None
+        try:
+            thumbnail_data = generate_thumbnail_from_bytes(mesh_data, size=512)
+            logging.info(f"Successfully generated thumbnail for model {generated_model_id}")
+        except Exception as ex:
+            logging.error(f"Failed to generate thumbnail for model {generated_model_id}: {ex}")
+
         # Update DB record with Hunyuan response
         supabase.from_("Generated_Models").update({
             "status": "COMPLETED",
@@ -473,11 +618,14 @@ async def _process_hunyuan_image_to_3d_background(generated_model_id: int, image
             "prompts_and_models_config": hunyuan_response,
         }).eq("generated_model_id", generated_model_id).execute()
 
+        # Convert binary data to Postgres bytea hex format ("\\x" prefix) for safe insertion
+        encoded_hex_data = "\\x" + mesh_data.hex()
+
         # 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,
+            "model_data": encoded_hex_data,  # stored as hex string compatible with bytea
             "file_name": file_name,
             "file_format": file_format,
             "file_size": file_size,
@@ -485,6 +633,28 @@ async def _process_hunyuan_image_to_3d_background(generated_model_id: int, image
             "is_preview_file": False,
         }).execute()
 
+        # Insert the thumbnail if generation was successful
+        if thumbnail_data:
+            try:
+                # Convert thumbnail bytes to hex format for Postgres bytea
+                thumbnail_hex_data = "\\x" + thumbnail_data.hex()
+                thumbnail_file_name = f"thumbnail_{generated_model_id}.png"
+                
+                supabase.from_("Model_Files").insert({
+                    "user_id": user_id,
+                    "generated_model_id": generated_model_id,
+                    "model_data": thumbnail_hex_data,
+                    "file_name": thumbnail_file_name,
+                    "file_format": "png",
+                    "file_size": len(thumbnail_data),
+                    "metadata": "Generated thumbnail image for 3D model preview",
+                    "is_preview_file": True,  # Flag to indicate this is a thumbnail/preview
+                }).execute()
+                
+                logging.info(f"Successfully stored thumbnail for model {generated_model_id}")
+            except Exception as ex:
+                logging.error(f"Failed to store thumbnail for model {generated_model_id}: {ex}")
+
         logging.info(f"Successfully completed Hunyuan image-to-3d generation for model {generated_model_id}")
         
     except Exception as ex:
@@ -617,26 +787,88 @@ async def text_to_3d(prompt: TextPrompt, background_tasks: BackgroundTasks, curr
 @router.post("/image-to-3d")
 async def image_to_3d(
     background_tasks: BackgroundTasks,
-    image_url: str,
+    image: UploadFile = File(None),
+    image_url: Optional[str] = Form(None),
     current_user: User = Depends(get_current_active_user),
 ):
     """
-    Create a Hunyuan3D Image-to-3D generation job using Replicate API.
+    Create a Hunyuan3D Image-to-3D generation job.
 
-    Returns immediately after creating the database record. Hunyuan API call 
-    and mesh file download happen in the background.
+    The client can either:
+    1. Upload an image file (multipart/form-data) via the "image" field
+    2. Provide an already publicly accessible URL via the "image_url" form field
+
+    If a file is uploaded we first store it in Supabase Storage and use the
+    resulting public URL when triggering the Hunyuan job.
     """
-    
+
+    # Validate input – at least one source must be provided
+    if image is None and not image_url:
+        raise HTTPException(status_code=400, detail="Either an image file or image_url must be provided")
+
+    # If we received an image file, upload it to Supabase Storage to obtain a public URL
+    if image is not None:
+        content = await image.read()
+        if not content:
+            raise HTTPException(status_code=400, detail="Uploaded image is empty")
+
+        file_ext = os.path.splitext(image.filename)[1] or ".jpg"
+        unique_name = f"{uuid4().hex}{file_ext}"
+        # Determine bucket name (hard-coded to avoid missing env vars)
+        bucket_name = "hunyuan-inputs"  # storage bucket for Hunyuan inputs
+
+        try:
+            # Upload bytes to Supabase Storage
+            upload_resp = supabase.storage.from_(bucket_name).upload(
+                unique_name,
+                content,
+                {"content-type": image.content_type or "application/octet-stream"},
+            )
+
+            # Handle both supabase-py <2.0 (dict response) and >=2.0 (UploadResponse object)
+            upload_error = None
+            if isinstance(upload_resp, dict):
+                upload_error = upload_resp.get("error")
+            elif hasattr(upload_resp, "error"):
+                upload_error = upload_resp.error
+
+            if upload_error:
+                # Ensure we always raise a string for logging / HTTPException
+                raise RuntimeError(str(upload_error))
+
+            public_url_resp = supabase.storage.from_(bucket_name).get_public_url(unique_name)
+
+            # Similar compatibility handling for get_public_url()
+            if isinstance(public_url_resp, str):
+                image_url = public_url_resp
+            elif isinstance(public_url_resp, dict):
+                image_url = public_url_resp.get("publicURL") or public_url_resp.get("publicUrl")
+            elif hasattr(public_url_resp, "data") and isinstance(public_url_resp.data, dict):
+                image_url = public_url_resp.data.get("publicURL") or public_url_resp.data.get("publicUrl")
+            else:
+                image_url = None
+            if not image_url:
+                raise RuntimeError("Failed to retrieve public URL for uploaded image")
+        except Exception as ex:
+            logging.error(f"Failed to upload image to Supabase storage: {ex}")
+            raise HTTPException(status_code=500, detail="Failed to upload image to storage")
+
+    # At this point, image_url should be a publicly accessible URL
+    if not image_url:
+        raise HTTPException(status_code=400, detail="Could not determine image URL")
+
     # Credit check and decrement - Hunyuan generation costs 2 credits
     await _check_and_decrement_credits(current_user.id, 2)
 
+    source_name = image.filename if image is not None else (image_url.split('/')[-1] if '/' in image_url else 'image')
+
     # 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'}",
+            "model_name": f"Hunyuan 3D from {source_name}",
             "prompts_and_models_config": {
                 "generation_type": "hunyuan_image_to_3d",
                 "input_image_url": image_url,
@@ -645,10 +877,10 @@ async def image_to_3d(
             },
         }).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,
@@ -656,216 +888,57 @@ async def image_to_3d(
             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(
-    background_tasks: BackgroundTasks,
-    file: UploadFile = File(...),
-    should_texture: bool = Form(False),
-    current_user: User = Depends(get_current_active_user),
-):
-    """Upload an image file and create a Meshy *Image-to-3D* task.
-
-    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
-    await _check_and_decrement_credits(current_user.id, credit_cost)
-
-    # 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"
-        b64 = base64.b64encode(file_bytes).decode("utf-8")
-        data_uri = f"data:{mime_type};base64,{b64}"
-    except Exception as ex:
-        raise HTTPException(status_code=400, detail=f"Failed to read uploaded file: {ex}")
-
-    # 3. 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"{file.filename}",
-            "prompts_and_models_config": {
-                "generation_type": "image_to_3d",
-                "input_image_filename": file.filename,
-                "status": "initializing",
-                "stage": "uploading_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")
-
-        # Build payload – only include "should_texture": False when texture is NOT requested
-        payload: Dict[str, Any] = {
-            "image_url": data_uri,
-            "mode": "preview",
-            "ai_model": "meshy-5",
+            "message": "Hunyuan 3D generation started. Use the progress_update endpoint to check status.",
         }
 
-        if not should_texture:
-            # Explicitly disable texturing when the user hasn't requested it
-            payload["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")
+        logging.info(f"Returning response for hunyuan image-to-3d: {response_data}")
 
-        # Return immediately with explicit headers
-        response_data = {
-            "generated_model_id": generated_model_id,
-            "status": "initializing",
-            "input_image_filename": file.filename,
-            "message": "Generation started. Use the progress_update endpoint to check status."
-        }
-        
-        logging.info(f"Returning response for image-to-3d/upload: {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("/multi-image-to-3d")
-async def multi_image_to_3d_upload(
-    background_tasks: BackgroundTasks,
-    files: list[UploadFile] = File(...),
-    should_texture: bool = Form(False),
-    current_user: User = Depends(get_current_active_user),
-):
-    """Upload multiple image files and create a Meshy *Multi-Image-to-3D* task.
-
-    Returns immediately after creating the database record and encoding the images.
-    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
-    await _check_and_decrement_credits(current_user.id, credit_cost)
-
-    # 2. Validate we have at least 2 images (typical requirement for multi-image)
-    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 (this is reasonably fast, so we do it synchronously)
-    try:
-        image_urls = []
-        filenames = []
-        for file in files:
-            file_bytes = await file.read()
-            mime_type = file.content_type or "image/png"
-            b64 = base64.b64encode(file_bytes).decode("utf-8")
-            data_uri = f"data:{mime_type};base64,{b64}"
-            image_urls.append(data_uri)
-            filenames.append(file.filename)
-    except Exception as ex:
-        raise HTTPException(status_code=400, detail=f"Failed to read uploaded files: {ex}")
-
-    # 4. 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"Multi-Image to 3D - {', '.join(filenames)}",
-            "prompts_and_models_config": {
-                "generation_type": "multi_image_to_3d",
-                "input_image_filenames": filenames,
-                "should_texture": should_texture,
-                "status": "initializing",
-                "stage": "uploading_images",
-            },
-        }).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",
-        }
-
-        if not should_texture:
-            payload["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 with explicit headers
-        response_data = {
-            "generated_model_id": generated_model_id,
-            "status": "initializing",
-            "input_image_filenames": filenames,
-            "message": "Generation started. Use the progress_update endpoint to check status."
-        }
-        
-        logging.info(f"Returning response for multi-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.get("/{generated_model_id}/file")
 async def get_model_file(
-    generated_model_id: str,
-    current_user: User = Depends(get_current_active_user)
+    generated_model_id: str
 ):
     """
     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()
+        # Handle placeholder IDs and validate integer format
+        if generated_model_id.startswith("placeholder_"):
+            raise HTTPException(status_code=400, detail="Invalid model ID. Model may not be ready yet or generation is still initializing.")
+        
+        try:
+            model_id_int = int(generated_model_id)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid model ID format. Expected numeric ID.")
+        
+        # First check if the model exists (removed user ownership check for public access)
+        model_check = supabase.from_("Generated_Models").select("generated_model_id, user_id, model_name").eq("generated_model_id", model_id_int).limit(1).execute()  # .eq("user_id", current_user.id) - commented out for public access
         
         if not model_check.data:
-            raise HTTPException(status_code=404, detail="Model not found or you do not have permission to access it.")
+            raise HTTPException(status_code=404, detail="Model not found.")
         
-        # 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()
+        # Get the single model file for this generated model (removed ownership verification for public access)
+        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", model_id_int).limit(1).execute()  # .eq("user_id", current_user.id) - commented out for public access
         
         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
+            "model_name": model_check.data[0].get("model_name"),
+            "file": file_result.data[0]
         }
         
     except HTTPException:
@@ -877,35 +950,54 @@ async def get_model_file(
 
 @router.get("/{generated_model_id}/download")
 async def download_model_file(
-    generated_model_id: str,
-    current_user: User = Depends(get_current_active_user)
+    generated_model_id: str
 ):
     """
     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()
+        # Handle placeholder IDs and validate integer format
+        if generated_model_id.startswith("placeholder_"):
+            raise HTTPException(status_code=400, detail="Invalid model ID. Model may not be ready yet or generation is still initializing.")
+        
+        try:
+            model_id_int = int(generated_model_id)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid model ID format. Expected numeric ID.")
+        
+        # First check if the model exists (removed user ownership check for public access)
+        model_check = supabase.from_("Generated_Models").select("generated_model_id, user_id, model_name").eq("generated_model_id", model_id_int).limit(1).execute()  # .eq("user_id", current_user.id) - commented out for public access
         
         if not model_check.data:
-            raise HTTPException(status_code=404, detail="Model not found or you do not have permission to access it.")
+            raise HTTPException(status_code=404, detail="Model not found.")
         
-        # 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()
+        # Get the model file (removed ownership verification for public access)
+        file_result = supabase.from_("Model_Files").select("*").eq("generated_model_id", model_id_int).limit(1).execute()  # .eq("user_id", current_user.id) - commented out for public access
         
         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
-        
+        file_data = file_result.data[0]
+
+        # Supabase stores bytea as base64-encoded strings; decode before sending.
+        raw_data = file_data.get("model_data")
+        if isinstance(raw_data, str):
+            try:
+                # Attempt base64 decode
+                raw_data = base64.b64decode(raw_data)
+            except Exception:
+                # Fallback for hex format ("\\x" prefix)
+                if raw_data.startswith("\\x"):
+                    raw_data = bytes.fromhex(raw_data[2:])
+
+        if raw_data is None:
+            raise HTTPException(status_code=500, detail="Failed to decode model file data.")
+
         return Response(
-            content=file_data["model_data"],
+            content=raw_data,
             media_type="application/octet-stream",
             headers={
-                "Content-Disposition": f"attachment; filename={file_data['file_name']}",
-                "Content-Length": str(file_data["file_size"])
+                "Content-Disposition": f"attachment; filename={file_data['file_name']}"
             }
         )
         
@@ -916,23 +1008,188 @@ async def download_model_file(
         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}")
+@router.get("/{generated_model_id}/view")
+async def view_model_file(
+    generated_model_id: str
+):
+    """
+    Serve the 3D model file inline for frontend 3D viewers.
+    This endpoint serves the file with appropriate headers for direct consumption by 3D libraries.
+    """
+    print("view_model_file")
+    try:
+        # Handle placeholder IDs and validate integer format
+        if generated_model_id.startswith("placeholder_"):
+            raise HTTPException(status_code=400, detail="Invalid model ID. Model may not be ready yet or generation is still initializing.")
+        
+        try:
+            model_id_int = int(generated_model_id)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid model ID format. Expected numeric ID.")
+        
+        # First check if the model exists (removed user ownership check for public access)
+        model_check = supabase.from_("Generated_Models").select("generated_model_id, user_id, model_name").eq("generated_model_id", model_id_int).limit(1).execute()  # .eq("user_id", current_user.id) - commented out for public access
+        
+        if not model_check.data:
+            raise HTTPException(status_code=404, detail="Model not found.")
+        
+        # Get the model file (removed ownership verification for public access)
+        file_result = supabase.from_("Model_Files").select("*").eq("generated_model_id", model_id_int).limit(1).execute()  # .eq("user_id", current_user.id) - commented out for public access
+        
+        if not file_result.data:
+            raise HTTPException(status_code=404, detail="No model file found for this generated model.")
+        
+        file_data = file_result.data[0]
+
+        # Supabase stores bytea as base64-encoded strings; decode before sending.
+        raw_data = file_data.get("model_data")
+        if isinstance(raw_data, str):
+            try:
+                # Attempt base64 decode
+                raw_data = base64.b64decode(raw_data)
+            except Exception:
+                # Fallback for hex format ("\\x" prefix)
+                if raw_data.startswith("\\x"):
+                    raw_data = bytes.fromhex(raw_data[2:])
+
+        if raw_data is None:
+            raise HTTPException(status_code=500, detail="Failed to decode model file data.")
+
+        # Determine appropriate MIME type based on file format
+        file_format = file_data.get("file_format", "").lower()
+        content_type = "application/octet-stream"  # Default fallback
+        
+        if file_format == "glb":
+            content_type = "model/gltf-binary"
+        elif file_format == "gltf":
+            content_type = "model/gltf+json"
+        elif file_format == "obj":
+            content_type = "text/plain"  # OBJ files are text-based
+        elif file_format == "stl":
+            content_type = "model/stl"
+        elif file_format == "fbx":
+            content_type = "application/octet-stream"
+        
+        return Response(
+            content=raw_data,
+            media_type=content_type,
+            headers={
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": "GET, HEAD, OPTIONS",
+                "Access-Control-Allow-Headers": "Authorization, Content-Type",
+                "Cache-Control": "public, max-age=3600"  # Cache for 1 hour
+            }
+        )
+        
+    except HTTPException:
+        # Re-raise HTTP exceptions as-is
+        raise
+    except Exception as e:
+        logging.error(f"Failed to serve model file for {generated_model_id}: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+# Allow URLs like /user/models/{id}/view.glb or .gltf etc.
+@router.get("/{generated_model_id}/view.{file_ext}")
+async def view_model_file_with_ext(generated_model_id: str, file_ext: str):
+    """Proxy to view_model_file to serve model regardless of extension in URL."""
+    return await view_model_file(generated_model_id)
+
+@router.get("/{generated_model_id}/thumbnail")
+async def get_model_thumbnail(generated_model_id: str):
+    """
+    Serve the thumbnail image for a generated model.
+    Returns a PNG image that can be displayed in the frontend for model previews.
+    """
+    try:
+        # Handle placeholder IDs and validate integer format
+        if generated_model_id.startswith("placeholder_"):
+            raise HTTPException(status_code=400, detail="Invalid model ID. Model may not be ready yet or generation is still initializing.")
+        
+        try:
+            model_id_int = int(generated_model_id)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid model ID format. Expected numeric ID.")
+        
+        # First check if the model exists (removed user ownership check for public access)
+        model_check = supabase.from_("Generated_Models").select("generated_model_id, user_id, model_name").eq("generated_model_id", model_id_int).limit(1).execute()
+        
+        if not model_check.data:
+            raise HTTPException(status_code=404, detail="Model not found.")
+        
+        # Get the thumbnail file (removed ownership verification for public access)
+        thumbnail_result = supabase.from_("Model_Files").select("*").eq("generated_model_id", model_id_int).eq("is_preview_file", True).eq("file_format", "png").limit(1).execute()
+        
+        if not thumbnail_result.data:
+            raise HTTPException(status_code=404, detail="No thumbnail found for this model.")
+        
+        thumbnail_data = thumbnail_result.data[0]
+
+        # Decode the thumbnail data
+        raw_data = thumbnail_data.get("model_data")
+        if isinstance(raw_data, str):
+            try:
+                # Attempt base64 decode
+                raw_data = base64.b64decode(raw_data)
+            except Exception:
+                # Fallback for hex format ("\\x" prefix)
+                if raw_data.startswith("\\x"):
+                    raw_data = bytes.fromhex(raw_data[2:])
+
+        if raw_data is None:
+            raise HTTPException(status_code=500, detail="Failed to decode thumbnail data.")
+
+        return Response(
+            content=raw_data,
+            media_type="image/png",
+            headers={
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": "GET, HEAD, OPTIONS",
+                "Access-Control-Allow-Headers": "Authorization, Content-Type",
+                "Cache-Control": "public, max-age=3600"  # Cache for 1 hour
+            }
+        )
+        
+    except HTTPException:
+        # Re-raise HTTP exceptions as-is
+        raise
+    except Exception as e:
+        logging.error(f"Failed to serve thumbnail for {generated_model_id}: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+@router.delete("/{generated_model_id}", dependencies=[Depends(get_current_active_user)])
 async def delete_model(
     generated_model_id: str,
     current_user: User = Depends(get_current_active_user)
 ):
     """
-    Delete a generated model for the current user.
+    Delete a generated model and its associated files for the current user.
     """
     try:
+        # Handle placeholder IDs and validate integer format
+        if generated_model_id.startswith("placeholder_"):
+            raise HTTPException(status_code=400, detail="Invalid model ID. Model may not be ready yet or generation is still initializing.")
+        
+        try:
+            model_id_int = int(generated_model_id)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid model ID format. Expected numeric ID.")
+        
         # 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()
+        model_check = supabase.from_("Generated_Models").select("generated_model_id, user_id, model_name").eq("generated_model_id", model_id_int).eq("user_id", current_user.id).limit(1).execute()
         
         if not model_check.data:
             raise HTTPException(status_code=404, detail="Model not found or you do not have permission to delete it.")
         
-        # Delete the model
-        delete_result = supabase.from_("Generated_Models").delete().eq("generated_model_id", generated_model_id).eq("user_id", current_user.id).execute()
+        # Delete associated model files first
+        files_delete_result = supabase.from_("Model_Files").delete().eq("generated_model_id", model_id_int).eq("user_id", current_user.id).execute()
+        
+        # Log how many files were deleted
+        files_deleted_count = len(files_delete_result.data) if files_delete_result.data else 0
+        if files_deleted_count > 0:
+            logging.info(f"Deleted {files_deleted_count} model file(s) for model {generated_model_id}")
+        
+        # Delete the model record
+        delete_result = supabase.from_("Generated_Models").delete().eq("generated_model_id", model_id_int).eq("user_id", current_user.id).execute()
 
         # The delete operation should return the deleted record(s)
         if not delete_result.data:
@@ -941,9 +1198,10 @@ async def delete_model(
         logging.info(f"Successfully deleted model {generated_model_id} for user {current_user.id}")
         
         return {
-            "message": "Model deleted successfully.",
+            "message": "Model and associated files deleted successfully.",
             "deleted_model_id": generated_model_id,
-            "model_name": model_check.data.get("model_name", "Unknown")
+            "model_name": model_check.data[0].get("model_name", "Unknown"),
+            "files_deleted": files_deleted_count
         }
         
     except HTTPException:

services/hunyuan_service.py

@@ -1,10 +1,24 @@
 from auth import supabase
 from fastapi import HTTPException
-import requests
 import os
+import time
+
+# NOTE: We now use the official Replicate SDK instead of manual HTTP requests.
+import replicate
 
 REPLICATE_API_TOKEN = os.getenv("REPLICATE_API_TOKEN")
 
+# Debug mode configuration: When `HUNYUAN_DEBUG_MODE` is set to a truthy value ("1", "true", "yes"),
+# the `_hunyuan_image_to_3d` helper will bypass the Replicate API call and instead return a
+# deterministic payload that contains a known mesh URL. This makes local development and CI
+# easier because it avoids external network calls and removes the dependency on valid API
+# credentials or available credits.
+
+HUNYUAN_DEBUG_MODE = False
+
+# Constant mesh URL used in debug mode (sourced from `test_hunyuan_service.py`).
+DEBUG_MESH_URL = "https://replicate.delivery/xezq/JzB2nOPjM5pXEJk7NC7gcMU12bz3a6tKS4e3fVCpotbstFfpA/gray_mesh.glb"
+
 def _credit_check_decrement(user_id: str, cost: int = 1) -> bool:
 
     user_credit = (
@@ -30,31 +44,59 @@ def _credit_check_decrement(user_id: str, cost: int = 1) -> bool:
     return True
 
 def _hunyuan_image_to_3d(image_url: str) -> dict:
+    # If debug mode is enabled, return a stub response immediately.
+    print(f"HUNYUAN_DEBUG_MODE: {HUNYUAN_DEBUG_MODE}")
+    if HUNYUAN_DEBUG_MODE:
+        time.sleep(10)
+        print("Returning debug mesh")
+        return {
+            "mesh": DEBUG_MESH_URL,
+            "status": "succeeded",
+            "is_debug": True,
+            "input": {"image": image_url},
+        }
+
     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,
-        }
+
+    # Build the input payload expected by the Hunyuan3D model
+    model_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,
-    )
+    try:
+        # Instantiate a dedicated Replicate client to avoid relying solely on env var side-effects
+        client = replicate.Client(api_token=REPLICATE_API_TOKEN)
 
-    if response.status_code != 200:
-        raise HTTPException(status_code=response.status_code, detail=f"Replicate API error: {response.text}")
-    
-    return response.json()
+        # Run the inference synchronously (Replicate waits by default here)
+        raw_output = client.run(
+            "tencent/hunyuan3d-2:b1b9449a1277e10402781c5d41eb30c0a0683504fb23fab591ca9dfc2aabe1cb",
+            input=model_input,
+        )
+
+        # The output is a dict containing a `mesh` FileOutput object. Convert it to a plain URL string.
+        if isinstance(raw_output, dict) and "mesh" in raw_output:
+            mesh_url = str(raw_output["mesh"])
+            sanitized_output = {**raw_output, "mesh": mesh_url}
+        else:
+            mesh_url = None
+            sanitized_output = raw_output
+
+        if not mesh_url:
+            raise ValueError("No 'mesh' field found in Replicate output")
+
+        # Return a response compatible with the existing background handler
+        return {
+            "mesh": mesh_url,
+            "status": "succeeded",
+            "input": model_input,
+            "output": sanitized_output,  # mesh field now guaranteed to be str
+        }
+
+    except Exception as err:
+        # Wrap any error from the Replicate SDK into an HTTPException so the caller gets proper feedback
+        raise HTTPException(status_code=500, detail=f"Replicate SDK error: {err}")

test_hunyuan_service.py

@@ -0,0 +1,21 @@
+import replicate
+
+input = {
+    "image": "https://blhjlpokxsdalllewjbx.supabase.co/storage/v1/object/public/hunyuan-inputs//bda24d1443ca45ff886fb582908acfc9.jpg"
+}
+
+# Run the model
+output = replicate.run(
+    "tencent/hunyuan3d-2:b1b9449a1277e10402781c5d41eb30c0a0683504fb23fab591ca9dfc2aabe1cb",
+    input=input
+)
+
+# The model returns a dict; grab the mesh file object
+mesh_file = output["mesh"]           # type: replicate.FileOutput
+
+# 1) Option A – just get the URL
+print("Mesh URL:", str(mesh_file))
+
+# 2) Option B – download it
+local_path = mesh_file.download("mesh.obj")   # saves to ./mesh.obj (returns the path)
+print("Saved locally to:", local_path)