foodforthought-cli 0.2.1__py3-none-any.whl → 0.2.4__py3-none-any.whl

ate/mcp_server.py

@@ -195,6 +195,158 @@ def get_robot_tools() -> List[Tool]:
     ]
 
 
+def get_marketplace_tools() -> List[Tool]:
+    """Unified marketplace tools (Phase 6)"""
+    return [
+        Tool(
+            name="ate_marketplace_robots",
+            description="List community robots from the unified marketplace. Includes both Artifex-published and imported robots.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "search": {
+                        "type": "string",
+                        "description": "Search by name or description",
+                    },
+                    "category": {
+                        "type": "string",
+                        "enum": ["arm", "gripper", "mobile_base", "quadruped", "humanoid",
+                                "dual_arm", "manipulator", "cobot", "drone", "custom"],
+                        "description": "Filter by robot category",
+                    },
+                    "sort": {
+                        "type": "string",
+                        "enum": ["downloads", "rating", "recent", "name"],
+                        "description": "Sort order",
+                        "default": "downloads",
+                    },
+                    "limit": {
+                        "type": "number",
+                        "description": "Maximum results",
+                        "default": 20,
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="ate_marketplace_robot",
+            description="Get detailed information about a specific robot from the marketplace, including URDF, links, joints, and parts.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "robot_id": {
+                        "type": "string",
+                        "description": "Robot ID or slug",
+                    },
+                },
+                "required": ["robot_id"],
+            },
+        ),
+        Tool(
+            name="ate_marketplace_components",
+            description="List components from the parts marketplace. Components can be grippers, sensors, actuators, etc.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "search": {
+                        "type": "string",
+                        "description": "Search by name or description",
+                    },
+                    "type": {
+                        "type": "string",
+                        "enum": ["gripper", "end_effector", "sensor", "camera",
+                                "actuator", "link", "base", "arm_segment", "custom"],
+                        "description": "Filter by component type",
+                    },
+                    "sort": {
+                        "type": "string",
+                        "enum": ["downloads", "rating", "recent", "name"],
+                        "description": "Sort order",
+                        "default": "downloads",
+                    },
+                    "limit": {
+                        "type": "number",
+                        "description": "Maximum results",
+                        "default": 20,
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="ate_marketplace_component",
+            description="Get detailed information about a specific component, including compatible robots and specifications.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "component_id": {
+                        "type": "string",
+                        "description": "Component ID",
+                    },
+                },
+                "required": ["component_id"],
+            },
+        ),
+        Tool(
+            name="ate_skill_transfer_check",
+            description="Calculate skill transfer compatibility between robots. Shows which robots can receive skills from a source robot.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "robot_id": {
+                        "type": "string",
+                        "description": "Source robot ID",
+                    },
+                    "direction": {
+                        "type": "string",
+                        "enum": ["from", "to"],
+                        "description": "Direction: 'from' = skills from this robot can transfer to others",
+                        "default": "from",
+                    },
+                    "min_score": {
+                        "type": "number",
+                        "description": "Minimum compatibility score (0.0-1.0)",
+                        "default": 0.4,
+                    },
+                    "limit": {
+                        "type": "number",
+                        "description": "Maximum results",
+                        "default": 10,
+                    },
+                },
+                "required": ["robot_id"],
+            },
+        ),
+        Tool(
+            name="ate_robot_parts",
+            description="Get parts required by or compatible with a robot.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "robot_id": {
+                        "type": "string",
+                        "description": "Robot ID",
+                    },
+                },
+                "required": ["robot_id"],
+            },
+        ),
+        Tool(
+            name="ate_component_robots",
+            description="Get robots that use or are compatible with a component.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "component_id": {
+                        "type": "string",
+                        "description": "Component ID",
+                    },
+                },
+                "required": ["component_id"],
+            },
+        ),
+    ]
+
+
 def get_compatibility_tools() -> List[Tool]:
     """Skill compatibility and adaptation tools"""
     return [
@@ -798,126 +950,939 @@ def get_test_tools() -> List[Tool]:
     ]
 
 
-@server.list_tools()
-async def list_tools() -> List[Tool]:
-    """List all available MCP tools"""
-    tools = []
-    tools.extend(get_repository_tools())
-    tools.extend(get_robot_tools())
-    tools.extend(get_compatibility_tools())
-    tools.extend(get_skill_tools())
-    tools.extend(get_parts_tools())
-    tools.extend(get_generate_tools())
-    tools.extend(get_workflow_tools())
-    tools.extend(get_team_tools())
-    tools.extend(get_data_tools())
-    tools.extend(get_deploy_tools())
-    tools.extend(get_test_tools())
-    return tools
-
-
-# ============================================================================
-# Tool Handlers
-# ============================================================================
-
-def capture_output(func, *args, **kwargs):
-    """Capture printed output from a function"""
-    import io
-    import contextlib
-    
-    f = io.StringIO()
-    with contextlib.redirect_stdout(f):
-        try:
-            result = func(*args, **kwargs)
-        except SystemExit:
-            pass  # CLI functions may call sys.exit
-    return f.getvalue()
-
-
-@server.call_tool()
-async def call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
-    """Handle tool calls"""
-    try:
-        # Repository tools
-        if name == "ate_init":
-            result = client.init(
-                arguments["name"],
-                arguments.get("description", ""),
-                arguments.get("visibility", "public"),
-            )
-            return [
-                TextContent(
-                    type="text",
-                    text=f"Repository created successfully!\nID: {result['repository']['id']}\nName: {result['repository']['name']}",
-                )
-            ]
-
-        elif name == "ate_clone":
-            output = capture_output(
-                client.clone,
-                arguments["repo_id"], 
-                arguments.get("target_dir")
-            )
-            return [TextContent(type="text", text=output or f"Repository cloned successfully")]
+def get_compiler_tools() -> List[Tool]:
+    """
+    Skill Compiler Tools - Transform skill.yaml specifications into deployable robot skill packages.
 
-        elif name == "ate_list_repositories":
-            params = {}
-            if arguments.get("search"):
-                params["search"] = arguments["search"]
-            if arguments.get("robot_model"):
-                params["robotModel"] = arguments["robot_model"]
-            params["limit"] = arguments.get("limit", 20)
+    WORKFLOW FOR AI ASSISTANTS:
+    1. Use ate_list_primitives to discover available building blocks
+    2. Help user create skill.yaml with proper format
+    3. Use ate_validate_skill_spec to check for errors
+    4. Use ate_check_skill_compatibility to verify robot compatibility
+    5. Use ate_compile_skill to generate deployable code
+    6. Use ate_test_compiled_skill to test in dry-run or simulation
+    7. Use ate_publish_compiled_skill to share with community
 
-            response = client._request("GET", "/repositories", params=params)
-            repos = response.get("repositories", [])
+    See docs/SKILL_COMPILER.md for full documentation.
+    """
+    return [
+        Tool(
+            name="ate_compile_skill",
+            description="""Compile a skill.yaml specification into deployable code.
+
+WHEN TO USE: After creating and validating a skill.yaml file, use this to generate
+executable Python code, ROS2 packages, or Docker containers.
+
+TARGETS:
+- python: Standalone Python package (default, simplest)
+- ros2: ROS2-compatible package with launch files
+- docker: Containerized deployment with Dockerfile
+- all: Generate all formats
+
+EXAMPLE:
+{
+  "skill_path": "pick_and_place.skill.yaml",
+  "target": "python",
+  "output": "./dist/pick_and_place"
+}
+
+OUTPUT: Creates a directory with generated code, config files, and dependencies.""",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "skill_path": {
+                        "type": "string",
+                        "description": "Path to skill.yaml file (e.g., 'skills/pick_place.skill.yaml')",
+                    },
+                    "output": {
+                        "type": "string",
+                        "description": "Output directory (default: ./output). Will be created if doesn't exist.",
+                    },
+                    "target": {
+                        "type": "string",
+                        "enum": ["python", "ros2", "docker", "all"],
+                        "description": "Compilation target: python (simplest), ros2 (for ROS2 robots), docker (containerized), all",
+                        "default": "python",
+                    },
+                    "robot": {
+                        "type": "string",
+                        "description": "Optional: Path to robot URDF for hardware-specific config generation",
+                    },
+                },
+                "required": ["skill_path"],
+            },
+        ),
+        Tool(
+            name="ate_test_compiled_skill",
+            description="""Test a compiled skill without deploying to a real robot.
 
-            result_text = f"Found {len(repos)} repositories:\n\n"
-            for repo in repos[:10]:
-                result_text += f"- {repo['name']} (ID: {repo['id']})\n"
-                if repo.get("description"):
-                    result_text += f"  {repo['description'][:100]}...\n"
+WHEN TO USE: After compiling a skill, verify it works correctly before deployment.
 
-            return [TextContent(type="text", text=result_text)]
+MODES:
+- dry-run: Traces execution without any robot (fastest, always available)
+- sim: Runs in simulation (requires simulation setup)
+- hardware: Runs on real robot (requires robot_port)
 
-        elif name == "ate_get_repository":
-            response = client._request("GET", f"/repositories/{arguments['repo_id']}")
-            repo = response.get("repository", {})
+EXAMPLE:
+{
+  "skill_path": "./dist/pick_and_place",
+  "mode": "dry-run",
+  "params": {"speed": 0.3, "grip_force": 15.0}
+}
 
-            result_text = f"Repository: {repo.get('name', 'Unknown')}\n"
-            result_text += f"ID: {repo.get('id', 'Unknown')}\n"
-            result_text += f"Description: {repo.get('description', 'No description')}\n"
-            result_text += f"Visibility: {repo.get('visibility', 'unknown')}\n"
+OUTPUT: Execution trace showing each primitive call and its result.""",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "skill_path": {
+                        "type": "string",
+                        "description": "Path to compiled skill directory (output from ate_compile_skill)",
+                    },
+                    "mode": {
+                        "type": "string",
+                        "enum": ["sim", "dry-run", "hardware"],
+                        "description": "dry-run=trace only, sim=simulation, hardware=real robot",
+                        "default": "dry-run",
+                    },
+                    "robot_port": {
+                        "type": "string",
+                        "description": "Robot serial port (only for hardware mode, e.g., '/dev/ttyUSB0')",
+                    },
+                    "params": {
+                        "type": "object",
+                        "description": "Override skill parameters (e.g., {\"speed\": 0.5})",
+                    },
+                },
+                "required": ["skill_path"],
+            },
+        ),
+        Tool(
+            name="ate_publish_compiled_skill",
+            description="""Publish a compiled skill to the FoodForThought registry.
 
-            return [TextContent(type="text", text=result_text)]
+WHEN TO USE: When the skill is tested and ready to share with others.
 
-        # Robot tools
-        elif name == "ate_list_robots":
-            params = {}
-            if arguments.get("search"):
-                params["search"] = arguments["search"]
-            if arguments.get("category"):
-                params["category"] = arguments["category"]
-            params["limit"] = arguments.get("limit", 20)
+VISIBILITY:
+- public: Anyone can use this skill
+- private: Only you can see it
+- team: Shared with your team members
 
-            response = client._request("GET", "/robots/profiles", params=params)
-            robots = response.get("profiles", [])
+EXAMPLE:
+{
+  "skill_path": "./dist/pick_and_place",
+  "visibility": "public"
+}
 
-            result_text = f"Found {len(robots)} robot profiles:\n\n"
-            for robot in robots[:10]:
-                result_text += f"- {robot['modelName']} by {robot['manufacturer']} (ID: {robot['id']})\n"
-                if robot.get("description"):
-                    result_text += f"  {robot['description'][:100]}...\n"
+OUTPUT: Registry URL where the skill is published.""",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "skill_path": {
+                        "type": "string",
+                        "description": "Path to compiled skill directory to publish",
+                    },
+                    "visibility": {
+                        "type": "string",
+                        "enum": ["public", "private", "team"],
+                        "description": "Who can access this skill",
+                        "default": "public",
+                    },
+                },
+                "required": ["skill_path"],
+            },
+        ),
+        Tool(
+            name="ate_check_skill_compatibility",
+            description="""Check if a skill can run on a specific robot.
 
-            return [TextContent(type="text", text=result_text)]
+WHEN TO USE: Before compiling, verify the skill's hardware requirements
+match the target robot's capabilities (DOF, sensors, payload, etc.).
 
-        elif name == "ate_get_robot":
-            response = client._request("GET", f"/robots/profiles/{arguments['robot_id']}")
-            robot = response.get("profile", {})
+CHECKS PERFORMED:
+- Arm DOF and reach requirements
+- Gripper type and force capabilities
+- Required sensors (cameras, F/T sensors)
+- Workspace bounds
 
-            result_text = f"Robot: {robot.get('modelName', 'Unknown')}\n"
-            result_text += f"Manufacturer: {robot.get('manufacturer', 'Unknown')}\n"
-            result_text += f"Category: {robot.get('category', 'Unknown')}\n"
-            result_text += f"Description: {robot.get('description', 'No description')}\n"
+EXAMPLE:
+{
+  "skill_path": "pick_and_place.skill.yaml",
+  "robot_urdf": "robots/ur5/ur5.urdf"
+}
+
+OUTPUT: Compatibility report with score and list of issues/adaptations needed.""",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "skill_path": {
+                        "type": "string",
+                        "description": "Path to skill.yaml file",
+                    },
+                    "robot_urdf": {
+                        "type": "string",
+                        "description": "Path to robot URDF file",
+                    },
+                    "robot_ate_dir": {
+                        "type": "string",
+                        "description": "Alternative: Path to directory containing ate.yaml robot config",
+                    },
+                },
+                "required": ["skill_path"],
+            },
+        ),
+        Tool(
+            name="ate_list_primitives",
+            description="""List available primitives (building blocks) for creating skills.
+
+WHEN TO USE: When starting to create a skill, or when you need to know what
+operations are available for a specific hardware type.
+
+CATEGORIES:
+- motion: Movement primitives (move_to_pose, move_linear, etc.)
+- gripper: Gripper actions (open_gripper, close_gripper)
+- sensing: Sensor reading (capture_image, read_force_torque)
+- wait: Timing and conditions (wait_time, wait_for_contact)
+- control: Control modes (set_control_mode, enable_compliance)
+
+EXAMPLE - List all motion primitives:
+{
+  "category": "motion"
+}
+
+EXAMPLE - List primitives that need a camera:
+{
+  "hardware": "camera"
+}
+
+OUTPUT: List of primitives with their descriptions and parameters.""",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "category": {
+                        "type": "string",
+                        "enum": ["motion", "gripper", "sensing", "wait", "control", "all"],
+                        "description": "Filter by category (use 'all' to see everything)",
+                        "default": "all",
+                    },
+                    "hardware": {
+                        "type": "string",
+                        "description": "Filter by hardware type: arm, gripper, camera, force_torque_sensor",
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="ate_get_primitive",
+            description="""Get detailed information about a specific primitive.
+
+WHEN TO USE: When you need to know the exact parameters and requirements
+for a primitive before using it in a skill.
+
+COMMON PRIMITIVES:
+- move_to_pose: Move end-effector to a 7D pose [x,y,z,qx,qy,qz,qw]
+- move_to_joint_positions: Move to specific joint angles
+- open_gripper / close_gripper: Gripper control
+- wait_for_contact: Wait until force threshold is reached
+- capture_image: Take a camera image
+
+EXAMPLE:
+{
+  "name": "move_to_pose"
+}
+
+OUTPUT: Full primitive definition with all parameters, types, defaults, and hardware requirements.""",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "name": {
+                        "type": "string",
+                        "description": "Primitive name (e.g., 'move_to_pose', 'close_gripper', 'wait_for_contact')",
+                    },
+                },
+                "required": ["name"],
+            },
+        ),
+        Tool(
+            name="ate_validate_skill_spec",
+            description="""Validate a skill.yaml file without compiling.
+
+WHEN TO USE: After creating or modifying a skill.yaml, check for errors before compiling.
+
+CHECKS PERFORMED:
+- YAML syntax validity
+- Required fields (name, version, description, execution)
+- Parameter type validity
+- Primitive names exist in registry
+- Template expression syntax
+- Hardware requirement format
+
+EXAMPLE:
+{
+  "skill_path": "my_skill.skill.yaml"
+}
+
+OUTPUT:
+- If valid: Summary of skill (name, version, parameter count, etc.)
+- If invalid: List of errors with line numbers and fix suggestions.""",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "skill_path": {
+                        "type": "string",
+                        "description": "Path to skill.yaml file to validate",
+                    },
+                },
+                "required": ["skill_path"],
+            },
+        ),
+    ]
+
+
+def get_protocol_tools() -> List[Tool]:
+    """Protocol registry tools"""
+    return [
+        Tool(
+            name="ate_protocol_list",
+            description="List protocols from the FoodForThought protocol registry. Protocols document how to communicate with robot hardware (BLE, serial, WiFi, CAN, etc.)",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "robot_model": {
+                        "type": "string",
+                        "description": "Filter by robot model name (e.g., 'mechdog', 'ur5')",
+                    },
+                    "transport_type": {
+                        "type": "string",
+                        "enum": ["ble", "serial", "wifi", "can", "i2c", "spi", "mqtt", "ros2"],
+                        "description": "Filter by transport type",
+                    },
+                    "verified_only": {
+                        "type": "boolean",
+                        "description": "Show only community-verified protocols",
+                        "default": False,
+                    },
+                    "search": {
+                        "type": "string",
+                        "description": "Search in command format and discovery notes",
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="ate_protocol_get",
+            description="Get detailed protocol information including BLE characteristics, serial config, command schema, and associated primitive skills",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "protocol_id": {
+                        "type": "string",
+                        "description": "Protocol ID to fetch",
+                    },
+                },
+                "required": ["protocol_id"],
+            },
+        ),
+        Tool(
+            name="ate_protocol_init",
+            description="Initialize a new protocol template for a robot. Creates protocol.json and README with transport-specific fields to fill in",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "robot_model": {
+                        "type": "string",
+                        "description": "Robot model name (e.g., 'hiwonder-mechdog-pro')",
+                    },
+                    "transport_type": {
+                        "type": "string",
+                        "enum": ["ble", "serial", "wifi", "can", "i2c", "spi", "mqtt", "ros2"],
+                        "description": "Transport type for communication",
+                    },
+                    "output_dir": {
+                        "type": "string",
+                        "description": "Output directory for protocol files",
+                        "default": "./protocol",
+                    },
+                },
+                "required": ["robot_model", "transport_type"],
+            },
+        ),
+        Tool(
+            name="ate_protocol_push",
+            description="Upload a protocol definition to FoodForThought registry for community use",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "protocol_file": {
+                        "type": "string",
+                        "description": "Path to protocol.json file (default: ./protocol.json)",
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="ate_protocol_scan_serial",
+            description="Scan for available serial ports on the system. Useful for discovering connected robot hardware",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+            },
+        ),
+        Tool(
+            name="ate_protocol_scan_ble",
+            description="Scan for BLE devices in range. Useful for discovering robot devices before connecting",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+            },
+        ),
+    ]
+
+
+def get_primitive_tools() -> List[Tool]:
+    """Primitive skills tools"""
+    return [
+        Tool(
+            name="ate_primitive_list",
+            description="List primitive skills - tested atomic robot operations like 'tilt_forward', 'gripper_close', etc. with safe parameter ranges",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "robot_model": {
+                        "type": "string",
+                        "description": "Filter by robot model name",
+                    },
+                    "category": {
+                        "type": "string",
+                        "enum": ["body_pose", "arm", "gripper", "locomotion", "head", "sensing", "manipulation", "navigation"],
+                        "description": "Filter by primitive category",
+                    },
+                    "status": {
+                        "type": "string",
+                        "enum": ["experimental", "tested", "verified", "deprecated"],
+                        "description": "Filter by status",
+                    },
+                    "tested_only": {
+                        "type": "boolean",
+                        "description": "Show only tested/verified primitives",
+                        "default": False,
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="ate_primitive_get",
+            description="Get detailed primitive skill info including command template, tested parameters with safe ranges, timing, safety notes, and dependencies",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "primitive_id": {
+                        "type": "string",
+                        "description": "Primitive skill ID to fetch",
+                    },
+                },
+                "required": ["primitive_id"],
+            },
+        ),
+        Tool(
+            name="ate_primitive_test",
+            description="Submit a test result for a primitive skill. Contributes to reliability score and helps verify safe operation ranges",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "primitive_id": {
+                        "type": "string",
+                        "description": "Primitive skill ID to test",
+                    },
+                    "params": {
+                        "type": "string",
+                        "description": "Parameters used in test as JSON string (e.g., '{\"pitch\": 15}')",
+                    },
+                    "result": {
+                        "type": "string",
+                        "enum": ["pass", "fail", "partial"],
+                        "description": "Test result",
+                    },
+                    "notes": {
+                        "type": "string",
+                        "description": "Additional notes about the test",
+                    },
+                    "video_url": {
+                        "type": "string",
+                        "description": "URL to video recording of test",
+                    },
+                },
+                "required": ["primitive_id", "params", "result"],
+            },
+        ),
+        Tool(
+            name="ate_primitive_deps_show",
+            description="Show dependency graph for a primitive skill. Shows what primitives it depends on and what depends on it. Indicates deployment readiness",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "primitive_id": {
+                        "type": "string",
+                        "description": "Primitive skill ID",
+                    },
+                },
+                "required": ["primitive_id"],
+            },
+        ),
+        Tool(
+            name="ate_primitive_deps_add",
+            description="Add a dependency to a primitive skill. Creates deployment gates to ensure required primitives are tested before deployment",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "primitive_id": {
+                        "type": "string",
+                        "description": "Primitive skill ID (the one that depends)",
+                    },
+                    "required_id": {
+                        "type": "string",
+                        "description": "Required primitive skill ID",
+                    },
+                    "dependency_type": {
+                        "type": "string",
+                        "enum": ["requires", "extends", "overrides", "optional"],
+                        "description": "Type of dependency",
+                        "default": "requires",
+                    },
+                    "min_status": {
+                        "type": "string",
+                        "enum": ["experimental", "tested", "verified"],
+                        "description": "Minimum required status for deployment",
+                        "default": "tested",
+                    },
+                },
+                "required": ["primitive_id", "required_id"],
+            },
+        ),
+    ]
+
+
+def get_bridge_tools() -> List[Tool]:
+    """Robot bridge tools for interactive communication"""
+    return [
+        Tool(
+            name="ate_bridge_scan_serial",
+            description="Scan for available serial ports. Use this to discover connected robots before using bridge connect",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+                "required": [],
+            },
+        ),
+        Tool(
+            name="ate_bridge_scan_ble",
+            description="Scan for BLE devices. Use this to discover bluetooth robots before using bridge connect",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+                "required": [],
+            },
+        ),
+        Tool(
+            name="ate_bridge_send",
+            description="Send a single command to a robot and get the response. Useful for quick tests without opening a full interactive session",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "port": {
+                        "type": "string",
+                        "description": "Serial port (e.g., /dev/tty.usbserial-0001) or BLE address",
+                    },
+                    "command": {
+                        "type": "string",
+                        "description": "Command to send to the robot",
+                    },
+                    "transport": {
+                        "type": "string",
+                        "enum": ["serial", "ble"],
+                        "description": "Transport type",
+                        "default": "serial",
+                    },
+                    "baud_rate": {
+                        "type": "integer",
+                        "description": "Baud rate for serial connection",
+                        "default": 115200,
+                    },
+                    "wait": {
+                        "type": "number",
+                        "description": "Wait time for response in seconds",
+                        "default": 0.5,
+                    },
+                },
+                "required": ["port", "command"],
+            },
+        ),
+        Tool(
+            name="ate_bridge_replay",
+            description="Replay a recorded robot session. Useful for testing primitives or reproducing sequences",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "recording": {
+                        "type": "string",
+                        "description": "Path to recording JSON file",
+                    },
+                    "port": {
+                        "type": "string",
+                        "description": "Serial port or BLE address",
+                    },
+                    "transport": {
+                        "type": "string",
+                        "enum": ["serial", "ble"],
+                        "description": "Transport type",
+                        "default": "serial",
+                    },
+                    "baud_rate": {
+                        "type": "integer",
+                        "description": "Baud rate for serial connection",
+                        "default": 115200,
+                    },
+                    "speed": {
+                        "type": "number",
+                        "description": "Playback speed multiplier (1.0 = normal, 2.0 = 2x speed)",
+                        "default": 1.0,
+                    },
+                },
+                "required": ["recording", "port"],
+            },
+        ),
+    ]
+
+
+@server.list_tools()
+async def list_tools() -> List[Tool]:
+    """List all available MCP tools"""
+    tools = []
+    tools.extend(get_repository_tools())
+    tools.extend(get_robot_tools())
+    tools.extend(get_marketplace_tools())  # Phase 6: Unified marketplace
+    tools.extend(get_compatibility_tools())
+    tools.extend(get_skill_tools())
+    tools.extend(get_protocol_tools())
+    tools.extend(get_primitive_tools())
+    tools.extend(get_bridge_tools())
+    tools.extend(get_parts_tools())
+    tools.extend(get_generate_tools())
+    tools.extend(get_workflow_tools())
+    tools.extend(get_team_tools())
+    tools.extend(get_data_tools())
+    tools.extend(get_deploy_tools())
+    tools.extend(get_test_tools())
+    tools.extend(get_compiler_tools())
+    return tools
+
+
+# ============================================================================
+# Tool Handlers
+# ============================================================================
+
+def capture_output(func, *args, **kwargs):
+    """Capture printed output from a function"""
+    import io
+    import contextlib
+    
+    f = io.StringIO()
+    with contextlib.redirect_stdout(f):
+        try:
+            result = func(*args, **kwargs)
+        except SystemExit:
+            pass  # CLI functions may call sys.exit
+    return f.getvalue()
+
+
+@server.call_tool()
+async def call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
+    """Handle tool calls"""
+    try:
+        # Repository tools
+        if name == "ate_init":
+            result = client.init(
+                arguments["name"],
+                arguments.get("description", ""),
+                arguments.get("visibility", "public"),
+            )
+            return [
+                TextContent(
+                    type="text",
+                    text=f"Repository created successfully!\nID: {result['repository']['id']}\nName: {result['repository']['name']}",
+                )
+            ]
+
+        elif name == "ate_clone":
+            output = capture_output(
+                client.clone,
+                arguments["repo_id"], 
+                arguments.get("target_dir")
+            )
+            return [TextContent(type="text", text=output or f"Repository cloned successfully")]
+
+        elif name == "ate_list_repositories":
+            params = {}
+            if arguments.get("search"):
+                params["search"] = arguments["search"]
+            if arguments.get("robot_model"):
+                params["robotModel"] = arguments["robot_model"]
+            params["limit"] = arguments.get("limit", 20)
+
+            response = client._request("GET", "/repositories", params=params)
+            repos = response.get("repositories", [])
+
+            result_text = f"Found {len(repos)} repositories:\n\n"
+            for repo in repos[:10]:
+                result_text += f"- {repo['name']} (ID: {repo['id']})\n"
+                if repo.get("description"):
+                    result_text += f"  {repo['description'][:100]}...\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_get_repository":
+            response = client._request("GET", f"/repositories/{arguments['repo_id']}")
+            repo = response.get("repository", {})
+
+            result_text = f"Repository: {repo.get('name', 'Unknown')}\n"
+            result_text += f"ID: {repo.get('id', 'Unknown')}\n"
+            result_text += f"Description: {repo.get('description', 'No description')}\n"
+            result_text += f"Visibility: {repo.get('visibility', 'unknown')}\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        # Robot tools
+        elif name == "ate_list_robots":
+            params = {}
+            if arguments.get("search"):
+                params["search"] = arguments["search"]
+            if arguments.get("category"):
+                params["category"] = arguments["category"]
+            params["limit"] = arguments.get("limit", 20)
+
+            response = client._request("GET", "/robots/profiles", params=params)
+            robots = response.get("profiles", [])
+
+            result_text = f"Found {len(robots)} robot profiles:\n\n"
+            for robot in robots[:10]:
+                result_text += f"- {robot['modelName']} by {robot['manufacturer']} (ID: {robot['id']})\n"
+                if robot.get("description"):
+                    result_text += f"  {robot['description'][:100]}...\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_get_robot":
+            response = client._request("GET", f"/robots/profiles/{arguments['robot_id']}")
+            robot = response.get("profile", {})
+
+            result_text = f"Robot: {robot.get('modelName', 'Unknown')}\n"
+            result_text += f"Manufacturer: {robot.get('manufacturer', 'Unknown')}\n"
+            result_text += f"Category: {robot.get('category', 'Unknown')}\n"
+            result_text += f"Description: {robot.get('description', 'No description')}\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        # Marketplace tools (Phase 6)
+        elif name == "ate_marketplace_robots":
+            params = {}
+            if arguments.get("search"):
+                params["q"] = arguments["search"]
+            if arguments.get("category"):
+                params["category"] = arguments["category"]
+            if arguments.get("sort"):
+                params["sortBy"] = arguments["sort"]
+            params["limit"] = arguments.get("limit", 20)
+
+            response = client._request("GET", "/robots/unified", params=params)
+            robots = response.get("robots", [])
+
+            if not robots:
+                return [TextContent(type="text", text="No robots found matching your criteria.")]
+
+            result_text = f"Found {len(robots)} robots:\n\n"
+            for robot in robots[:20]:
+                result_text += f"- **{robot.get('name', 'Unknown')}** ({robot.get('manufacturer', 'Unknown')})\n"
+                result_text += f"  ID: {robot.get('id')} | Category: {robot.get('category')} | DOF: {robot.get('dof', 'N/A')}\n"
+                if robot.get("description"):
+                    result_text += f"  {robot['description'][:100]}...\n"
+                result_text += "\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_marketplace_robot":
+            robot_id = arguments["robot_id"]
+            response = client._request("GET", f"/robots/unified/{robot_id}")
+            robot = response.get("robot", {})
+
+            if not robot:
+                return [TextContent(type="text", text=f"Robot not found: {robot_id}")]
+
+            result_text = f"# {robot.get('name', 'Unknown')}\n\n"
+            result_text += f"**Manufacturer:** {robot.get('manufacturer', 'Unknown')}\n"
+            result_text += f"**Category:** {robot.get('category', 'Unknown')}\n"
+            result_text += f"**DOF:** {robot.get('dof', 'N/A')}\n"
+            result_text += f"**Downloads:** {robot.get('downloads', 0)}\n\n"
+
+            if robot.get("description"):
+                result_text += f"## Description\n{robot['description']}\n\n"
+
+            links = robot.get("links", [])
+            if links:
+                result_text += f"## Links ({len(links)})\n"
+                for link in links[:5]:
+                    result_text += f"- {link.get('name', 'Unnamed')}\n"
+
+            joints = robot.get("joints", [])
+            if joints:
+                result_text += f"\n## Joints ({len(joints)})\n"
+                for joint in joints[:5]:
+                    result_text += f"- {joint.get('name', 'Unnamed')}: {joint.get('type', 'unknown')}\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_marketplace_components":
+            params = {}
+            if arguments.get("search"):
+                params["q"] = arguments["search"]
+            if arguments.get("type"):
+                params["type"] = arguments["type"]
+            if arguments.get("sort"):
+                params["sortBy"] = arguments["sort"]
+            params["limit"] = arguments.get("limit", 20)
+
+            response = client._request("GET", "/components", params=params)
+            components = response.get("components", [])
+
+            if not components:
+                return [TextContent(type="text", text="No components found matching your criteria.")]
+
+            result_text = f"Found {len(components)} components:\n\n"
+            for comp in components[:20]:
+                verified = " ✓" if comp.get("verified") else ""
+                result_text += f"- **{comp.get('name', 'Unknown')}** v{comp.get('version', '1.0')}{verified}\n"
+                result_text += f"  ID: {comp.get('id')} | Type: {comp.get('type')} | Downloads: {comp.get('downloads', 0)}\n"
+                if comp.get("description"):
+                    result_text += f"  {comp['description'][:80]}...\n"
+                result_text += "\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_marketplace_component":
+            component_id = arguments["component_id"]
+            response = client._request("GET", f"/components/{component_id}")
+            comp = response.get("component", {})
+
+            if not comp:
+                return [TextContent(type="text", text=f"Component not found: {component_id}")]
+
+            verified = "Yes ✓" if comp.get("verified") else "No"
+            result_text = f"# {comp.get('name', 'Unknown')}\n\n"
+            result_text += f"**Type:** {comp.get('type', 'Unknown')}\n"
+            result_text += f"**Version:** {comp.get('version', '1.0')}\n"
+            result_text += f"**Verified:** {verified}\n"
+            result_text += f"**Downloads:** {comp.get('downloads', 0)}\n\n"
+
+            if comp.get("description"):
+                result_text += f"## Description\n{comp['description']}\n\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_skill_transfer_check":
+            robot_id = arguments["robot_id"]
+            direction = arguments.get("direction", "from")
+            min_score = arguments.get("min_score", 0.4)
+            limit = arguments.get("limit", 10)
+
+            params = {
+                "direction": direction,
+                "minScore": min_score,
+                "limit": limit,
+            }
+            response = client._request("GET", f"/robots/unified/{robot_id}/skill-transfer", params=params)
+
+            if response.get("error"):
+                return [TextContent(type="text", text=f"Error: {response['error']}")]
+
+            source = response.get("sourceRobot", {})
+            results = response.get("results", [])
+
+            if not results:
+                return [TextContent(type="text", text=f"No compatible robots found for skill transfer from {source.get('name', robot_id)}.")]
+
+            result_text = f"# Skill Transfer Compatibility for {source.get('name', 'Unknown')}\n\n"
+            result_text += f"Direction: Skills can transfer **{direction}** this robot\n\n"
+
+            result_text += f"## Compatible Robots ({len(results)})\n\n"
+            for item in results:
+                robot = item.get("robot", {})
+                scores = item.get("scores", {})
+                adaptation = item.get("adaptationType", "unknown")
+                result_text += f"- **{robot.get('name', 'Unknown')}** - {int(scores.get('overall', 0) * 100)}% ({adaptation})\n"
+                result_text += f"  Category: {robot.get('category')} | DOF: {robot.get('dof', 'N/A')}\n\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_robot_parts":
+            robot_id = arguments["robot_id"]
+            response = client._request("GET", f"/robots/unified/{robot_id}/parts")
+
+            if response.get("error"):
+                return [TextContent(type="text", text=f"Error: {response['error']}")]
+
+            robot_name = response.get("robotName", robot_id)
+            required = response.get("requiredParts", [])
+            compatible = response.get("compatibleParts", [])
+
+            result_text = f"# Parts for {robot_name}\n\n"
+
+            if required:
+                result_text += f"## Required Parts ({len(required)})\n"
+                for req in required:
+                    comp = req.get("component", {})
+                    result_text += f"- **{comp.get('name', 'Unknown')}** ({comp.get('type', 'unknown')})\n"
+                    result_text += f"  Quantity: {req.get('quantity', 1)} | Required: {'Yes' if req.get('required') else 'Optional'}\n\n"
+            else:
+                result_text += "## Required Parts\nNo required parts specified.\n\n"
+
+            if compatible:
+                result_text += f"## Compatible Parts ({len(compatible)})\n"
+                for compat in compatible[:10]:
+                    comp = compat.get("component", {})
+                    score = compat.get("compatibilityScore", 0)
+                    result_text += f"- **{comp.get('name', 'Unknown')}** ({comp.get('type', 'unknown')})\n"
+                    result_text += f"  Compatibility: {int(score * 100)}%\n\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_component_robots":
+            component_id = arguments["component_id"]
+            response = client._request("GET", f"/components/{component_id}/compatible-robots")
+
+            if response.get("error"):
+                return [TextContent(type="text", text=f"Error: {response['error']}")]
+
+            comp_name = response.get("componentName", component_id)
+            required_by = response.get("requiredBy", [])
+            compatible_with = response.get("compatibleWith", [])
+
+            result_text = f"# Robots for {comp_name}\n\n"
+
+            if required_by:
+                result_text += f"## Required By ({len(required_by)} robots)\n"
+                for req in required_by:
+                    robot = req.get("robot", {})
+                    result_text += f"- **{robot.get('name', 'Unknown')}** ({robot.get('category', 'unknown')})\n"
+                    result_text += f"  Quantity: {req.get('quantity', 1)}\n\n"
+            else:
+                result_text += "## Required By\nNo robots require this component.\n\n"
+
+            if compatible_with:
+                result_text += f"## Compatible With ({len(compatible_with)} robots)\n"
+                for compat in compatible_with[:10]:
+                    robot = compat.get("robot", {})
+                    score = compat.get("compatibilityScore", 0)
+                    verified = " ✓" if compat.get("verified") else ""
+                    result_text += f"- **{robot.get('name', 'Unknown')}** ({robot.get('category', 'unknown')})\n"
+                    result_text += f"  Compatibility: {int(score * 100)}%{verified}\n\n"
 
             return [TextContent(type="text", text=result_text)]
 
@@ -1151,6 +2116,275 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
             )
             return [TextContent(type="text", text=output)]
 
+        # Protocol tools
+        elif name == "ate_protocol_list":
+            output = capture_output(
+                client.protocol_list,
+                arguments.get("robot_model"),
+                arguments.get("transport_type"),
+                arguments.get("verified_only", False),
+                arguments.get("search")
+            )
+            return [TextContent(type="text", text=output)]
+
+        elif name == "ate_protocol_get":
+            output = capture_output(
+                client.protocol_get,
+                arguments["protocol_id"]
+            )
+            return [TextContent(type="text", text=output)]
+
+        elif name == "ate_protocol_init":
+            output = capture_output(
+                client.protocol_init,
+                arguments["robot_model"],
+                arguments["transport_type"],
+                arguments.get("output_dir", "./protocol")
+            )
+            return [TextContent(type="text", text=output)]
+
+        elif name == "ate_protocol_push":
+            output = capture_output(
+                client.protocol_push,
+                arguments.get("protocol_file")
+            )
+            return [TextContent(type="text", text=output)]
+
+        elif name == "ate_protocol_scan_serial":
+            output = capture_output(client.protocol_scan_serial)
+            return [TextContent(type="text", text=output)]
+
+        elif name == "ate_protocol_scan_ble":
+            output = capture_output(client.protocol_scan_ble)
+            return [TextContent(type="text", text=output)]
+
+        # Primitive tools
+        elif name == "ate_primitive_list":
+            output = capture_output(
+                client.primitive_list,
+                arguments.get("robot_model"),
+                arguments.get("category"),
+                arguments.get("status"),
+                arguments.get("tested_only", False)
+            )
+            return [TextContent(type="text", text=output)]
+
+        elif name == "ate_primitive_get":
+            output = capture_output(
+                client.primitive_get,
+                arguments["primitive_id"]
+            )
+            return [TextContent(type="text", text=output)]
+
+        elif name == "ate_primitive_test":
+            output = capture_output(
+                client.primitive_test,
+                arguments["primitive_id"],
+                arguments["params"],
+                arguments["result"],
+                arguments.get("notes"),
+                arguments.get("video_url")
+            )
+            return [TextContent(type="text", text=output)]
+
+        elif name == "ate_primitive_deps_show":
+            output = capture_output(
+                client.primitive_deps_show,
+                arguments["primitive_id"]
+            )
+            return [TextContent(type="text", text=output)]
+
+        elif name == "ate_primitive_deps_add":
+            output = capture_output(
+                client.primitive_deps_add,
+                arguments["primitive_id"],
+                arguments["required_id"],
+                arguments.get("dependency_type", "requires"),
+                arguments.get("min_status", "tested")
+            )
+            return [TextContent(type="text", text=output)]
+
+        # Bridge tools
+        elif name == "ate_bridge_scan_serial":
+            output = capture_output(client.protocol_scan_serial)
+            return [TextContent(type="text", text=output)]
+
+        elif name == "ate_bridge_scan_ble":
+            output = capture_output(client.protocol_scan_ble)
+            return [TextContent(type="text", text=output)]
+
+        elif name == "ate_bridge_send":
+            output = capture_output(
+                client.bridge_send,
+                arguments["port"],
+                arguments["command"],
+                arguments.get("transport", "serial"),
+                arguments.get("baud_rate", 115200),
+                arguments.get("wait", 0.5)
+            )
+            return [TextContent(type="text", text=output if output else "Command sent (no response)")]
+
+        elif name == "ate_bridge_replay":
+            output = capture_output(
+                client.bridge_replay,
+                arguments["recording"],
+                arguments["port"],
+                arguments.get("transport", "serial"),
+                arguments.get("baud_rate", 115200),
+                arguments.get("speed", 1.0)
+            )
+            return [TextContent(type="text", text=output)]
+
+        # Compiler tools
+        elif name == "ate_compile_skill":
+            output = capture_output(
+                client.compile_skill,
+                arguments["skill_path"],
+                arguments.get("output", "./output"),
+                arguments.get("target", "python"),
+                arguments.get("robot"),
+                arguments.get("ate_dir")
+            )
+            return [TextContent(type="text", text=output or "Skill compiled successfully")]
+
+        elif name == "ate_test_compiled_skill":
+            output = capture_output(
+                client.test_compiled_skill,
+                arguments["skill_path"],
+                arguments.get("mode", "dry-run"),
+                arguments.get("robot_port"),
+                arguments.get("params", {})
+            )
+            return [TextContent(type="text", text=output or "Skill test completed")]
+
+        elif name == "ate_publish_compiled_skill":
+            output = capture_output(
+                client.publish_compiled_skill,
+                arguments["skill_path"],
+                arguments.get("visibility", "public")
+            )
+            return [TextContent(type="text", text=output or "Skill published successfully")]
+
+        elif name == "ate_check_skill_compatibility":
+            output = capture_output(
+                client.check_skill_compatibility,
+                arguments["skill_path"],
+                arguments.get("robot_urdf"),
+                arguments.get("robot_ate_dir")
+            )
+            return [TextContent(type="text", text=output or "Compatibility check completed")]
+
+        elif name == "ate_list_primitives":
+            from ate.primitives import PRIMITIVE_REGISTRY, PrimitiveCategory
+
+            category = arguments.get("category", "all")
+            hardware = arguments.get("hardware")
+
+            result_text = "# Available Primitives\n\n"
+
+            for prim_name, prim_def in PRIMITIVE_REGISTRY.items():
+                # Filter by category
+                if category != "all":
+                    cat_match = prim_def.get("category", "").lower() == category.lower()
+                    if not cat_match:
+                        continue
+
+                # Filter by hardware
+                if hardware:
+                    req_hardware = prim_def.get("hardware", [])
+                    if hardware.lower() not in [h.lower() for h in req_hardware]:
+                        continue
+
+                result_text += f"## {prim_name}\n"
+                result_text += f"**Category:** {prim_def.get('category', 'unknown')}\n"
+                result_text += f"**Description:** {prim_def.get('description', 'No description')}\n"
+
+                # Parameters
+                params = prim_def.get("parameters", {})
+                if params:
+                    result_text += "**Parameters:**\n"
+                    for param_name, param_def in params.items():
+                        required = "required" if param_def.get("required", False) else "optional"
+                        result_text += f"  - `{param_name}` ({param_def.get('type', 'any')}, {required}): {param_def.get('description', '')}\n"
+
+                # Hardware requirements
+                hw_reqs = prim_def.get("hardware", [])
+                if hw_reqs:
+                    result_text += f"**Hardware:** {', '.join(hw_reqs)}\n"
+
+                result_text += "\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_get_primitive":
+            from ate.primitives import get_primitive
+
+            prim_name = arguments["name"]
+            prim_def = get_primitive(prim_name)
+
+            if not prim_def:
+                return [TextContent(type="text", text=f"Primitive not found: {prim_name}")]
+
+            result_text = f"# {prim_name}\n\n"
+            result_text += f"**Category:** {prim_def.get('category', 'unknown')}\n"
+            result_text += f"**Description:** {prim_def.get('description', 'No description')}\n\n"
+
+            # Parameters
+            params = prim_def.get("parameters", {})
+            if params:
+                result_text += "## Parameters\n\n"
+                for param_name, param_def in params.items():
+                    required = "✓ Required" if param_def.get("required", False) else "○ Optional"
+                    default = f", default: `{param_def.get('default')}`" if "default" in param_def else ""
+                    result_text += f"### `{param_name}`\n"
+                    result_text += f"- **Type:** {param_def.get('type', 'any')}\n"
+                    result_text += f"- **Status:** {required}{default}\n"
+                    result_text += f"- **Description:** {param_def.get('description', '')}\n\n"
+
+            # Hardware requirements
+            hw_reqs = prim_def.get("hardware", [])
+            if hw_reqs:
+                result_text += f"## Hardware Requirements\n\n"
+                for hw in hw_reqs:
+                    result_text += f"- {hw}\n"
+
+            # Return type
+            result_text += f"\n## Returns\n\n`{prim_def.get('returns', 'bool')}`\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_validate_skill_spec":
+            from ate.skill_schema import SkillSpecification
+
+            skill_path = arguments["skill_path"]
+
+            try:
+                spec = SkillSpecification.from_yaml(skill_path)
+                errors = spec.validate()
+
+                if errors:
+                    result_text = f"# Validation Failed\n\n"
+                    result_text += f"Found {len(errors)} error(s) in `{skill_path}`:\n\n"
+                    for error in errors:
+                        result_text += f"- ❌ {error}\n"
+                    return [TextContent(type="text", text=result_text)]
+
+                result_text = f"# Validation Passed ✓\n\n"
+                result_text += f"**Skill:** {spec.name}\n"
+                result_text += f"**Version:** {spec.version}\n"
+                result_text += f"**Description:** {spec.description}\n\n"
+
+                # Summary
+                result_text += "## Summary\n\n"
+                result_text += f"- **Parameters:** {len(spec.parameters)}\n"
+                result_text += f"- **Hardware Requirements:** {len(spec.hardware_requirements)}\n"
+                result_text += f"- **Execution Steps:** {len(spec.execution)}\n"
+                result_text += f"- **Success Criteria:** {len(spec.success_criteria)}\n"
+
+                return [TextContent(type="text", text=result_text)]
+            except Exception as e:
+                return [TextContent(type="text", text=f"# Validation Error\n\nFailed to parse skill specification:\n\n```\n{str(e)}\n```")]
+
         else:
             return [
                 TextContent(