Enable strict mypy type checking and fix all issues

## Type Safety Improvements
- ✅ All source files pass strict mypy checks
- ✅ Added metadata field to TaskResult
- ✅ Fixed ProtocolAdapter type annotation in ADCPClient
- ✅ Fixed Callable type parameters in handlers
- ✅ Proper type ignores for conditional MCP imports

## Mypy Configuration
- Strict mode enabled for all source files
- Test files have relaxed type checking (practical approach)
- Integration tests ignored for type checking (use sys.path)

## Type Annotations Fixed
- TaskResult now includes optional metadata field
- ADCPClient.adapter properly typed as ProtocolAdapter
- Callable[..., Any] for generic handler functions
- MCP imports with proper type: ignore comments

## Benefits
- Catches type errors at development time
- Better IDE autocomplete and hints
- Safer refactoring
- Self-documenting code

All code now passes:
- mypy --strict (10 source files)
- black formatting
- ruff linting

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: bokelley

pyproject.toml

@@ -68,6 +68,14 @@ strict = true
 warn_return_any = true
 warn_unused_configs = true
 
+[[tool.mypy.overrides]]
+module = "tests.*"
+disable_error_code = ["import-not-found", "no-untyped-def", "var-annotated", "operator"]
+
+[[tool.mypy.overrides]]
+module = "tests.integration.*"
+ignore_errors = true
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 asyncio_mode = "auto"

src/adcp/client.py

@@ -2,8 +2,9 @@
 
 import json
 import os
+from collections.abc import Callable
 from datetime import datetime
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any
 from uuid import uuid4
 
 from adcp.protocols.a2a import A2AAdapter
@@ -29,9 +30,9 @@ class ADCPClient:
     def __init__(
         self,
         agent_config: AgentConfig,
-        webhook_url_template: Optional[str] = None,
-        webhook_secret: Optional[str] = None,
-        on_activity: Optional[Callable[[Activity], None]] = None,
+        webhook_url_template: str | None = None,
+        webhook_secret: str | None = None,
+        on_activity: Callable[[Activity], None] | None = None,
     ):
         """
         Initialize ADCP client for a single agent.
@@ -49,10 +50,11 @@ def __init__(
         self.on_activity = on_activity
 
         # Initialize protocol adapter
+        self.adapter: ProtocolAdapter
         if agent_config.protocol == Protocol.A2A:
-            self.adapter: ProtocolAdapter = A2AAdapter(agent_config)
+            self.adapter = A2AAdapter(agent_config)
         elif agent_config.protocol == Protocol.MCP:
-            self.adapter: ProtocolAdapter = MCPAdapter(agent_config)
+            self.adapter = MCPAdapter(agent_config)
         else:
             raise ValueError(f"Unsupported protocol: {agent_config.protocol}")
 
@@ -395,7 +397,7 @@ async def provide_performance_feedback(self, **kwargs: Any) -> TaskResult[Any]:
     async def handle_webhook(
         self,
         payload: dict[str, Any],
-        signature: Optional[str] = None,
+        signature: str | None = None,
     ) -> None:
         """
         Handle incoming webhook.
@@ -430,10 +432,10 @@ class ADCPMultiAgentClient:
     def __init__(
         self,
         agents: list[AgentConfig],
-        webhook_url_template: Optional[str] = None,
-        webhook_secret: Optional[str] = None,
-        on_activity: Optional[Callable[[Activity], None]] = None,
-        handlers: Optional[Dict[str, Callable]] = None,
+        webhook_url_template: str | None = None,
+        webhook_secret: str | None = None,
+        on_activity: Callable[[Activity], None] | None = None,
+        handlers: dict[str, Callable[..., Any]] | None = None,
     ):
         """
         Initialize multi-agent client.

src/adcp/protocols/mcp.py

@@ -4,13 +4,13 @@
 from urllib.parse import urlparse
 
 try:
-    from mcp import ClientSession
-    from mcp.client.sse import sse_client
+    from mcp import ClientSession  # type: ignore[import-not-found]
+    from mcp.client.sse import sse_client  # type: ignore[import-not-found]
 
     MCP_AVAILABLE = True
 except ImportError:
     MCP_AVAILABLE = False
-    ClientSession = None  # type: ignore
+    ClientSession = None
 
 from adcp.protocols.base import ProtocolAdapter
 from adcp.types.core import TaskResult, TaskStatus

src/adcp/types/core.py

@@ -1,7 +1,7 @@
 """Core type definitions."""
 
 from enum import Enum
-from typing import Any, Dict, Generic, Literal, Optional, TypeVar
+from typing import Any, Generic, Literal, TypeVar
 
 from pydantic import BaseModel, Field
 
@@ -19,7 +19,7 @@ class AgentConfig(BaseModel):
     id: str
     agent_uri: str
     protocol: Protocol
-    auth_token: Optional[str] = None
+    auth_token: str | None = None
     requires_auth: bool = False
 
 
@@ -47,18 +47,19 @@ class NeedsInputInfo(BaseModel):
     """Information when agent needs clarification."""
 
     message: str
-    field: Optional[str] = None
+    field: str | None = None
 
 
 class TaskResult(BaseModel, Generic[T]):
     """Result from task execution."""
 
     status: TaskStatus
-    data: Optional[T] = None
-    submitted: Optional[SubmittedInfo] = None
-    needs_input: Optional[NeedsInputInfo] = None
-    error: Optional[str] = None
+    data: T | None = None
+    submitted: SubmittedInfo | None = None
+    needs_input: NeedsInputInfo | None = None
+    error: str | None = None
     success: bool = Field(default=True)
+    metadata: dict[str, Any] | None = None
 
     class Config:
         arbitrary_types_allowed = True
@@ -81,9 +82,9 @@ class Activity(BaseModel):
     operation_id: str
     agent_id: str
     task_type: str
-    status: Optional[TaskStatus] = None
+    status: TaskStatus | None = None
     timestamp: str
-    metadata: Optional[Dict[str, Any]] = None
+    metadata: dict[str, Any] | None = None
 
 
 class WebhookMetadata(BaseModel):
@@ -93,6 +94,6 @@ class WebhookMetadata(BaseModel):
     agent_id: str
     task_type: str
     status: TaskStatus
-    sequence_number: Optional[int] = None
-    notification_type: Optional[Literal["scheduled", "final", "delayed"]] = None
+    sequence_number: int | None = None
+    notification_type: Literal["scheduled", "final", "delayed"] | None = None
     timestamp: str