keep it all in GRadio no passing state

app.py

@@ -140,20 +140,18 @@ def text_to_3d(
     # Convert to serializable format
     serializable_state = json.loads(json.dumps(state, cls=NumpyEncoder))
     
-    print(f"[{req.session_hash}] text_to_3d completed. Intended state generated.") # Add logging
+    print(f"[{req.session_hash}] text_to_3d completed. Returning state.") # Modified log message
     
     torch.cuda.empty_cache()
+        
+    # --- REVERTED DEBUGGING --- 
+    # Remove the temporary simple dictionary return
+    # print("[DEBUG] Returning simple dict for API test.")
+    # return {"status": "test_success", "received_prompt": prompt}
+    # --- END REVERTED DEBUGGING ---
     
-    # --- TEMPORARY DEBUGGING --- 
-    # Instead of returning the complex state, return a simple dictionary.
-    # This tests if the API mechanism itself can return *any* data.
-    # REMEMBER TO REVERT THIS AFTER TESTING!
-    print("[DEBUG] Returning simple dict for API test.")
-    return {"status": "test_success", "received_prompt": prompt}
-    # --- END TEMPORARY DEBUGGING ---
-    
-    # Original return line (commented out for test):
-    # return serializable_state # MODIFIED: Return only state
+    # Original return line (restored):
+    return serializable_state # MODIFIED: Return only state
 
 # --- NEW FUNCTION ---
 @spaces.GPU
@@ -258,6 +256,91 @@ def extract_gaussian(state: dict, req: gr.Request) -> Tuple[str, str]:
     return gaussian_path, gaussian_path
 
 
+# --- NEW COMBINED API FUNCTION ---
+@spaces.GPU(duration=120) # Allow more time for combined generation + extraction
+def generate_and_extract_glb(
+    # Inputs mirror text_to_3d and extract_glb settings
+    prompt: str,
+    seed: int,
+    ss_guidance_strength: float,
+    ss_sampling_steps: int,
+    slat_guidance_strength: float,
+    slat_sampling_steps: int,
+    mesh_simplify: float, # Added from extract_glb
+    texture_size: int,    # Added from extract_glb
+    req: gr.Request,
+) -> str: # MODIFIED: Returns only the final GLB path string
+    """
+    Combines 3D model generation and GLB extraction into a single step 
+    for API usage, avoiding the need to transfer the state object.
+    
+    Args:
+        prompt (str): Text prompt for generation.
+        seed (int): Random seed.
+        ss_guidance_strength (float): Sparse structure guidance.
+        ss_sampling_steps (int): Sparse structure steps.
+        slat_guidance_strength (float): Structured latent guidance.
+        slat_sampling_steps (int): Structured latent steps.
+        mesh_simplify (float): Mesh simplification factor for GLB.
+        texture_size (int): Texture resolution for GLB.
+        req (gr.Request): Gradio request object.
+        
+    Returns:
+        str: The absolute path to the generated GLB file within the Space's filesystem.
+             Returns None if any step fails.
+    """
+    user_dir = os.path.join(TMP_DIR, str(req.session_hash))
+    os.makedirs(user_dir, exist_ok=True)
+    
+    print(f"[{req.session_hash}] API: Starting combined generation and extraction for prompt: {prompt}")
+    
+    # --- Step 1: Generate 3D Model (adapted from text_to_3d) ---
+    try:
+        print(f"[{req.session_hash}] API: Running generation pipeline...")
+        outputs = pipeline.run(
+            prompt,
+            seed=seed,
+            formats=["gaussian", "mesh"], # Need both for GLB extraction
+            sparse_structure_sampler_params={
+                "steps": ss_sampling_steps,
+                "cfg_strength": ss_guidance_strength,
+            },
+            slat_sampler_params={
+                "steps": slat_sampling_steps,
+                "cfg_strength": slat_guidance_strength,
+            },
+        )
+        # Keep handles to the direct outputs (no need to pack/unpack state)
+        gs_output = outputs['gaussian'][0]
+        mesh_output = outputs['mesh'][0]
+        print(f"[{req.session_hash}] API: Generation pipeline completed.")
+    except Exception as e:
+        print(f"[{req.session_hash}] API: ERROR during generation pipeline: {e}")
+        traceback.print_exc() 
+        torch.cuda.empty_cache()
+        return None # Return None on failure
+        
+    # --- Step 2: Extract GLB (adapted from extract_glb) ---
+    try:
+        print(f"[{req.session_hash}] API: Extracting GLB (simplify={mesh_simplify}, texture={texture_size})...")
+        # Directly use the outputs from the pipeline
+        glb = postprocessing_utils.to_glb(gs_output, mesh_output, simplify=mesh_simplify, texture_size=texture_size, verbose=False)
+        glb_path = os.path.join(user_dir, 'api_generated_sample.glb') # Use a distinct name for API outputs
+        print(f"[{req.session_hash}] API: Saving GLB to {glb_path}")
+        glb.export(glb_path)
+        print(f"[{req.session_hash}] API: GLB extraction completed.")
+    except Exception as e:
+        print(f"[{req.session_hash}] API: ERROR during GLB extraction: {e}")
+        traceback.print_exc()
+        torch.cuda.empty_cache()
+        return None # Return None on failure
+
+    torch.cuda.empty_cache()
+    print(f"[{req.session_hash}] API: Combined process successful. Returning GLB path: {glb_path}")
+    return glb_path # Return only the path to the generated GLB
+# --- END NEW COMBINED API FUNCTION ---
+
+
 # State object to hold the generated model info between steps
 output_buf = gr.State() 
 # Video component placeholder (will be populated by render_preview_video)
@@ -383,6 +466,25 @@ with gr.Blocks(delete_cache=(600, 600)) as demo:
         outputs=[download_glb, download_gs], # Disable both download buttons
     )
     
+    # --- NEW API ENDPOINT DEFINITION ---
+    # Define the combined function as an API endpoint. 
+    # This is *separate* from the UI button clicks.
+    # It directly calls the combined function.
+    demo.load(
+        None, # No function needed on load for this endpoint
+        inputs=[
+            text_prompt, # Map inputs from API request data based on order
+            seed,
+            ss_guidance_strength,
+            ss_sampling_steps,
+            slat_guidance_strength,
+            slat_sampling_steps,
+            mesh_simplify,
+            texture_size
+        ],
+        outputs=None, # Output is handled by the function return for the API
+        api_name="generate_and_extract_glb" # Assign the specific API name
+    )
 
 # --- Launch the Gradio app ---
 if __name__ == "__main__":