Finalize th rest of the files

demo_mcp_usage.py

@@ -0,0 +1,357 @@
+#!/usr/bin/env python3
+"""
+Demo script showcasing MCP server integration for LLM-Agent-Designed Vehicle System
+
+This script demonstrates how to interact with our MCP server to design robots and drones
+for obstacle crossing using the Model Context Protocol.
+"""
+
+import asyncio
+import json
+import time
+from typing import Dict, Any
+
+# Note: In a real implementation, you would use the actual MCP client
+# For demo purposes, we'll simulate the MCP calls by importing our server directly
+import mcp_server
+
+class MCPDemoClient:
+    """Simulated MCP client for demonstration purposes"""
+    
+    def __init__(self):
+        self.server = mcp_server  # Direct import for demo
+        
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Simulate MCP tool call"""
+        print(f"🔧 Calling MCP tool: {tool_name}")
+        print(f"📊 Arguments: {json.dumps(arguments, indent=2)}")
+        print("─" * 50)
+        
+        # Call the actual tool function
+        tool_func = getattr(self.server, tool_name, None)
+        if tool_func:
+            result = tool_func(**arguments)
+            return result
+        else:
+            return {"error": f"Tool {tool_name} not found"}
+
+async def demo_obstacle_info():
+    """Demo: Get obstacle information"""
+    print("🎯 DEMO 1: Getting Obstacle Information")
+    print("=" * 60)
+    
+    client = MCPDemoClient()
+    result = await client.call_tool("get_obstacle_info", {})
+    
+    print("✅ Obstacle Information:")
+    print(json.dumps(result, indent=2))
+    print("\n")
+
+async def demo_design_parameters():
+    """Demo: Get design parameters for robots and drones"""
+    print("🔧 DEMO 2: Getting Design Parameters")
+    print("=" * 60)
+    
+    client = MCPDemoClient()
+    
+    # Get robot parameters
+    print("🤖 Robot Design Parameters:")
+    robot_params = await client.call_tool("get_design_parameters", {"vehicle_type": "robot"})
+    print(json.dumps(robot_params, indent=2))
+    print()
+    
+    # Get drone parameters
+    print("🚁 Drone Design Parameters:")
+    drone_params = await client.call_tool("get_design_parameters", {"vehicle_type": "drone"})
+    print(json.dumps(drone_params, indent=2))
+    print("\n")
+
+async def demo_robot_design():
+    """Demo: Design and simulate a robot"""
+    print("🤖 DEMO 3: Robot Design and Simulation")
+    print("=" * 60)
+    
+    client = MCPDemoClient()
+    
+    # Design a robot
+    robot_specs = {
+        "wheel_type": "large_smooth",
+        "body_clearance_cm": 7,
+        "approach_sensor_enabled": True,
+        "main_material": "light_plastic"
+    }
+    
+    design_result = await client.call_tool("design_vehicle", {
+        "vehicle_type": "robot",
+        "specifications": robot_specs,
+        "design_reasoning": "Large smooth wheels for obstacle climbing, moderate clearance for 5cm obstacle, light material for mobility"
+    })
+    
+    print("✅ Robot Design Result:")
+    print(json.dumps(design_result, indent=2))
+    print()
+    
+    if design_result.get("success"):
+        # Simulate the robot
+        print("🏃 Running robot simulation...")
+        sim_result = await client.call_tool("simulate_vehicle", {
+            "vehicle_type": "robot",
+            "specifications": robot_specs,
+            "simulation_duration": 5.0
+        })
+        
+        print("✅ Simulation Result:")
+        print(json.dumps(sim_result, indent=2))
+        print()
+        
+        if sim_result.get("success"):
+            # Evaluate performance
+            print("📊 Evaluating robot performance...")
+            eval_result = await client.call_tool("evaluate_performance", {
+                "simulation_feedback": sim_result["simulation_feedback"]
+            })
+            
+            print("✅ Evaluation Result:")
+            print(json.dumps(eval_result, indent=2))
+            
+            if eval_result.get("success"):
+                success_criteria = eval_result["success_criteria"]
+                print(f"\n🎯 Performance Summary:")
+                print(f"   Crossed Obstacle: {'✅' if success_criteria['crossed_obstacle'] else '❌'}")
+                print(f"   Remained Stable: {'✅' if success_criteria['remained_stable'] else '❌'}")
+                print(f"   Minimal Collision: {'✅' if success_criteria['minimal_collision'] else '❌'}")
+                print(f"   Overall Success: {'✅' if success_criteria['overall_success'] else '❌'}")
+    
+    print("\n")
+
+async def demo_drone_design():
+    """Demo: Design and simulate a drone"""
+    print("🚁 DEMO 4: Drone Design and Simulation")
+    print("=" * 60)
+    
+    client = MCPDemoClient()
+    
+    # Design a drone
+    drone_specs = {
+        "propeller_size": "medium",
+        "flight_height_cm": 25,
+        "stability_mode": "auto_hover",
+        "main_material": "light_carbon_fiber"
+    }
+    
+    design_result = await client.call_tool("design_vehicle", {
+        "vehicle_type": "drone",
+        "specifications": drone_specs,
+        "design_reasoning": "Medium propellers for balanced thrust, 25cm flight height to safely clear obstacle, auto-hover for stability, carbon fiber for lightweight performance"
+    })
+    
+    print("✅ Drone Design Result:")
+    print(json.dumps(design_result, indent=2))
+    print()
+    
+    if design_result.get("success"):
+        # Simulate the drone
+        print("🛸 Running drone simulation...")
+        sim_result = await client.call_tool("simulate_vehicle", {
+            "vehicle_type": "drone",
+            "specifications": drone_specs,
+            "simulation_duration": 5.0
+        })
+        
+        print("✅ Simulation Result:")
+        print(json.dumps(sim_result, indent=2))
+        print()
+        
+        if sim_result.get("success"):
+            # Evaluate performance
+            print("📊 Evaluating drone performance...")
+            eval_result = await client.call_tool("evaluate_performance", {
+                "simulation_feedback": sim_result["simulation_feedback"]
+            })
+            
+            print("✅ Evaluation Result:")
+            print(json.dumps(eval_result, indent=2))
+            
+            if eval_result.get("success"):
+                success_criteria = eval_result["success_criteria"]
+                print(f"\n🎯 Performance Summary:")
+                print(f"   Crossed Obstacle: {'✅' if success_criteria['crossed_obstacle'] else '❌'}")
+                print(f"   Remained Stable: {'✅' if success_criteria['remained_stable'] else '❌'}")
+                print(f"   Minimal Collision: {'✅' if success_criteria['minimal_collision'] else '❌'}")
+                print(f"   Overall Success: {'✅' if success_criteria['overall_success'] else '❌'}")
+    
+    print("\n")
+
+async def demo_iterative_design():
+    """Demo: Complete iterative design process"""
+    print("🔄 DEMO 5: Complete Iterative Design Process")
+    print("=" * 60)
+    
+    client = MCPDemoClient()
+    
+    # Run iterative design process for a robot
+    print("🤖 Running iterative robot design process...")
+    iterative_result = await client.call_tool("iterative_design_process", {
+        "vehicle_type": "robot",
+        "task_description": "Design a robot that can efficiently cross the 5cm obstacle",
+        "max_iterations": 3
+    })
+    
+    print("✅ Iterative Design Result:")
+    print(json.dumps(iterative_result, indent=2))
+    
+    if iterative_result.get("success"):
+        print(f"\n🎉 SUCCESS! Robot design completed in {iterative_result['iterations_needed']} iterations")
+        print(f"🔧 Final Design: {iterative_result['successful_design']}")
+    else:
+        print(f"\n❌ Design process did not achieve success within max iterations")
+        if "best_attempt" in iterative_result:
+            print(f"🔧 Best Attempt: {iterative_result['best_attempt'].get('specifications', {})}")
+    
+    print("\n")
+
+async def demo_comparison():
+    """Demo: Compare robot vs drone approaches"""
+    print("⚔️ DEMO 6: Robot vs Drone Comparison")
+    print("=" * 60)
+    
+    client = MCPDemoClient()
+    
+    # Design specifications for comparison
+    robot_specs = {
+        "wheel_type": "tracked_base",
+        "body_clearance_cm": 8,
+        "approach_sensor_enabled": True,
+        "main_material": "sturdy_metal_alloy"
+    }
+    
+    drone_specs = {
+        "propeller_size": "large_stable",
+        "flight_height_cm": 20,
+        "stability_mode": "auto_hover",
+        "main_material": "sturdy_aluminum"
+    }
+    
+    print("🤖 Testing Robust Robot Design...")
+    robot_sim = await client.call_tool("simulate_vehicle", {
+        "vehicle_type": "robot",
+        "specifications": robot_specs,
+        "simulation_duration": 8.0
+    })
+    
+    print("🚁 Testing Stable Drone Design...")
+    drone_sim = await client.call_tool("simulate_vehicle", {
+        "vehicle_type": "drone",
+        "specifications": drone_specs,
+        "simulation_duration": 8.0
+    })
+    
+    # Evaluate both
+    if robot_sim.get("success"):
+        robot_eval = await client.call_tool("evaluate_performance", {
+            "simulation_feedback": robot_sim["simulation_feedback"]
+        })
+        
+        print("\n🤖 Robot Performance:")
+        if robot_eval.get("success"):
+            robot_success = robot_eval["success_criteria"]["overall_success"]
+            print(f"   Overall Success: {'✅' if robot_success else '❌'}")
+            print(f"   Final Position: {robot_eval['evaluation_results'].get('final_robot_x_position', 0):.2f}m")
+    
+    if drone_sim.get("success"):
+        drone_eval = await client.call_tool("evaluate_performance", {
+            "simulation_feedback": drone_sim["simulation_feedback"]
+        })
+        
+        print("\n🚁 Drone Performance:")
+        if drone_eval.get("success"):
+            drone_success = drone_eval["success_criteria"]["overall_success"]
+            print(f"   Overall Success: {'✅' if drone_success else '���'}")
+            print(f"   Final Position: {drone_eval['evaluation_results'].get('final_robot_x_position', 0):.2f}m")
+    
+    print("\n")
+
+async def main():
+    """Run all demo scenarios"""
+    print("🚀 MCP Vehicle Design System Demo")
+    print("=" * 80)
+    print("This demo showcases the Model Context Protocol integration")
+    print("for our LLM-Agent-Designed Vehicle System.")
+    print("=" * 80)
+    print()
+    
+    try:
+        # Run all demos
+        await demo_obstacle_info()
+        await demo_design_parameters()
+        await demo_robot_design()
+        await demo_drone_design()
+        await demo_iterative_design()
+        await demo_comparison()
+        
+        print("🎊 Demo completed successfully!")
+        print("\n" + "=" * 80)
+        print("💡 MCP Integration Benefits Demonstrated:")
+        print("   ✅ Standardized tool access for vehicle design")
+        print("   ✅ Support for both robots and drones")
+        print("   ✅ Complete design-simulate-evaluate loop")
+        print("   ✅ Iterative optimization with LLM feedback")
+        print("   ✅ Performance evaluation and comparison")
+        print("   ✅ Type-safe parameter validation")
+        print("=" * 80)
+        
+    except Exception as e:
+        print(f"❌ Demo failed with error: {e}")
+        print("\nNote: This demo requires the enhanced simulation environment.")
+        print("Make sure all dependencies are installed and PyBullet is working.")
+
+def run_cli_demo():
+    """CLI version that can be run without MCP client"""
+    print("🔧 MCP CLI Demo")
+    print("=" * 50)
+    print("This demonstrates the MCP tools available in our system:")
+    print()
+    
+    # Show available tools
+    tools = [
+        "get_obstacle_info() - Get obstacle specifications",
+        "get_design_parameters(vehicle_type) - Get available parameters",
+        "design_vehicle(vehicle_type, specs, reasoning) - Design validation",
+        "simulate_vehicle(vehicle_type, specs, duration) - Run simulation",
+        "evaluate_performance(feedback) - Evaluate performance",
+        "iterative_design_process(vehicle_type, task, max_iter) - Complete process"
+    ]
+    
+    print("📋 Available MCP Tools:")
+    for i, tool in enumerate(tools, 1):
+        print(f"   {i}. {tool}")
+    
+    print()
+    print("🎯 Example Usage:")
+    print("   # Get obstacle info")
+    print("   mcp call get_obstacle_info")
+    print()
+    print("   # Design a robot")
+    print("   mcp call design_vehicle \\")
+    print("     --vehicle_type robot \\")
+    print("     --specifications '{\"wheel_type\": \"large_smooth\", \"body_clearance_cm\": 7}' \\")
+    print("     --design_reasoning 'Balanced design for obstacle crossing'")
+    print()
+    print("   # Run complete design process")
+    print("   mcp call iterative_design_process \\")
+    print("     --vehicle_type drone \\")
+    print("     --max_iterations 3")
+    print()
+    print("🚀 To use with real MCP client:")
+    print("   1. Start server: python mcp_server.py")
+    print("   2. Connect client to our MCP server")
+    print("   3. Use the tools listed above")
+
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) > 1 and sys.argv[1] == "--cli":
+        run_cli_demo()
+    else:
+        print("Starting full MCP demo...")
+        asyncio.run(main()) 

main_orchestrator_enhanced.py

@@ -0,0 +1,702 @@
+import os
+import ssl
+import time
+import imageio
+import numpy as np
+from PIL import Image
+import json
+from datetime import datetime
+import simulation_env_enhanced as simulation_env
+import llm_interface_enhanced as llm_interface
+import evaluation
+
+# SSL workaround for Gradio issues
+try:
+    import certifi
+    os.environ['SSL_CERT_FILE'] = certifi.where()
+except ImportError:
+    pass
+
+# Try to disable SSL verification as a workaround
+try:
+    ssl._create_default_https_context = ssl._create_unverified_context
+except AttributeError:
+    pass
+
+# Try to import Gradio with error handling
+GRADIO_AVAILABLE = False
+try:
+    import gradio as gr
+    GRADIO_AVAILABLE = True
+    print("✓ Gradio imported successfully")
+except Exception as e:
+    print(f"⚠ Gradio import failed: {e}")
+    print("Will use console-based interface instead")
+    GRADIO_AVAILABLE = False
+
+# Global configuration
+MAX_ITERATIONS = 5
+SIMULATION_DURATION_SEC = 10
+OBSTACLE_FAR_EDGE_X = 0.8
+
+def run_design_and_simulation_iteration(llm_prompt_func, previous_attempt_data, current_iteration, vehicle_type="robot"):
+    """Run one complete design and simulation iteration for robot or drone"""
+    
+    try:
+        # Call LLM for vehicle design
+        prompt = llm_prompt_func()
+        llm_response_dict = llm_interface.call_llm_api(prompt)
+        
+        if not llm_response_dict:
+            raise Exception("Failed to get valid LLM response")
+        
+        # Extract vehicle specs and validate
+        vehicle_specs = llm_response_dict.get('robot_specs', {})
+        vehicle_specs["vehicle_type"] = vehicle_type  # Add vehicle type
+        design_reasoning = llm_response_dict.get('design_reasoning', 'No reasoning provided')
+        
+        # Setup PyBullet environment
+        obstacle_id, plane_id = simulation_env.setup_pybullet_environment()
+        
+        # Create vehicle (robot or drone)
+        if vehicle_type == "robot":
+            vehicle_id, joint_indices, v_type = simulation_env.create_robot(vehicle_specs)
+            vehicle_props = None
+        elif vehicle_type == "drone":
+            vehicle_id, joint_indices, v_type, vehicle_props = simulation_env.create_drone(vehicle_specs)
+        else:
+            raise ValueError(f"Unknown vehicle type: {vehicle_type}")
+        
+        # Run simulation loop
+        current_sim_time = 0
+        frames_for_gif = []
+        final_pybullet_feedback = {}
+        start_time = time.time()
+        
+        # Simulation loop
+        simulation_steps = int(SIMULATION_DURATION_SEC * 240)
+        for step in range(simulation_steps):
+            # Run simulation step
+            simulation_env.run_simulation_step(
+                vehicle_id, joint_indices, {}, vehicle_type, 
+                vehicle_props if vehicle_type == "drone" else None
+            )
+            
+            current_sim_time = time.time() - start_time
+            
+            # Capture frame every 24 steps (10 fps for GIF)
+            if step % 24 == 0:
+                try:
+                    frame = simulation_env.capture_frame()
+                    frames_for_gif.append(frame)
+                except:
+                    pass  # Skip frame capture if it fails
+            
+            # Get current feedback
+            pybullet_feedback_snapshot = simulation_env.get_simulation_feedback(
+                vehicle_id, obstacle_id, start_time, current_sim_time, vehicle_type
+            )
+            final_pybullet_feedback = pybullet_feedback_snapshot
+            
+            # Check for early exit conditions
+            vehicle_x_pos = pybullet_feedback_snapshot['robot_position'][0]  # Using robot_position for compatibility
+            is_stable = pybullet_feedback_snapshot['is_robot_upright']       # Using is_robot_upright for compatibility
+            
+            # Exit if vehicle crossed well past obstacle or became unstable
+            if vehicle_x_pos > OBSTACLE_FAR_EDGE_X + 0.1 or not is_stable:
+                break
+            
+            # Exit if simulation time exceeded
+            if current_sim_time > SIMULATION_DURATION_SEC:
+                break
+        
+        # Evaluate results
+        evaluation_results = evaluation.evaluate_simulation_outcome(
+            final_pybullet_feedback, OBSTACLE_FAR_EDGE_X
+        )
+        llm_feedback_string = evaluation.format_feedback_for_llm(evaluation_results)
+        
+        # Cleanup PyBullet
+        simulation_env.reset_simulation()
+        
+        return llm_response_dict, evaluation_results, llm_feedback_string, frames_for_gif
+        
+    except Exception as e:
+        print(f"Error in simulation iteration: {e}")
+        # Cleanup on error
+        try:
+            simulation_env.reset_simulation()
+        except:
+            pass
+        
+        # Return error response
+        error_response = {
+            'robot_design_iteration': current_iteration,
+            'design_reasoning': f'Error occurred: {str(e)}',
+            'robot_specs': {}
+        }
+        error_evaluation = {
+            'robot_crossed_obstacle': False,
+            'no_significant_collision_with_obstacle_during_pass': False,
+            'robot_remains_upright': False,
+            'overall_success': False,
+            'specific_failure_point': 'simulation_error',
+            'final_robot_x_position': 0.0
+        }
+        error_feedback = f"Simulation failed with error: {str(e)}"
+        
+        return error_response, error_evaluation, error_feedback, []
+
+def create_gif_from_frames(frames, filename):
+    """Create GIF from simulation frames"""
+    try:
+        # Create outputs directory if it doesn't exist
+        outputs_dir = "outputs"
+        if not os.path.exists(outputs_dir):
+            os.makedirs(outputs_dir)
+        
+        gif_path = os.path.join(outputs_dir, filename)
+        
+        # Convert PIL images to numpy arrays
+        frame_arrays = []
+        for frame in frames:
+            if isinstance(frame, Image.Image):
+                frame_arrays.append(np.array(frame))
+            else:
+                frame_arrays.append(frame)
+        
+        # Create GIF
+        if frame_arrays:
+            imageio.mimsave(gif_path, frame_arrays, fps=10, loop=0)
+            return gif_path
+        else:
+            return None
+            
+    except Exception as e:
+        print(f"Error creating GIF: {e}")
+        return None
+
+def find_best_attempt(all_attempts_data):
+    """Find the best attempt from all attempts"""
+    if not all_attempts_data:
+        return None
+    
+    # Sort by final position reached
+    best_attempt = max(all_attempts_data, 
+                      key=lambda x: x['evaluation_results']['final_robot_x_position'])
+    return best_attempt
+
+def design_vehicle_for_obstacle(vehicle_type, user_task_description):
+    """Main function for Gradio interface - design vehicle iteratively"""
+    
+    # Initialize
+    iteration = 1
+    all_attempts_data = []
+    overall_process_log = []
+    
+    vehicle_name = "robot" if vehicle_type == "robot" else "drone"
+    overall_process_log.append(f"Starting {vehicle_name} design process for task: {user_task_description}")
+    overall_process_log.append(f"Target: Cross 5cm high obstacle at x=0.75m")
+    overall_process_log.append(f"Success criteria: Cross obstacle (x>0.8m), stay upright/stable, minimal collision")
+    overall_process_log.append("")
+    
+    # Main iteration loop
+    while iteration <= MAX_ITERATIONS:
+        overall_process_log.append(f"--- Iteration {iteration} ---")
+        
+        # Yield current progress
+        yield "\n".join(overall_process_log), None, None
+        
+        try:
+            # Determine prompt function
+            if iteration == 1:
+                if vehicle_type == "robot":
+                    prompt_func = lambda: llm_interface.generate_initial_robot_design_prompt()
+                else:  # drone
+                    prompt_func = lambda: llm_interface.generate_initial_drone_design_prompt()
+                prev_attempt = None
+            else:
+                last_attempt = all_attempts_data[-1]
+                if vehicle_type == "robot":
+                    prompt_func = lambda: llm_interface.generate_iterative_robot_design_prompt(
+                        last_attempt, iteration
+                    )
+                else:  # drone
+                    prompt_func = lambda: llm_interface.generate_iterative_drone_design_prompt(
+                        last_attempt, iteration
+                    )
+                prev_attempt = last_attempt
+            
+            # Run design and simulation iteration
+            llm_design, eval_results, feedback_str, frames = run_design_and_simulation_iteration(
+                prompt_func, prev_attempt, iteration, vehicle_type
+            )
+            
+            # Store attempt data
+            current_attempt_data = {
+                "llm_design": llm_design,
+                "robot_specs": llm_design.get('robot_specs', {}),
+                "design_reasoning": llm_design.get('design_reasoning', ''),
+                "evaluation_results": eval_results,
+                "feedback_from_simulation": feedback_str
+            }
+            all_attempts_data.append(current_attempt_data)
+            
+            # Update log
+            overall_process_log.append(f"LLM Design ({iteration}): {llm_design.get('robot_specs')}")
+            overall_process_log.append(f"Design Reasoning: {llm_design.get('design_reasoning', 'N/A')}")
+            overall_process_log.append(f"Simulation Feedback: {feedback_str}")
+            overall_process_log.append("")
+            
+            # Create GIF from frames
+            gif_path = None
+            if frames:
+                gif_filename = f"{vehicle_name}_iteration_{iteration}.gif"
+                gif_path = create_gif_from_frames(frames, gif_filename)
+            
+            # Check for success
+            if eval_results.get('overall_success', False):
+                overall_process_log.append(f"🎉 SUCCESS! {vehicle_name.title()} passed the obstacle in {iteration} iterations.")
+                overall_process_log.append(f"Final {vehicle_name} specs: {llm_design.get('robot_specs')}")
+                
+                # Return final results
+                final_log = "\n".join(overall_process_log)
+                final_specs = llm_design.get('robot_specs', {})
+                
+                yield final_log, gif_path, final_specs
+                return
+            
+            # Yield current progress with GIF
+            yield "\n".join(overall_process_log), gif_path, llm_design.get('robot_specs', {})
+            
+        except Exception as e:
+            overall_process_log.append(f"Error in iteration {iteration}: {str(e)}")
+            overall_process_log.append("")
+        
+        iteration += 1
+    
+    # Max iterations reached without success
+    overall_process_log.append(f"❌ FAILURE: Max {MAX_ITERATIONS} iterations reached. Obstacle not passed.")
+    
+    # Find best attempt
+    best_attempt = find_best_attempt(all_attempts_data)
+    best_specs = best_attempt['robot_specs'] if best_attempt else "No valid designs generated"
+    
+    if best_attempt:
+        overall_process_log.append(f"Best attempt reached x={best_attempt['evaluation_results']['final_robot_x_position']:.2f}m")
+        overall_process_log.append(f"Best {vehicle_name} specs: {best_specs}")
+    
+    # Create final GIF from last attempt
+    final_gif_path = None
+    if all_attempts_data and 'frames' in locals():
+        final_gif_path = create_gif_from_frames(frames, f"final_{vehicle_name}_attempt.gif")
+    
+    final_log = "\n".join(overall_process_log)
+    yield final_log, final_gif_path, best_specs
+
+def console_design_vehicle_for_obstacle(vehicle_type, user_task_description):
+    """Console-based version of the vehicle design system"""
+    
+    vehicle_name = "robot" if vehicle_type == "robot" else "drone"
+    
+    print("=" * 60)
+    print(f"LLM {vehicle_name.title()} Design System - Console Interface")
+    print("=" * 60)
+    print(f"Task: {user_task_description}")
+    print(f"Target: Cross 5cm high obstacle at x=0.75m")
+    print(f"Success criteria: Cross obstacle (x>0.8m), stay upright/stable, minimal collision")
+    print("")
+    
+    # Initialize best design tracking
+    iteration = 1
+    all_attempts_data = []
+    best_attempt_data = None
+    best_iteration = 0
+    
+    # Main iteration loop
+    while iteration <= MAX_ITERATIONS:
+        print(f"--- Iteration {iteration} ---")
+        
+        try:
+            # Determine prompt function
+            if iteration == 1:
+                if vehicle_type == "robot":
+                    prompt_func = lambda: llm_interface.generate_initial_robot_design_prompt()
+                else:  # drone
+                    prompt_func = lambda: llm_interface.generate_initial_drone_design_prompt()
+                prev_attempt = None
+            else:
+                last_attempt = all_attempts_data[-1]
+                if vehicle_type == "robot":
+                    prompt_func = lambda: llm_interface.generate_iterative_robot_design_prompt(
+                        last_attempt, iteration
+                    )
+                else:  # drone
+                    prompt_func = lambda: llm_interface.generate_iterative_drone_design_prompt(
+                        last_attempt, iteration
+                    )
+                prev_attempt = last_attempt
+            
+            # Run design and simulation iteration
+            llm_design, eval_results, feedback_str, frames = run_design_and_simulation_iteration(
+                prompt_func, prev_attempt, iteration, vehicle_type
+            )
+            
+            # Store attempt data
+            current_attempt_data = {
+                "llm_design": llm_design,
+                "robot_specs": llm_design.get('robot_specs', {}),
+                "design_reasoning": llm_design.get('design_reasoning', ''),
+                "evaluation_results": eval_results,
+                "feedback_from_simulation": feedback_str,
+                "iteration": iteration
+            }
+            all_attempts_data.append(current_attempt_data)
+            
+            # Check if this is the best design so far
+            if best_attempt_data is None or is_current_better(
+                eval_results, iteration, 
+                best_attempt_data['evaluation_results'], best_iteration
+            ):
+                best_attempt_data = current_attempt_data
+                best_iteration = iteration
+                print(f"🏆 New best design found in iteration {iteration}!")
+            
+            # Display results
+            print(f"LLM Design ({iteration}): {llm_design.get('robot_specs')}")
+            print(f"Design Reasoning: {llm_design.get('design_reasoning', 'N/A')}")
+            print(f"Simulation Feedback: {feedback_str}")
+            print("")
+            
+            # Create GIF from frames
+            if frames:
+                gif_filename = f"{vehicle_name}_iteration_{iteration}.gif"
+                gif_path = create_gif_from_frames(frames, gif_filename)
+                if gif_path:
+                    print(f"Simulation GIF saved: {gif_path}")
+            
+            # Check for success
+            if eval_results.get('overall_success', False):
+                print(f"🎉 SUCCESS! {vehicle_name.title()} passed the obstacle in {iteration} iterations.")
+                print(f"Final {vehicle_name} specs: {llm_design.get('robot_specs')}")
+                
+                # Save best design JSON
+                json_file = save_best_design_json(best_attempt_data, vehicle_type, iteration)
+                
+                return True, llm_design.get('robot_specs')
+            
+        except Exception as e:
+            print(f"Error in iteration {iteration}: {str(e)}")
+        
+        iteration += 1
+    
+    # Max iterations reached without success
+    print(f"❌ FAILURE: Max {MAX_ITERATIONS} iterations reached. Obstacle not passed.")
+    
+    # Display best design summary
+    if best_attempt_data:
+        print(f"\n🏆 BEST DESIGN SUMMARY (from iteration {best_iteration}):")
+        print(f"   • Final Position: {best_attempt_data['evaluation_results']['final_robot_x_position']:.3f}m")
+        print(f"   • Success: {best_attempt_data['evaluation_results']['overall_success']}")
+        
+        best_specs = best_attempt_data['robot_specs']
+        if vehicle_type == "robot":
+            print(f"   • Wheel Type: {best_specs.get('wheel_type', 'unknown')}")
+            print(f"   • Body Clearance: {best_specs.get('body_clearance_cm', 0)}cm")
+            print(f"   • Material: {best_specs.get('main_material', 'unknown')}")
+        else:  # drone
+            print(f"   • Propeller Size: {best_specs.get('propeller_size', 'unknown')}")
+            print(f"   • Flight Height: {best_specs.get('flight_height_cm', 0)}cm")
+            print(f"   • Material: {best_specs.get('main_material', 'unknown')}")
+        
+        print(f"   • Design Reasoning: {best_attempt_data['design_reasoning']}")
+        
+        # Save best design JSON
+        json_file = save_best_design_json(best_attempt_data, vehicle_type, MAX_ITERATIONS)
+        
+        return False, best_specs
+    else:
+        print("No valid designs generated")
+        return False, "No valid designs generated"
+
+# Gradio Interface Setup
+def create_gradio_interface():
+    """Create and configure Gradio interface with vehicle type selection"""
+    
+    with gr.Blocks(title="LLM Vehicle Designer - Robots & Drones", theme=gr.themes.Soft()) as iface:
+        gr.Markdown("# 🤖🚁 LLM-Agent-Designed Obstacle-Passing Vehicle System")
+        gr.Markdown("This system uses an LLM agent to iteratively design **robots** or **drones** that can pass a 5cm high obstacle.")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                vehicle_type = gr.Radio(
+                    choices=["robot", "drone"],
+                    label="Vehicle Type",
+                    value="robot",
+                    info="Choose between a ground robot or flying drone"
+                )
+                
+                task_input = gr.Textbox(
+                    label="Task Description",
+                    value="Design a vehicle that can pass the 5cm high obstacle",
+                    placeholder="Describe what you want the vehicle to accomplish...",
+                    lines=2
+                )
+                
+                submit_btn = gr.Button("🚀 Start Vehicle Design Process", variant="primary", size="lg")
+                
+            with gr.Column(scale=1):
+                gr.Markdown("### Process Info")
+                gr.Markdown("- **Obstacle**: 5cm high, 50cm wide, 10cm deep")
+                gr.Markdown("- **Success**: Vehicle crosses (x > 0.8m), stays stable")
+                gr.Markdown("- **Max Iterations**: 5")
+                gr.Markdown("- **Robot**: Wheels, clearance, materials")
+                gr.Markdown("- **Drone**: Propellers, flight height, materials")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                process_log = gr.Textbox(
+                    label="🔄 Design Process Log",
+                    lines=20,
+                    max_lines=30,
+                    show_copy_button=True
+                )
+            
+            with gr.Column(scale=1):
+                simulation_gif = gr.Image(
+                    label="🎬 Simulation Visualization",
+                    type="filepath"
+                )
+                
+                vehicle_specs = gr.JSON(
+                    label="🔧 Final Vehicle Specifications"
+                )
+        
+        # Set up the interface interaction
+        submit_btn.click(
+            fn=design_vehicle_for_obstacle,
+            inputs=[vehicle_type, task_input],
+            outputs=[process_log, simulation_gif, vehicle_specs]
+        )
+        
+        gr.Markdown("---")
+        gr.Markdown("### How it works:")
+        gr.Markdown("1. **Vehicle Selection**: Choose robot (ground) or drone (flying)")
+        gr.Markdown("2. **LLM Design**: AI agent proposes vehicle parameters")
+        gr.Markdown("3. **Simulation**: Vehicle tested in PyBullet physics")
+        gr.Markdown("4. **Evaluation**: Performance measured against success criteria")
+        gr.Markdown("5. **Iteration**: Feedback used to improve design")
+        gr.Markdown("6. **Success/Failure**: Process continues until success or max iterations")
+    
+    return iface
+
+def is_current_better(current_eval, current_iteration, best_eval, best_iteration):
+    """
+    Determine if current design is better than best design using priority criteria:
+    1. Priority 1: Any design achieving overall_success == True
+    2. Priority 2: Among successful designs, fewer iterations preferred  
+    3. Priority 3: Designs that crossed obstacle (even if failed other criteria)
+    4. Priority 4: Design with furthest final_robot_x_position
+    5. Priority 5: If tied, use last design
+    """
+    
+    # Priority 1: Success vs non-success
+    current_success = current_eval.get('overall_success', False)
+    best_success = best_eval.get('overall_success', False)
+    
+    if current_success and not best_success:
+        return True
+    elif best_success and not current_success:
+        return False
+    elif current_success and best_success:
+        # Priority 2: Among successful, prefer fewer iterations
+        return current_iteration < best_iteration
+    
+    # Priority 3: Obstacle crossing (even if overall failed)
+    current_crossed = current_eval.get('robot_crossed_obstacle', False)
+    best_crossed = best_eval.get('robot_crossed_obstacle', False)
+    
+    if current_crossed and not best_crossed:
+        return True
+    elif best_crossed and not current_crossed:
+        return False
+    
+    # Priority 4: Furthest distance
+    current_distance = current_eval.get('final_robot_x_position', 0.0)
+    best_distance = best_eval.get('final_robot_x_position', 0.0)
+    
+    if current_distance > best_distance:
+        return True
+    elif current_distance < best_distance:
+        return False
+    
+    # Priority 5: If tied, use last design (current)
+    return True
+
+def format_best_design_performance(eval_results):
+    """Format evaluation results for user-friendly display"""
+    
+    success_status = "✅ SUCCESS" if eval_results.get('overall_success', False) else "❌ FAILED"
+    
+    performance_text = f"""
+{success_status}
+
+📊 **Performance Metrics:**
+• 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 Upright: {'✅ 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'}
+
+🎯 **Success Criteria:**
+• Target: Cross obstacle (reach x > 0.8m)
+• Current: {eval_results.get('final_robot_x_position', 0.0):.3f}m
+• Status: {'ACHIEVED' if eval_results.get('final_robot_x_position', 0.0) > 0.8 else 'NOT ACHIEVED'}
+
+⚠️ **Failure Analysis:**
+{eval_results.get('specific_failure_point', 'No specific failure identified')}
+"""
+    
+    return performance_text.strip()
+
+def save_best_design_json(best_attempt_data, vehicle_type, iteration_count):
+    """Save the best design to a comprehensive JSON file"""
+    
+    if not best_attempt_data:
+        return None
+    
+    # Create timestamp
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    
+    # Determine vehicle specifications key
+    if vehicle_type == "robot":
+        specs_key = "robot_specs"
+        json_filename = f"best_robot_design_{timestamp}.json"
+    else:
+        specs_key = "robot_specs"  # Using same key for compatibility
+        json_filename = f"best_drone_design_{timestamp}.json"
+    
+    # Extract specifications
+    vehicle_specs = best_attempt_data.get(specs_key, {})
+    
+    # Create comprehensive JSON structure
+    json_data = {
+        "timestamp": datetime.now().isoformat(),
+        "vehicle_type": vehicle_type,
+        "total_iterations": iteration_count,
+        "design_process_summary": {
+            "success": best_attempt_data['evaluation_results'].get('overall_success', False),
+            "best_iteration": "Final attempt",  # Could be enhanced to track actual best iteration
+            "total_attempts": iteration_count
+        }
+    }
+    
+    # Add vehicle-specific specifications
+    if vehicle_type == "robot":
+        json_data["robot_specifications"] = {
+            "wheel_type": vehicle_specs.get('wheel_type', 'unknown'),
+            "body_clearance_cm": vehicle_specs.get('body_clearance_cm', 0),
+            "approach_sensor_enabled": vehicle_specs.get('approach_sensor_enabled', False),
+            "main_material": vehicle_specs.get('main_material', 'unknown'),
+            "vehicle_type": vehicle_specs.get('vehicle_type', 'robot')
+        }
+    else:  # drone
+        json_data["drone_specifications"] = {
+            "propeller_size": vehicle_specs.get('propeller_size', 'unknown'),
+            "flight_height_cm": vehicle_specs.get('flight_height_cm', 0),
+            "stability_mode": vehicle_specs.get('stability_mode', 'unknown'),
+            "main_material": vehicle_specs.get('main_material', 'unknown'),
+            "vehicle_type": vehicle_specs.get('vehicle_type', 'drone')
+        }
+    
+    # Add design reasoning
+    json_data["design_reasoning"] = best_attempt_data.get('design_reasoning', 'No reasoning provided')
+    
+    # Add performance results
+    eval_results = best_attempt_data['evaluation_results']
+    json_data["performance_results"] = {
+        "overall_success": eval_results.get('overall_success', False),
+        "robot_crossed_obstacle": eval_results.get('robot_crossed_obstacle', False),
+        "robot_remains_upright": eval_results.get('robot_remains_upright', False),
+        "no_significant_collision_with_obstacle_during_pass": eval_results.get('no_significant_collision_with_obstacle_during_pass', False),
+        "final_robot_x_position": eval_results.get('final_robot_x_position', 0.0),
+        "specific_failure_point": eval_results.get('specific_failure_point', 'none')
+    }
+    
+    # Add success criteria breakdown
+    json_data["success_criteria_analysis"] = {
+        "target_distance": 0.8,
+        "achieved_distance": eval_results.get('final_robot_x_position', 0.0),
+        "distance_success": eval_results.get('final_robot_x_position', 0.0) > 0.8,
+        "stability_success": eval_results.get('robot_remains_upright', False),
+        "collision_success": eval_results.get('no_significant_collision_with_obstacle_during_pass', False),
+        "overall_success": eval_results.get('overall_success', False)
+    }
+    
+    # Add performance summary
+    json_data["performance_summary"] = {
+        "distance_traveled": f"{eval_results.get('final_robot_x_position', 0.0):.3f}m",
+        "success_rate": "100%" if eval_results.get('overall_success', False) else "0%",
+        "primary_failure": eval_results.get('specific_failure_point', 'unknown') if not eval_results.get('overall_success', False) else None
+    }
+    
+    # Save JSON file
+    try:
+        with open(json_filename, 'w', encoding='utf-8') as f:
+            json.dump(json_data, f, indent=2, ensure_ascii=False)
+        
+        print(f"📄 Best {vehicle_type} design saved to: {json_filename}")
+        return json_filename
+        
+    except Exception as e:
+        print(f"❌ Error saving JSON file: {e}")
+        return None
+
+if __name__ == "__main__":
+    print("🤖🚁 LLM-Agent-Designed Vehicle System (Robots & Drones)")
+    print("=" * 60)
+    
+    if GRADIO_AVAILABLE:
+        print("Starting Gradio web interface...")
+        try:
+            # Create and launch Gradio interface
+            interface = create_gradio_interface()
+            interface.launch(
+                server_name="0.0.0.0",
+                server_port=7860,
+                share=True,
+                show_error=True
+            )
+        except Exception as e:
+            print(f"Failed to start Gradio interface: {e}")
+            print("Falling back to console interface...")
+            GRADIO_AVAILABLE = False
+    
+    if not GRADIO_AVAILABLE:
+        print("Using console interface...")
+        print("Note: Simulation GIFs will be saved to the 'outputs' directory")
+        print("")
+        
+        # Get user input
+        vehicle_type = input("Choose vehicle type (robot/drone) [robot]: ").strip().lower()
+        if vehicle_type not in ["robot", "drone"]:
+            vehicle_type = "robot"
+        
+        task_description = input("Enter task description (or press Enter for default): ").strip()
+        if not task_description:
+            task_description = f"Design a {vehicle_type} that can pass the 5cm high obstacle"
+        
+        print("")
+        
+        # Run the design process
+        success, final_specs = console_design_vehicle_for_obstacle(vehicle_type, task_description)
+        
+        print("\n" + "=" * 60)
+        if success:
+            print("🎉 MISSION ACCOMPLISHED!")
+            print(f"Final successful {vehicle_type} design: {final_specs}")
+        else:
+            print("❌ Mission failed, but valuable data collected.")
+            print(f"Best attempt specs: {final_specs}")
+        
+        print("\nCheck the 'outputs' directory for simulation GIFs.")
+        print("=" * 60) 

mcp_server.py

@@ -0,0 +1,396 @@
+"""
+MCP Server for LLM-Agent-Designed Obstacle-Passing Vehicle System
+
+This server exposes vehicle design, simulation, and evaluation tools via the Model Context Protocol.
+Supports both robots and drones for crossing a 5cm obstacle.
+"""
+
+from mcp.server.fastmcp import FastMCP
+import json
+import time
+import os
+import imageio
+from typing import Dict, Any, List, Optional, Literal
+
+# Import our existing modules
+import simulation_env_enhanced as simulation_env
+import llm_interface
+import evaluation
+
+# Create the MCP server
+mcp = FastMCP("Robot-Drone-Design-Server")
+
+# Global configuration
+MAX_ITERATIONS = 5
+SIMULATION_DURATION_SEC = 10
+OBSTACLE_FAR_EDGE_X = 0.8
+
+@mcp.tool()
+def get_obstacle_info() -> Dict[str, Any]:
+    """Get information about the obstacle that vehicles need to cross"""
+    return simulation_env.get_obstacle_info()
+
+@mcp.tool()
+def design_vehicle(
+    vehicle_type: Literal["robot", "drone"],
+    specifications: Dict[str, Any],
+    design_reasoning: str = ""
+) -> Dict[str, Any]:
+    """
+    Design a robot or drone with specified parameters
+    
+    Args:
+        vehicle_type: Either "robot" or "drone"
+        specifications: Vehicle parameters (depends on type)
+        design_reasoning: Explanation of design choices
+    
+    Returns:
+        Design validation and summary
+    """
+    try:
+        # Add vehicle_type to specifications
+        specs = specifications.copy()
+        specs["vehicle_type"] = vehicle_type
+        
+        # Validate specifications based on vehicle type
+        if vehicle_type == "robot":
+            required_params = ["wheel_type", "body_clearance_cm", "main_material"]
+            valid_wheel_types = ["small_high_grip", "large_smooth", "tracked_base"]
+            valid_materials = ["light_plastic", "sturdy_metal_alloy"]
+            
+            # Validate parameters
+            for param in required_params:
+                if param not in specs:
+                    return {"error": f"Missing required parameter: {param}"}
+            
+            if specs["wheel_type"] not in valid_wheel_types:
+                return {"error": f"Invalid wheel_type. Must be one of: {valid_wheel_types}"}
+            
+            if specs["main_material"] not in valid_materials:
+                return {"error": f"Invalid main_material. Must be one of: {valid_materials}"}
+            
+            if not (1 <= specs["body_clearance_cm"] <= 10):
+                return {"error": "body_clearance_cm must be between 1 and 10"}
+        
+        elif vehicle_type == "drone":
+            required_params = ["propeller_size", "flight_height_cm", "main_material"]
+            valid_propeller_sizes = ["small_agile", "medium", "large_stable"]
+            valid_materials = ["light_carbon_fiber", "sturdy_aluminum"]
+            
+            # Validate parameters
+            for param in required_params:
+                if param not in specs:
+                    return {"error": f"Missing required parameter: {param}"}
+            
+            if specs["propeller_size"] not in valid_propeller_sizes:
+                return {"error": f"Invalid propeller_size. Must be one of: {valid_propeller_sizes}"}
+            
+            if specs["main_material"] not in valid_materials:
+                return {"error": f"Invalid main_material. Must be one of: {valid_materials}"}
+            
+            if not (10 <= specs["flight_height_cm"] <= 50):
+                return {"error": "flight_height_cm must be between 10 and 50"}
+        
+        else:
+            return {"error": f"Invalid vehicle_type: {vehicle_type}. Must be 'robot' or 'drone'"}
+        
+        return {
+            "success": True,
+            "vehicle_type": vehicle_type,
+            "specifications": specs,
+            "design_reasoning": design_reasoning,
+            "status": "Design validated and ready for simulation"
+        }
+        
+    except Exception as e:
+        return {"error": f"Design validation failed: {str(e)}"}
+
+@mcp.tool()
+def simulate_vehicle(
+    vehicle_type: Literal["robot", "drone"],
+    specifications: Dict[str, Any],
+    simulation_duration: float = 10.0
+) -> Dict[str, Any]:
+    """
+    Run physics simulation of a vehicle attempting to cross the obstacle
+    
+    Args:
+        vehicle_type: Either "robot" or "drone"  
+        specifications: Vehicle parameters
+        simulation_duration: How long to run simulation (seconds)
+    
+    Returns:
+        Simulation results and performance data
+    """
+    try:
+        # Add vehicle_type to specifications
+        specs = specifications.copy()
+        specs["vehicle_type"] = vehicle_type
+        
+        # Setup PyBullet environment
+        obstacle_id, plane_id = simulation_env.setup_pybullet_environment()
+        
+        # Create vehicle
+        if vehicle_type == "robot":
+            vehicle_id, joint_indices, v_type = simulation_env.create_robot(specs)
+            vehicle_props = None
+        elif vehicle_type == "drone":
+            vehicle_id, joint_indices, v_type, vehicle_props = simulation_env.create_drone(specs)
+        else:
+            return {"error": f"Invalid vehicle_type: {vehicle_type}"}
+        
+        # Run simulation
+        start_time = time.time()
+        final_feedback = {}
+        simulation_steps = int(simulation_duration * 240)  # 240 Hz
+        
+        for step in range(simulation_steps):
+            # Run simulation step
+            simulation_env.run_simulation_step(
+                vehicle_id, joint_indices, {}, vehicle_type, 
+                vehicle_props if vehicle_type == "drone" else None
+            )
+            
+            current_sim_time = time.time() - start_time
+            
+            # Get feedback every 60 steps (4 times per second)
+            if step % 60 == 0:
+                feedback = simulation_env.get_simulation_feedback(
+                    vehicle_id, obstacle_id, start_time, current_sim_time, vehicle_type
+                )
+                final_feedback = feedback
+                
+                # Check for early exit
+                vehicle_x_pos = feedback['robot_position'][0]  # Using robot_position for compatibility
+                is_stable = feedback['is_robot_upright']       # Using is_robot_upright for compatibility
+                
+                if vehicle_x_pos > OBSTACLE_FAR_EDGE_X + 0.1 or not is_stable:
+                    break
+            
+            if current_sim_time > simulation_duration:
+                break
+        
+        # Cleanup
+        simulation_env.reset_simulation()
+        
+        return {
+            "success": True,
+            "vehicle_type": vehicle_type,
+            "specifications": specs,
+            "simulation_feedback": final_feedback,
+            "simulation_duration": current_sim_time
+        }
+        
+    except Exception as e:
+        # Cleanup on error
+        try:
+            simulation_env.reset_simulation()
+        except:
+            pass
+        
+        return {"error": f"Simulation failed: {str(e)}"}
+
+@mcp.tool()
+def evaluate_performance(simulation_feedback: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Evaluate vehicle performance based on simulation feedback
+    
+    Args:
+        simulation_feedback: Feedback from simulation
+    
+    Returns:
+        Performance evaluation and success criteria analysis
+    """
+    try:
+        # Use existing evaluation logic
+        eval_results = evaluation.evaluate_simulation_outcome(
+            simulation_feedback, OBSTACLE_FAR_EDGE_X
+        )
+        feedback_str = evaluation.format_feedback_for_llm(eval_results)
+        
+        return {
+            "success": True,
+            "evaluation_results": eval_results,
+            "feedback_summary": feedback_str,
+            "success_criteria": {
+                "crossed_obstacle": eval_results["robot_crossed_obstacle"],
+                "remained_stable": eval_results["robot_remains_upright"],
+                "minimal_collision": eval_results["no_significant_collision_with_obstacle_during_pass"],
+                "overall_success": eval_results["overall_success"]
+            }
+        }
+        
+    except Exception as e:
+        return {"error": f"Evaluation failed: {str(e)}"}
+
+@mcp.tool()
+def iterative_design_process(
+    vehicle_type: Literal["robot", "drone"],
+    task_description: str = "Cross the 5cm obstacle",
+    max_iterations: int = 5
+) -> Dict[str, Any]:
+    """
+    Run complete iterative LLM-driven vehicle design process
+    
+    Args:
+        vehicle_type: Either "robot" or "drone"
+        task_description: Description of the task
+        max_iterations: Maximum number of design iterations
+    
+    Returns:
+        Complete design process results with all iterations
+    """
+    try:
+        all_attempts = []
+        iteration = 1
+        
+        while iteration <= max_iterations:
+            # Generate design prompt
+            if iteration == 1:
+                if vehicle_type == "robot":
+                    prompt = llm_interface.generate_initial_robot_design_prompt()
+                else:  # drone
+                    prompt = llm_interface.generate_initial_drone_design_prompt()
+            else:
+                last_attempt = all_attempts[-1]
+                if vehicle_type == "robot":
+                    prompt = llm_interface.generate_iterative_robot_design_prompt(
+                        last_attempt, iteration
+                    )
+                else:  # drone
+                    prompt = llm_interface.generate_iterative_drone_design_prompt(
+                        last_attempt, iteration
+                    )
+            
+            # Get LLM design
+            llm_response = llm_interface.call_llm_api(prompt)
+            vehicle_specs = llm_response.get('robot_specs', {})  # robot_specs used for both
+            design_reasoning = llm_response.get('design_reasoning', '')
+            
+            # Add vehicle type
+            vehicle_specs["vehicle_type"] = vehicle_type
+            
+            # Run simulation
+            sim_result = simulate_vehicle(vehicle_type, vehicle_specs, SIMULATION_DURATION_SEC)
+            
+            if sim_result.get("error"):
+                all_attempts.append({
+                    "iteration": iteration,
+                    "error": sim_result["error"],
+                    "specifications": vehicle_specs
+                })
+                iteration += 1
+                continue
+            
+            # Evaluate performance
+            eval_result = evaluate_performance(sim_result["simulation_feedback"])
+            
+            # Store attempt
+            attempt_data = {
+                "iteration": iteration,
+                "vehicle_type": vehicle_type,
+                "specifications": vehicle_specs,
+                "design_reasoning": design_reasoning,
+                "simulation_result": sim_result,
+                "evaluation_result": eval_result,
+                "success": eval_result.get("evaluation_results", {}).get("overall_success", False)
+            }
+            all_attempts.append(attempt_data)
+            
+            # Check for success
+            if attempt_data["success"]:
+                return {
+                    "success": True,
+                    "vehicle_type": vehicle_type,
+                    "iterations_needed": iteration,
+                    "successful_design": vehicle_specs,
+                    "all_attempts": all_attempts,
+                    "final_evaluation": eval_result
+                }
+            
+            iteration += 1
+        
+        # Max iterations reached
+        best_attempt = max(all_attempts, 
+                          key=lambda x: x.get("evaluation_result", {}).get("evaluation_results", {}).get("final_robot_x_position", 0),
+                          default={})
+        
+        return {
+            "success": False,
+            "vehicle_type": vehicle_type,
+            "max_iterations_reached": True,
+            "best_attempt": best_attempt,
+            "all_attempts": all_attempts
+        }
+        
+    except Exception as e:
+        return {"error": f"Iterative design process failed: {str(e)}"}
+
+@mcp.tool()
+def get_design_parameters(vehicle_type: Literal["robot", "drone"]) -> Dict[str, Any]:
+    """
+    Get available design parameters for robots or drones
+    
+    Args:
+        vehicle_type: Either "robot" or "drone"
+    
+    Returns:
+        Available parameters and their valid ranges/options
+    """
+    if vehicle_type == "robot":
+        return {
+            "vehicle_type": "robot",
+            "parameters": {
+                "wheel_type": {
+                    "type": "enum",
+                    "options": ["small_high_grip", "large_smooth", "tracked_base"],
+                    "description": "Type of wheels for traction and obstacle climbing"
+                },
+                "body_clearance_cm": {
+                    "type": "integer",
+                    "range": [1, 10],
+                    "description": "Ground clearance in centimeters (obstacle is 5cm high)"
+                },
+                "approach_sensor_enabled": {
+                    "type": "boolean",
+                    "description": "Enable obstacle detection sensors (conceptual for MVP)"
+                },
+                "main_material": {
+                    "type": "enum",
+                    "options": ["light_plastic", "sturdy_metal_alloy"],
+                    "description": "Material affects weight and durability"
+                }
+            }
+        }
+    elif vehicle_type == "drone":
+        return {
+            "vehicle_type": "drone",
+            "parameters": {
+                "propeller_size": {
+                    "type": "enum",
+                    "options": ["small_agile", "medium", "large_stable"],
+                    "description": "Propeller size affects thrust and maneuverability"
+                },
+                "flight_height_cm": {
+                    "type": "integer", 
+                    "range": [10, 50],
+                    "description": "Target flight height in centimeters (obstacle is 5cm high)"
+                },
+                "stability_mode": {
+                    "type": "enum",
+                    "options": ["auto_hover", "manual_control"],
+                    "description": "Flight stability control mode"
+                },
+                "main_material": {
+                    "type": "enum",
+                    "options": ["light_carbon_fiber", "sturdy_aluminum"],
+                    "description": "Material affects weight and flight characteristics"
+                }
+            }
+        }
+    else:
+        return {"error": f"Invalid vehicle_type: {vehicle_type}. Must be 'robot' or 'drone'"}
+
+# Run the MCP server
+if __name__ == "__main__":
+    mcp.run() 

record_trial_videos.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""
+Record trial videos with timestamps to avoid overriding existing files
+"""
+
+import os
+import time
+from datetime import datetime
+import main_orchestrator_enhanced
+
+def record_trial_videos():
+    """Run trial and record videos with unique timestamps"""
+    
+    # Create timestamp for this session
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    print(f"🎬 Recording Trial Videos - Session: {timestamp}")
+    print("=" * 60)
+    
+    # Ensure outputs directory exists
+    os.makedirs("outputs", exist_ok=True)
+    
+    # List existing videos
+    existing_videos = [f for f in os.listdir("outputs") if f.endswith('.gif')]
+    print(f"📁 Existing videos: {len(existing_videos)} files")
+    for video in existing_videos[:5]:  # Show first 5
+        print(f"   • {video}")
+    if len(existing_videos) > 5:
+        print(f"   • ... and {len(existing_videos) - 5} more")
+    
+    print(f"\n🚀 Starting Enhanced Trial with Video Recording...")
+    print(f"📹 New videos will be saved with timestamp: {timestamp}")
+    
+    try:
+        # Test Robot Design
+        print(f"\n🤖 Testing Robot Design...")
+        robot_success, robot_specs = main_orchestrator_enhanced.console_design_vehicle_for_obstacle(
+            vehicle_type='robot',
+            user_task_description=f'Design a robot that can pass the 5cm high obstacle - Session {timestamp}'
+        )
+        
+        print(f"✅ Robot trial completed!")
+        print(f"   Success: {robot_success}")
+        print(f"   Final specs: {robot_specs}")
+        
+        # Test Drone Design
+        print(f"\n🚁 Testing Drone Design...")
+        drone_success, drone_specs = main_orchestrator_enhanced.console_design_vehicle_for_obstacle(
+            vehicle_type='drone', 
+            user_task_description=f'Design a drone that can pass the 5cm high obstacle - Session {timestamp}'
+        )
+        
+        print(f"✅ Drone trial completed!")
+        print(f"   Success: {drone_success}")
+        print(f"   Final specs: {drone_specs}")
+        
+        # List new videos created
+        print(f"\n📹 VIDEO RECORDING RESULTS:")
+        new_videos = [f for f in os.listdir("outputs") if f.endswith('.gif')]
+        new_count = len(new_videos) - len(existing_videos)
+        
+        print(f"Total videos now: {len(new_videos)} files (+{new_count} new)")
+        
+        # Show newest videos (those created in this session)
+        newest_videos = sorted([f for f in new_videos if f not in existing_videos])
+        if newest_videos:
+            print(f"\n🎬 NEW VIDEOS CREATED:")
+            for video in newest_videos:
+                file_path = os.path.join("outputs", video)
+                file_size = os.path.getsize(file_path)
+                print(f"   • {video} ({file_size:,} bytes)")
+        
+        # Check JSON files
+        json_files = [f for f in os.listdir(".") if f.startswith("best_") and f.endswith(".json")]
+        latest_json = sorted(json_files)[-2:] if len(json_files) >= 2 else json_files
+        
+        if latest_json:
+            print(f"\n📄 LATEST JSON RESULTS:")
+            for json_file in latest_json:
+                print(f"   • {json_file}")
+        
+        print(f"\n🎯 TRIAL SESSION {timestamp} COMPLETED SUCCESSFULLY!")
+        print(f"   Robot moved: {robot_success}")
+        print(f"   Drone moved: {drone_success}")
+        print(f"   Videos created: {new_count}")
+        print(f"   No existing videos were overridden ✅")
+        
+        return {
+            "timestamp": timestamp,
+            "robot_success": robot_success,
+            "drone_success": drone_success,
+            "videos_created": new_count,
+            "newest_videos": newest_videos
+        }
+        
+    except Exception as e:
+        print(f"❌ Error during trial recording: {e}")
+        import traceback
+        traceback.print_exc()
+        return None
+
+if __name__ == "__main__":
+    result = record_trial_videos()
+    
+    if result:
+        print(f"\n🏆 FINAL SUMMARY:")
+        print(f"Session: {result['timestamp']}")
+        print(f"Robot performance: {'✅ Success' if result['robot_success'] else '❌ Failed'}")  
+        print(f"Drone performance: {'✅ Success' if result['drone_success'] else '❌ Failed'}")
+        print(f"Videos recorded: {result['videos_created']}")
+        print(f"All videos preserved! 🎬")
+    else:
+        print("❌ Trial recording failed") 

run_trial.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""
+Trial script for testing the enhanced orchestrator with multiple iterations
+"""
+
+import main_orchestrator_enhanced
+import json
+import os
+from datetime import datetime
+
+def run_trial():
+    print("🚀 Starting Enhanced Orchestrator Trial...")
+    print("=" * 60)
+    
+    # Test with robot first
+    print("\n🤖 Testing Robot Design (up to 5 iterations)...")
+    try:
+        success, final_specs = main_orchestrator_enhanced.console_design_vehicle_for_obstacle(
+            vehicle_type='robot',
+            user_task_description='Design a robot that can pass the 5cm high obstacle'
+        )
+        
+        print(f"\n✅ Robot trial completed!")
+        print(f"Success: {success}")
+        print(f"Final specs: {final_specs}")
+        
+        # Check if JSON file was created
+        json_files = [f for f in os.listdir('.') if f.startswith('best_robot_design_') and f.endswith('.json')]
+        if json_files:
+            latest_json = max(json_files, key=os.path.getctime)
+            print(f"\n📄 Best design saved to: {latest_json}")
+            
+            # Show summary of best design
+            with open(latest_json, 'r') as f:
+                best_design = json.load(f)
+            
+            print(f"\n🏆 BEST ROBOT DESIGN SUMMARY:")
+            print(f"   • Final Position: {best_design['performance_results']['final_robot_x_position']:.3f}m")
+            print(f"   • Success: {best_design['performance_results']['overall_success']}")
+            print(f"   • Wheel Type: {best_design['robot_specifications']['wheel_type']}")
+            print(f"   • Body Clearance: {best_design['robot_specifications']['body_clearance_cm']}cm")
+            print(f"   • Material: {best_design['robot_specifications']['main_material']}")
+        
+    except Exception as e:
+        print(f"❌ Robot trial failed: {e}")
+        import traceback
+        traceback.print_exc()
+    
+    print("\n" + "=" * 60)
+    
+    # Test with drone
+    print("\n🚁 Testing Drone Design (up to 5 iterations)...")
+    try:
+        success, final_specs = main_orchestrator_enhanced.console_design_vehicle_for_obstacle(
+            vehicle_type='drone',
+            user_task_description='Design a drone that can pass the 5cm high obstacle'
+        )
+        
+        print(f"\n✅ Drone trial completed!")
+        print(f"Success: {success}")
+        print(f"Final specs: {final_specs}")
+        
+        # Check if JSON file was created
+        json_files = [f for f in os.listdir('.') if f.startswith('best_drone_design_') and f.endswith('.json')]
+        if json_files:
+            latest_json = max(json_files, key=os.path.getctime)
+            print(f"\n📄 Best design saved to: {latest_json}")
+            
+            # Show summary of best design
+            with open(latest_json, 'r') as f:
+                best_design = json.load(f)
+            
+            print(f"\n🏆 BEST DRONE DESIGN SUMMARY:")
+            print(f"   • Final Position: {best_design['performance_results']['final_robot_x_position']:.3f}m")
+            print(f"   • Success: {best_design['performance_results']['overall_success']}")
+            print(f"   • Propeller Size: {best_design['drone_specifications']['propeller_size']}")
+            print(f"   • Flight Height: {best_design['drone_specifications']['flight_height_cm']}cm")
+            print(f"   • Material: {best_design['drone_specifications']['main_material']}")
+        
+    except Exception as e:
+        print(f"❌ Drone trial failed: {e}")
+        import traceback
+        traceback.print_exc()
+    
+    print("\n🎯 Trial completed! Check the generated JSON files and GIF files for detailed results.")
+
+if __name__ == "__main__":
+    run_trial()