Add typed Tool/ToolError classes per Pankit's feedback

- Add Tool dataclass with name, description, input_schema, output_schema
- Add ToolError and ToolErrorType for structured error handling
- Update ListToolsObservation to use List[Tool] instead of dicts
- Add MCP deps (mcp, fastmcp) to src/pyproject.toml
- Add pytest config to root pyproject.toml
- Remove test __init__.py files that shadowed src/core

Author: Darktex

src/core/env_server/__init__.py

@@ -15,6 +15,9 @@
     CallToolObservation,
     ListToolsAction,
     ListToolsObservation,
+    Tool,
+    ToolError,
+    ToolErrorType,
 )
 from .types import Action, Observation, State
 from .web_interface import create_web_interface_app, WebInterfaceManager
@@ -33,6 +36,9 @@
     "Observation",
     "ListToolsObservation",
     "CallToolObservation",
+    "Tool",
+    "ToolError",
+    "ToolErrorType",
     "State",
     # Base transforms
     "CompositeTransform",

src/core/env_server/mcp_environment.py

@@ -126,7 +126,13 @@ async def _handle_mcp_action(self, action: Action) -> Observation:
         Raises:
             ValueError: If MCP client not configured or action type invalid
         """
-        from .mcp_types import CallToolObservation, ListToolsObservation
+        from .mcp_types import (
+            CallToolObservation,
+            ListToolsObservation,
+            Tool,
+            ToolError,
+            ToolErrorType,
+        )
 
         if self.mcp_client is None:
             raise ValueError("MCP client not configured for this environment")
@@ -137,11 +143,11 @@ async def _handle_mcp_action(self, action: Action) -> Observation:
                 return ListToolsObservation(
                     done=False,
                     tools=[
-                        {
-                            "name": tool.name,
-                            "description": tool.description,
-                            "inputSchema": tool.inputSchema,
-                        }
+                        Tool(
+                            name=tool.name,
+                            description=tool.description or "",
+                            input_schema=tool.inputSchema or {},
+                        )
                         for tool in tools
                     ],
                 )
@@ -151,14 +157,18 @@ async def _handle_mcp_action(self, action: Action) -> Observation:
                     result = await self.mcp_client.call_tool(
                         action.tool_name, action.parameters
                     )
-                    # Extract data from CallToolResult (FastMCP wraps results)
                     result_data = result.data if hasattr(result, "data") else result
                     return CallToolObservation(
                         done=False, result=result_data, tool_name=action.tool_name
                     )
                 except Exception as e:
                     return CallToolObservation(
-                        done=False, error=str(e), tool_name=action.tool_name
+                        done=False,
+                        tool_name=action.tool_name,
+                        error=ToolError(
+                            error_type=ToolErrorType.EXECUTION_ERROR,
+                            message=str(e),
+                        ),
                     )
 
             else:

src/core/env_server/mcp_types.py

@@ -12,11 +12,49 @@
 """
 
 from dataclasses import dataclass, field
+from enum import Enum
 from typing import Any, Dict, List, Optional
 
 from .types import Action, Observation
 
 
+class ToolErrorType(Enum):
+    """Types of errors that can occur during tool execution."""
+
+    INVALID_ARGUMENTS = "invalid_arguments"
+    TOOL_NOT_FOUND = "tool_not_found"
+    EXECUTION_ERROR = "execution_error"
+    TIMEOUT = "timeout"
+
+
+@dataclass
+class ToolError:
+    """
+    Structured error for tool call failures.
+
+    Used for transport/validation errors. Tool execution errors that are
+    part of normal operation should be returned in the result field.
+    """
+
+    error_type: ToolErrorType
+    message: str
+    details: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class Tool:
+    """
+    Strongly typed representation of an MCP tool.
+
+    Follows the MCP specification for tool definitions.
+    """
+
+    name: str
+    description: str
+    input_schema: Dict[str, Any]
+    output_schema: Optional[Dict[str, Any]] = None
+
+
 @dataclass(kw_only=True)
 class ListToolsAction(Action):
     """
@@ -49,17 +87,19 @@ class ListToolsObservation(Observation):
     Contains the list of available tools with their schemas.
     """
 
-    tools: List[Dict[str, Any]] = field(default_factory=list)
+    tools: List[Tool] = field(default_factory=list)
 
 
 @dataclass(kw_only=True)
 class CallToolObservation(Observation):
     """
     Observation returned from CallToolAction.
 
-    Contains the result of calling a tool, or an error if the call failed.
+    Contains the result of calling a tool. The error field is for
+    transport/validation errors only - tool execution errors should
+    be part of the result.
     """
 
-    result: Optional[Any] = None
-    error: Optional[str] = None
-    tool_name: Optional[str] = None
+    tool_name: str
+    result: Any = None
+    error: Optional[ToolError] = None

src/core/pyproject.toml

@@ -25,11 +25,14 @@ dependencies = [
     "rich>=13.0.0",
     "tomli>=2.0.1",
     "tomli-w>=1.0.0",
+    "mcp>=1.0.0",
+    "fastmcp>=0.1.0",
 ]
 
 [project.optional-dependencies]
 dev = [
     "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
     "black>=23.0.0",
     "ruff>=0.1.0",
     "mypy>=1.0.0",

src/pyproject.toml

@@ -58,7 +58,7 @@ async def test_echo_env_mcp_integration():
     assert not obs.done
     assert hasattr(obs, "tools")
     assert len(obs.tools) == 1
-    assert obs.tools[0]["name"] == "echo_message"
+    assert obs.tools[0].name == "echo_message"
 
     # Test CallToolAction
     call_action = CallToolAction(