Minimal 9-output function for schema debug

app.py

@@ -41,41 +41,38 @@ os.environ['PYTHONPATH'] = os.environ.get('PYTHONPATH', '') + ';.'
 
 import gradio as gr
 
-def simple_test_function(vehicle_type, user_description):
-    """Ultra simple function with only basic string outputs"""
-    if not user_description:
-        user_description = "No description provided"
+def minimal_ui_function_wrapper(vehicle_type, user_description):
+    """
+    ULTRA MINIMAL wrapper function for debugging schema validation
+    Must yield exactly 9 outputs to match the complex function:
+    process_log, current_design_specs, progress_bar, final_status, 
+    simulation_video, best_design_specs, download_json, performance_summary, llm_rationale
+    """
     
-    # Only basic string outputs to avoid any schema issues
-    result = f"""✅ DESIGN COMPLETED!
-
-🚁 Vehicle: {vehicle_type}
-📝 Description: {user_description}
-
-🎯 Design Parameters:
-• Speed: 5.2 m/s
-• Weight: 1.8 kg  
-• Dimensions: 10x8x6 cm
-• Battery: 45 min
-
-✅ Status: SUCCESS"""
-    
-    progress = "100% Complete"
-    
-    return result, progress
+    # Test with absolute minimal data types
+    yield (
+        "Minimal test: Process started.",        # process_log_output (gr.Textbox)
+        {"status": "minimal_test"},              # current_design_specs_output (gr.JSON) 
+        1,                                       # progress_bar_output (gr.Slider/Number)
+        "Minimal test: Test status.",            # final_status_output (gr.Markdown/Textbox)
+        None,                                    # simulation_video_output (gr.Image/Video)
+        {"result": "minimal_test_data"},         # best_design_specs_output (gr.JSON)
+        None,                                    # download_json_output (gr.File)
+        "Minimal test: Performance test.",       # performance_summary_output (gr.Markdown/Textbox)
+        "Minimal test: Rationale test."          # llm_rationale_output (gr.Textbox)
+    )
 
 def create_minimal_working_app():
-    """Ultra minimal app with only basic components"""
+    """Ultra minimal app for debugging schema validation"""
     
-    with gr.Blocks(title="🤖🚁 Agent2Robot") as demo:
+    with gr.Blocks(title="🤖🚁 Agent2Robot - Schema Debug") as demo:
         
-        gr.HTML("<h1>🤖🚁 Agent2Robot - Ultra Stable Version</h1>")
+        gr.HTML("<h1>🤖🚁 Agent2Robot - Schema Validation Debug</h1>")
         
         with gr.Row():
             with gr.Column():
                 gr.Markdown("## Input")
                 
-                # Most basic components only
                 vehicle_input = gr.Radio(
                     choices=["Robot", "Drone"], 
                     label="Vehicle Type",
@@ -88,33 +85,81 @@ def create_minimal_working_app():
                     value="Design a robot for obstacle navigation"
                 )
                 
-                process_button = gr.Button("🚀 Process", variant="primary")
+                debug_button = gr.Button("🔍 Debug Schema", variant="primary")
             
             with gr.Column():
-                gr.Markdown("## Results")
+                gr.Markdown("## Debug Outputs (9 components)")
+                
+                # Exactly matching the complex function's 9 outputs
+                process_log_output = gr.Textbox(
+                    label="1. Process Log",
+                    lines=3,
+                    interactive=False
+                )
+                
+                current_design_specs_output = gr.JSON(
+                    label="2. Current Design Specs",
+                    value={}
+                )
+                
+                progress_bar_output = gr.Number(
+                    label="3. Progress Bar",
+                    value=0,
+                    interactive=False
+                )
+                
+                final_status_output = gr.Textbox(
+                    label="4. Final Status",
+                    lines=2,
+                    interactive=False
+                )
+                
+                simulation_video_output = gr.Image(
+                    label="5. Simulation Video",
+                    interactive=False
+                )
+                
+                best_design_specs_output = gr.JSON(
+                    label="6. Best Design Specs",
+                    value={}
+                )
+                
+                download_json_output = gr.File(
+                    label="7. Download JSON",
+                    interactive=False
+                )
                 
-                # Only basic text outputs
-                result_output = gr.Textbox(
-                    label="Design Results",
-                    lines=12,
+                performance_summary_output = gr.Textbox(
+                    label="8. Performance Summary",
+                    lines=2,
                     interactive=False
                 )
                 
-                status_output = gr.Textbox(
-                    label="Status",
-                    lines=1,
+                llm_rationale_output = gr.Textbox(
+                    label="9. LLM Rationale",
+                    lines=2,
                     interactive=False
                 )
         
-        # Ultra simple button connection
-        process_button.click(
-            fn=simple_test_function,
+        # Connect with 9 outputs (matching complex function)
+        debug_button.click(
+            fn=minimal_ui_function_wrapper,
             inputs=[vehicle_input, description_input],
-            outputs=[result_output, status_output]
+            outputs=[
+                process_log_output,
+                current_design_specs_output,
+                progress_bar_output,
+                final_status_output,
+                simulation_video_output,
+                best_design_specs_output,
+                download_json_output,
+                performance_summary_output,
+                llm_rationale_output
+            ]
         )
         
         gr.Markdown("---")
-        gr.Markdown("**Ultra Stable Version** - Avoids all schema validation issues")
+        gr.Markdown("**Schema Debug Version** - Testing 9-output function for schema validation issues")
     
     return demo
 

ui_function_backup.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""
+BACKUP of complex ui_function_wrapper that causes schema validation issues
+This is the original function from app_backup.py that triggers:
+TypeError: argument of type 'bool' is not iterable
+"""
+
+def ui_function_wrapper(vehicle_type, user_description):
+    """
+    Main UI wrapper function that yields real-time updates to multiple Gradio components
+    Returns tuples in the order: process_log, current_design_specs, progress_bar, 
+    final_status, simulation_video, best_design_specs, download_json, 
+    performance_summary, llm_rationale
+    """
+    global designer
+    
+    # Reset designer for new task
+    designer.reset_design_session()
+    designer.vehicle_type = vehicle_type.lower()
+    designer.user_task_description = user_description
+    
+    # Initial setup - yield initial states
+    yield (
+        "🚀 Initializing Agent2Robot system...\n",  # process_log_output
+        {},  # current_design_specs_output
+        0,   # progress_bar_output
+        "",  # final_status_output
+        None,  # simulation_video_output
+        {},  # best_design_specs_output
+        None,  # download_json_output
+        "",  # performance_summary_output
+        ""   # llm_rationale_output
+    )
+    
+    # Parse user criteria
+    designer.log_process_step("🎯 Analyzing user task and success criteria...")
+    criteria = designer.parse_user_task_for_criteria(user_description)
+    
+    designer.log_process_step(f"📋 Interpreted success criteria:")
+    for criterion in criteria:
+        designer.log_process_step(f"  • {criterion}")
+    
+    # Update with criteria interpretation
+    current_log = "\n".join(designer.process_log)
+    yield (
+        current_log,  # process_log_output
+        {"interpreted_criteria": criteria},  # current_design_specs_output
+        0,  # progress_bar_output
+        "",  # final_status_output
+        None,  # simulation_video_output
+        {},  # best_design_specs_output
+        None,  # download_json_output
+        "",  # performance_summary_output
+        ""   # llm_rationale_output
+    )
+    
+    # Start design process
+    designer.log_process_step(f"🚀 Starting {vehicle_type} design process...")
+    designer.log_process_step(f"🎯 Target: {user_description}")
+    
+    current_log = "\n".join(designer.process_log)
+    yield (
+        current_log,  # process_log_output
+        {"status": "Design process starting..."},  # current_design_specs_output
+        0,  # progress_bar_output
+        "",  # final_status_output
+        None,  # simulation_video_output
+        {},  # best_design_specs_output
+        None,  # download_json_output
+        "",  # performance_summary_output
+        ""   # llm_rationale_output
+    )
+    
+    # Run iterations
+    for iteration in range(1, MAX_ITERATIONS + 1):
+        designer.log_process_step(f"\n=== Starting Iteration {iteration}/{MAX_ITERATIONS} ===")
+        
+        # Update progress at start of iteration
+        current_log = "\n".join(designer.process_log)
+        progress_value = (iteration - 0.5) / MAX_ITERATIONS * 100  # Convert to percentage
+        yield (
+            current_log,  # process_log_output
+            {"current_iteration": iteration, "max_iterations": MAX_ITERATIONS, "status": "Running..."},  # current_design_specs_output
+            progress_value,  # progress_bar_output
+            "",  # final_status_output
+            None,  # simulation_video_output
+            {},  # best_design_specs_output
+            None,  # download_json_output
+            "",  # performance_summary_output
+            ""   # llm_rationale_output
+        )
+        
+        # Run the iteration
+        try:
+            success = designer.run_single_iteration(iteration)
+            
+            # Get current design specs for display
+            if designer.all_attempts:
+                current_attempt = designer.all_attempts[-1]
+                current_specs = current_attempt['vehicle_specs']
+                design_reasoning = current_attempt.get('design_reasoning', 'No reasoning provided')
+                
+                # Update with current iteration results
+                current_log = "\n".join(designer.process_log)
+                progress_value = iteration / MAX_ITERATIONS * 100
+                
+                current_specs_display = {
+                    "iteration": iteration,
+                    "vehicle_specs": current_specs,
+                    "design_reasoning_preview": design_reasoning[:200] + "..." if len(design_reasoning) > 200 else design_reasoning,
+                    "status": "✅ SUCCESS" if success else "🔄 Completed - Evaluating..."
+                }
+                
+                yield (
+                    current_log,  # process_log_output
+                    current_specs_display,  # current_design_specs_output
+                    progress_value,  # progress_bar_output
+                    "",  # final_status_output
+                    None,  # simulation_video_output
+                    {},  # best_design_specs_output
+                    None,  # download_json_output
+                    "",  # performance_summary_output
+                    ""   # llm_rationale_output
+                )
+            
+            if success:
+                designer.log_process_step("🎉 SUCCESS! Design meets all criteria!")
+                break
+                
+        except Exception as e:
+            designer.log_process_step(f"❌ Error in iteration {iteration}: {str(e)}")
+            current_log = "\n".join(designer.process_log)
+            progress_value = iteration / MAX_ITERATIONS * 100
+            yield (
+                current_log,  # process_log_output
+                {"error": f"Iteration {iteration} failed", "details": str(e)},  # current_design_specs_output
+                progress_value,  # progress_bar_output
+                "",  # final_status_output
+                None,  # simulation_video_output
+                {},  # best_design_specs_output
+                None,  # download_json_output
+                "",  # performance_summary_output
+                ""   # llm_rationale_output
+            )
+    
+    # Generate final results
+    designer.log_process_step("📊 Generating final results and visualizations...")
+    current_log = "\n".join(designer.process_log)
+    yield (
+        current_log,  # process_log_output
+        {"status": "Generating final results..."},  # current_design_specs_output
+        100,  # progress_bar_output - complete
+        "",  # final_status_output
+        None,  # simulation_video_output
+        {},  # best_design_specs_output
+        None,  # download_json_output
+        "",  # performance_summary_output
+        ""   # llm_rationale_output
+    )
+    
+    # Prepare final outputs
+    if designer.overall_success:
+        final_status = "## 🎉 SUCCESS!\n\nThe LLM agent successfully designed a vehicle that meets all criteria!"
+        status_emoji = "✅"
+    else:
+        final_status = "## ⚠️ PROCESS COMPLETED\n\nThe agent completed all iterations. Showing best attempt found."
+        status_emoji = "🔄"
+    
+    # Get best design specs
+    best_specs = designer.best_attempt['vehicle_specs'] if designer.best_attempt else {}
+    
+    # Create visualization
+    simulation_gif_path = None
+    try:
+        simulation_gif_path = designer.create_final_visualization()
+    except Exception as e:
+        designer.log_process_step(f"⚠️ Error creating visualization: {str(e)}")
+    
+    # Format performance summary
+    if designer.best_attempt:
+        eval_results = designer.best_attempt['evaluation_results']
+        performance_summary = f"""## 📊 Performance Summary of Best Design
+
+**Iteration Found**: {designer.best_iteration}/{len(designer.all_attempts)}
+**Final Position**: {eval_results.get('final_robot_x_position', 0.0):.3f}m
+**Crossed Obstacle**: {'✅ Yes' if eval_results.get('robot_crossed_obstacle', False) else '❌ No'}
+**Remained Stable**: {'✅ Yes' if eval_results.get('robot_remains_upright', False) else '❌ No'}
+**Clean Pass**: {'✅ Yes' if eval_results.get('no_significant_collision_with_obstacle_during_pass', False) else '❌ No'}
+
+**Overall Success**: {'✅ ACHIEVED' if eval_results.get('overall_success', False) else '❌ NOT FULLY ACHIEVED'}
+
+**Target Distance**: 0.8m (obstacle clearance)
+**Achieved Distance**: {eval_results.get('final_robot_x_position', 0.0):.3f}m
+**Success Rate**: {100 if eval_results.get('overall_success', False) else 0}%
+
+{status_emoji} **Status**: {'Complete Success' if designer.overall_success else 'Best Effort'}
+"""
+    else:
+        performance_summary = "## ❌ No successful attempts recorded\n\nThe system was unable to generate valid designs."
+    
+    # Get LLM rationale
+    llm_rationale = designer.best_attempt['design_reasoning'] if designer.best_attempt else "No design reasoning available"
+    
+    # Create downloadable specs
+    download_specs_path = None
+    try:
+        download_specs_path = designer.save_design_specs_json()
+    except Exception as e:
+        designer.log_process_step(f"⚠️ Error saving specs: {str(e)}")
+    
+    # Final log update
+    designer.log_process_step(f"\n🏁 DESIGN PROCESS COMPLETED")
+    designer.log_process_step(f"📊 Total iterations: {len(designer.all_attempts)}")
+    designer.log_process_step(f"🏆 Best iteration: {designer.best_iteration}")
+    designer.log_process_step(f"✅ Overall success: {designer.overall_success}")
+    
+    final_log = "\n".join(designer.process_log)
+    
+    # Final yield with all results
+    yield (
+        final_log,  # process_log_output
+        {"final_summary": f"Process completed. {len(designer.all_attempts)} iterations run."},  # current_design_specs_output
+        100,  # progress_bar_output
+        final_status,  # final_status_output
+        simulation_gif_path,  # simulation_video_output
+        best_specs,  # best_design_specs_output
+        download_specs_path,  # download_json_output
+        performance_summary,  # performance_summary_output
+        llm_rationale  # llm_rationale_output
+    )