chuk-tool-processor 0.6.12__py3-none-any.whl → 0.6.13__py3-none-any.whl

chuk_tool_processor/mcp/mcp_tool.py

@@ -14,13 +14,14 @@ HEALTH MONITORING FIX: Updated health checking to be more lenient and trust
 the underlying transport's health monitoring instead of doing aggressive
 ping tests that create false negatives.
 """
+
 from __future__ import annotations
 
 import asyncio
 import time
-from enum import Enum
-from typing import Any, Dict, List, Optional
 from dataclasses import dataclass
+from enum import Enum
+from typing import Any
 
 from chuk_tool_processor.logging import get_logger
 from chuk_tool_processor.mcp.stream_manager import StreamManager
@@ -30,8 +31,9 @@ logger = get_logger("chuk_tool_processor.mcp.mcp_tool")
 
 class ConnectionState(Enum):
     """Connection states for the MCP tool."""
+
     HEALTHY = "healthy"
-    DEGRADED = "degraded"  
+    DEGRADED = "degraded"
     DISCONNECTED = "disconnected"
     FAILED = "failed"
 
@@ -39,6 +41,7 @@ class ConnectionState(Enum):
 @dataclass
 class RecoveryConfig:
     """Configuration for connection recovery behavior."""
+
     max_retries: int = 3
     initial_backoff: float = 1.0
     max_backoff: float = 30.0
@@ -50,21 +53,22 @@ class RecoveryConfig:
 @dataclass
 class ConnectionStats:
     """Statistics for connection monitoring."""
+
     total_calls: int = 0
     successful_calls: int = 0
     failed_calls: int = 0
     connection_errors: int = 0
-    last_success_time: Optional[float] = None
-    last_failure_time: Optional[float] = None
+    last_success_time: float | None = None
+    last_failure_time: float | None = None
 
 
 class MCPTool:
     """
     Wrap a remote MCP tool so it can be called like a local tool.
-    
+
     SIMPLIFIED: This class now focuses only on execution delegation.
     It does NOT handle configuration files or StreamManager bootstrapping.
-    
+
     FIXED: Health monitoring is now more lenient and trusts the underlying
     transport's health reporting instead of doing aggressive health checks.
     """
@@ -72,84 +76,84 @@ class MCPTool:
     def __init__(
         self,
         tool_name: str = "",
-        stream_manager: Optional[StreamManager] = None,
+        stream_manager: StreamManager | None = None,
         *,
-        default_timeout: Optional[float] = None,
+        default_timeout: float | None = None,
         enable_resilience: bool = True,
-        recovery_config: Optional[RecoveryConfig] = None,
+        recovery_config: RecoveryConfig | None = None,
     ) -> None:
         if not tool_name:
             raise ValueError("MCPTool requires a tool_name")
-        
+
         self.tool_name = tool_name
-        self._sm: Optional[StreamManager] = stream_manager
+        self._sm: StreamManager | None = stream_manager
         self.default_timeout = default_timeout or 30.0
 
         # Resilience features
         self.enable_resilience = enable_resilience
         self.recovery_config = recovery_config or RecoveryConfig()
-        
+
         # State tracking (only if resilience enabled)
         if self.enable_resilience:
             self.connection_state = ConnectionState.HEALTHY if stream_manager else ConnectionState.DISCONNECTED
             self.stats = ConnectionStats()
-            
+
             # Circuit breaker state
             self._circuit_open = False
-            self._circuit_open_time: Optional[float] = None
+            self._circuit_open_time: float | None = None
             self._consecutive_failures = 0
 
     # ------------------------------------------------------------------ #
     # Serialization support for subprocess execution
     # ------------------------------------------------------------------ #
-    def __getstate__(self) -> Dict[str, Any]:
+    def __getstate__(self) -> dict[str, Any]:
         """
         Serialize for subprocess execution.
-        
+
         SIMPLIFIED: Only preserve essential execution state, not configuration.
         The StreamManager will be None after deserialization - that's expected.
         """
         state = self.__dict__.copy()
-        
+
         # Remove non-serializable items
-        state['_sm'] = None  # StreamManager will be None in subprocess
-        
+        state["_sm"] = None  # StreamManager will be None in subprocess
+
         # Reset connection state for subprocess
         if self.enable_resilience:
-            state['connection_state'] = ConnectionState.DISCONNECTED
-        
+            state["connection_state"] = ConnectionState.DISCONNECTED
+
         logger.debug(f"Serializing MCPTool '{self.tool_name}' for subprocess")
         return state
-    
-    def __setstate__(self, state: Dict[str, Any]) -> None:
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
         """
         Deserialize after subprocess execution.
-        
+
         SIMPLIFIED: Just restore state. StreamManager will be None and that's fine.
         """
         self.__dict__.update(state)
-        
+
         # Ensure critical fields exist
-        if not hasattr(self, 'tool_name') or not self.tool_name:
+        if not hasattr(self, "tool_name") or not self.tool_name:
             raise ValueError("Invalid MCPTool state: missing tool_name")
-        
+
         # StreamManager will be None in subprocess - that's expected
         self._sm = None
-        
+
         # Initialize resilience state if enabled
         if self.enable_resilience:
-            if not hasattr(self, 'connection_state'):
+            if not hasattr(self, "connection_state"):
                 self.connection_state = ConnectionState.DISCONNECTED
-            if not hasattr(self, 'stats'):
+            if not hasattr(self, "stats"):
                 self.stats = ConnectionStats()
-        
+
         logger.debug(f"Deserialized MCPTool '{self.tool_name}' in subprocess")
 
     # ------------------------------------------------------------------ #
-    async def execute(self, timeout: Optional[float] = None, **kwargs: Any) -> Any:
+    async def execute(self, timeout: float | None = None, **kwargs: Any) -> Any:
         """
         Execute the tool, returning graceful errors if StreamManager unavailable.
-        
+
         SIMPLIFIED: If no StreamManager, return a structured error response
         instead of trying to bootstrap one.
         """
@@ -159,21 +163,21 @@ class MCPTool:
                 "error": f"Tool '{self.tool_name}' is not available (no stream manager)",
                 "tool_name": self.tool_name,
                 "available": False,
-                "reason": "disconnected"
+                "reason": "disconnected",
             }
 
         # If resilience is disabled, use simple execution
         if not self.enable_resilience:
             return await self._simple_execute(timeout, **kwargs)
-        
+
         # Resilient execution
         return await self._resilient_execute(timeout, **kwargs)
 
-    async def _simple_execute(self, timeout: Optional[float] = None, **kwargs: Any) -> Any:
+    async def _simple_execute(self, timeout: float | None = None, **kwargs: Any) -> Any:
         """Simple execution without resilience features."""
         effective_timeout = timeout if timeout is not None else self.default_timeout
 
-        call_kwargs = {
+        call_kwargs: dict[str, Any] = {
             "tool_name": self.tool_name,
             "arguments": kwargs,
         }
@@ -181,8 +185,8 @@ class MCPTool:
             call_kwargs["timeout"] = effective_timeout
 
         try:
-            result = await self._sm.call_tool(**call_kwargs)
-        except asyncio.TimeoutError:
+            result = await self._sm.call_tool(**call_kwargs)  # type: ignore[union-attr]
+        except TimeoutError:
             logger.warning(f"MCP tool '{self.tool_name}' timed out after {effective_timeout}s")
             raise
 
@@ -193,7 +197,7 @@ class MCPTool:
 
         return result.get("content")
 
-    async def _resilient_execute(self, timeout: Optional[float] = None, **kwargs: Any) -> Any:
+    async def _resilient_execute(self, timeout: float | None = None, **kwargs: Any) -> Any:
         """Resilient execution with circuit breaker and health checks."""
         # Check circuit breaker
         if self._is_circuit_open():
@@ -201,12 +205,12 @@ class MCPTool:
                 "error": f"Circuit breaker open for tool '{self.tool_name}' - too many recent failures",
                 "tool_name": self.tool_name,
                 "available": False,
-                "reason": "circuit_breaker"
+                "reason": "circuit_breaker",
             }
-        
+
         effective_timeout = timeout if timeout is not None else self.default_timeout
         self.stats.total_calls += 1
-        
+
         # FIXED: More lenient health check - trust the transport layer
         if not await self._is_stream_manager_healthy():
             await self._record_failure(is_connection_error=True)
@@ -214,64 +218,59 @@ class MCPTool:
                 "error": f"Tool '{self.tool_name}' is not available (unhealthy connection)",
                 "tool_name": self.tool_name,
                 "available": False,
-                "reason": "unhealthy"
+                "reason": "unhealthy",
             }
-        
+
         # Try execution with retries
         max_attempts = self.recovery_config.max_retries + 1
         backoff = self.recovery_config.initial_backoff
-        
+
         for attempt in range(max_attempts):
             try:
                 result = await self._execute_with_timeout(effective_timeout, **kwargs)
                 await self._record_success()
                 return result
-                
-            except asyncio.TimeoutError:
+
+            except TimeoutError:
                 error_msg = f"Tool '{self.tool_name}' timed out after {effective_timeout}s"
                 logger.warning(error_msg)
                 await self._record_failure()
-                
+
                 if attempt == max_attempts - 1:
-                    return {
-                        "error": error_msg,
-                        "tool_name": self.tool_name,
-                        "available": False,
-                        "reason": "timeout"
-                    }
-                    
+                    return {"error": error_msg, "tool_name": self.tool_name, "available": False, "reason": "timeout"}
+
             except Exception as e:
                 error_str = str(e)
                 is_connection_error = self._is_connection_error(e)
-                
+
                 logger.warning(f"Tool '{self.tool_name}' attempt {attempt + 1} failed: {error_str}")
                 await self._record_failure(is_connection_error)
-                
+
                 if attempt == max_attempts - 1:
                     return {
                         "error": f"Tool execution failed after {max_attempts} attempts: {error_str}",
                         "tool_name": self.tool_name,
                         "available": False,
-                        "reason": "execution_failed"
+                        "reason": "execution_failed",
                     }
-                
+
                 # Exponential backoff
                 if attempt < max_attempts - 1:
                     logger.debug(f"Waiting {backoff:.1f}s before retry {attempt + 2}")
                     await asyncio.sleep(backoff)
                     backoff = min(backoff * self.recovery_config.backoff_multiplier, self.recovery_config.max_backoff)
-        
+
         # Should never reach here
         return {
             "error": f"Tool '{self.tool_name}' failed after all attempts",
             "tool_name": self.tool_name,
             "available": False,
-            "reason": "exhausted_retries"
+            "reason": "exhausted_retries",
         }
 
     async def _execute_with_timeout(self, timeout: float, **kwargs: Any) -> Any:
         """Execute the tool with timeout."""
-        call_kwargs = {
+        call_kwargs: dict[str, Any] = {
             "tool_name": self.tool_name,
             "arguments": kwargs,
         }
@@ -280,17 +279,17 @@ class MCPTool:
 
         try:
             result = await asyncio.wait_for(
-                self._sm.call_tool(**call_kwargs),
-                timeout=(timeout + 5.0) if timeout else None
+                self._sm.call_tool(**call_kwargs),  # type: ignore[union-attr]
+                timeout=(timeout + 5.0) if timeout else None,
             )
-            
+
             if result.get("isError"):
                 error = result.get("error", "Unknown error")
                 raise RuntimeError(f"Tool execution failed: {error}")
-            
+
             return result.get("content")
-            
-        except asyncio.TimeoutError:
+
+        except TimeoutError:
             self.connection_state = ConnectionState.DEGRADED
             raise
         except Exception as e:
@@ -303,31 +302,35 @@ class MCPTool:
     async def _is_stream_manager_healthy(self) -> bool:
         """
         FIXED: Much more lenient health check.
-        
+
         The diagnostic proves SSE transport is healthy, so we should trust it
         instead of doing aggressive health checking that creates false negatives.
-        
+
         This replaces the previous ping_servers() call which was too aggressive
         and caused "unhealthy connection" false positives.
         """
         if self._sm is None:
             return False
-        
+
         # FIXED: Simple check - if we have a StreamManager, assume it's available
         # The underlying SSE transport now has proper health monitoring
         try:
             # Just check if the StreamManager has basic functionality
-            if hasattr(self._sm, 'transports') and self._sm.transports:
-                logger.debug(f"StreamManager healthy for '{self.tool_name}' - has {len(self._sm.transports)} transports")
+            if hasattr(self._sm, "transports") and self._sm.transports:
+                logger.debug(
+                    f"StreamManager healthy for '{self.tool_name}' - has {len(self._sm.transports)} transports"
+                )
                 return True
-            
+
             # Fallback - try very quick operation with short timeout
-            server_info = await asyncio.wait_for(self._sm.get_server_info(), timeout=1.0)
+            server_info: list[dict[str, Any]] = await asyncio.wait_for(  # type: ignore[arg-type]
+                self._sm.get_server_info(), timeout=1.0
+            )
             healthy = len(server_info) > 0
             logger.debug(f"StreamManager health for '{self.tool_name}': {healthy} (via server_info)")
             return healthy
-            
-        except asyncio.TimeoutError:
+
+        except TimeoutError:
             logger.debug(f"StreamManager health check timed out for '{self.tool_name}' - assuming healthy")
             # FIXED: Timeout doesn't mean unavailable, just slow
             return True
@@ -341,10 +344,18 @@ class MCPTool:
         """Determine if an exception indicates a connection problem."""
         error_str = str(exception).lower()
         connection_indicators = [
-            "connection lost", "connection closed", "connection refused",
-            "broken pipe", "timeout", "eof", "pipe closed", "process died",
-            "no route to host", "no server found", "transport not initialized",
-            "stream manager unavailable"
+            "connection lost",
+            "connection closed",
+            "connection refused",
+            "broken pipe",
+            "timeout",
+            "eof",
+            "pipe closed",
+            "process died",
+            "no route to host",
+            "no server found",
+            "transport not initialized",
+            "stream manager unavailable",
         ]
         return any(indicator in error_str for indicator in connection_indicators)
 
@@ -353,7 +364,7 @@ class MCPTool:
         self.stats.successful_calls += 1
         self.stats.last_success_time = time.time()
         self._consecutive_failures = 0
-        
+
         # Close circuit breaker if it was open
         if self._circuit_open:
             self._circuit_open = False
@@ -365,42 +376,45 @@ class MCPTool:
         """Record a failed execution."""
         self.stats.failed_calls += 1
         self.stats.last_failure_time = time.time()
-        
+
         if is_connection_error:
             self.stats.connection_errors += 1
             self.connection_state = ConnectionState.DISCONNECTED
         else:
             self.connection_state = ConnectionState.DEGRADED
-        
+
         self._consecutive_failures += 1
-        
+
         # Check if we should open the circuit breaker
-        if (self._consecutive_failures >= self.recovery_config.circuit_breaker_threshold and 
-            not self._circuit_open):
+        if self._consecutive_failures >= self.recovery_config.circuit_breaker_threshold and not self._circuit_open:
             self._circuit_open = True
             self._circuit_open_time = time.time()
             self.connection_state = ConnectionState.FAILED
-            logger.error(f"Circuit breaker opened for tool '{self.tool_name}' after {self._consecutive_failures} consecutive failures")
+            logger.error(
+                f"Circuit breaker opened for tool '{self.tool_name}' after {self._consecutive_failures} consecutive failures"
+            )
 
     def _is_circuit_open(self) -> bool:
         """Check if the circuit breaker is currently open."""
         if not self._circuit_open:
             return False
-        
+
         # Check if enough time has passed to close the circuit
-        if (self._circuit_open_time and 
-            time.time() - self._circuit_open_time >= self.recovery_config.circuit_breaker_timeout):
+        if (
+            self._circuit_open_time
+            and time.time() - self._circuit_open_time >= self.recovery_config.circuit_breaker_timeout
+        ):
             self._circuit_open = False
             self._circuit_open_time = None
             self.connection_state = ConnectionState.HEALTHY
             logger.info(f"Circuit breaker reset for tool '{self.tool_name}' after timeout")
             return False
-        
+
         return True
 
     # ------------------------------------------------------------------ #
     # Legacy method name support
-    async def _aexecute(self, timeout: Optional[float] = None, **kwargs: Any) -> Any:
+    async def _aexecute(self, timeout: float | None = None, **kwargs: Any) -> Any:
         """Legacy alias for execute() method."""
         return await self.execute(timeout=timeout, **kwargs)
 
@@ -409,23 +423,21 @@ class MCPTool:
     # ------------------------------------------------------------------ #
     def is_available(self) -> bool:
         """Check if this tool is currently available."""
-        return (self._sm is not None and 
-                not self._is_circuit_open() and 
-                self.connection_state in [ConnectionState.HEALTHY, ConnectionState.DEGRADED])
-    
-    def get_stats(self) -> Dict[str, Any]:
+        return (
+            self._sm is not None
+            and not self._is_circuit_open()
+            and self.connection_state in [ConnectionState.HEALTHY, ConnectionState.DEGRADED]
+        )
+
+    def get_stats(self) -> dict[str, Any]:
         """Get connection and execution statistics."""
         if not self.enable_resilience:
-            return {
-                "tool_name": self.tool_name, 
-                "resilience_enabled": False,
-                "available": self._sm is not None
-            }
-        
+            return {"tool_name": self.tool_name, "resilience_enabled": False, "available": self._sm is not None}
+
         success_rate = 0.0
         if self.stats.total_calls > 0:
             success_rate = (self.stats.successful_calls / self.stats.total_calls) * 100
-        
+
         return {
             "tool_name": self.tool_name,
             "resilience_enabled": True,
@@ -445,7 +457,7 @@ class MCPTool:
         """Manually reset the circuit breaker."""
         if not self.enable_resilience:
             return
-            
+
         self._circuit_open = False
         self._circuit_open_time = None
         self._consecutive_failures = 0
@@ -457,10 +469,10 @@ class MCPTool:
         self.enable_resilience = False
         logger.info(f"Resilience features disabled for tool '{self.tool_name}'")
 
-    def set_stream_manager(self, stream_manager: Optional[StreamManager]) -> None:
+    def set_stream_manager(self, stream_manager: StreamManager | None) -> None:
         """
         Set or update the StreamManager for this tool.
-        
+
         This can be used by external systems to reconnect tools after
         StreamManager recovery at a higher level.
         """
@@ -473,5 +485,5 @@ class MCPTool:
                 logger.info(f"Circuit breaker closed for tool '{self.tool_name}' due to new stream manager")
         else:
             self.connection_state = ConnectionState.DISCONNECTED
-        
-        logger.debug(f"StreamManager {'set' if stream_manager else 'cleared'} for tool '{self.tool_name}'")
+
+        logger.debug(f"StreamManager {'set' if stream_manager else 'cleared'} for tool '{self.tool_name}'")

chuk_tool_processor/mcp/register_mcp_tools.py

@@ -8,7 +8,7 @@ CLEAN & SIMPLE: Just the essentials - create MCPTool wrappers for remote tools.
 
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from chuk_tool_processor.logging import get_logger
 from chuk_tool_processor.mcp.mcp_tool import MCPTool, RecoveryConfig
@@ -25,8 +25,8 @@ async def register_mcp_tools(
     # Optional resilience configuration
     default_timeout: float = 30.0,
     enable_resilience: bool = True,
-    recovery_config: Optional[RecoveryConfig] = None,
-) -> List[str]:
+    recovery_config: RecoveryConfig | None = None,
+) -> list[str]:
     """
     Pull the remote tool catalogue and create local MCPTool wrappers.
 
@@ -49,10 +49,10 @@ async def register_mcp_tools(
         The tool names that were registered.
     """
     registry = await ToolRegistryProvider.get_registry()
-    registered: List[str] = []
+    registered: list[str] = []
 
     # Get the remote tool catalogue
-    mcp_tools: List[Dict[str, Any]] = stream_manager.get_all_tools()
+    mcp_tools: list[dict[str, Any]] = stream_manager.get_all_tools()
 
     for tool_def in mcp_tools:
         tool_name = tool_def.get("name")
@@ -61,7 +61,7 @@ async def register_mcp_tools(
             continue
 
         description = tool_def.get("description") or f"MCP tool • {tool_name}"
-        meta: Dict[str, Any] = {
+        meta: dict[str, Any] = {
             "description": description,
             "is_async": True,
             "tags": {"mcp", "remote"},
@@ -101,20 +101,20 @@ async def register_mcp_tools(
 
 async def update_mcp_tools_stream_manager(
     namespace: str,
-    new_stream_manager: Optional[StreamManager],
+    new_stream_manager: StreamManager | None,
 ) -> int:
     """
     Update the StreamManager reference for all MCP tools in a namespace.
-    
+
     Useful for reconnecting tools after StreamManager recovery at the service level.
-    
+
     Parameters
     ----------
     namespace
         The namespace containing MCP tools to update
     new_stream_manager
         The new StreamManager to use, or None to disconnect
-        
+
     Returns
     -------
     int
@@ -122,26 +122,26 @@ async def update_mcp_tools_stream_manager(
     """
     registry = await ToolRegistryProvider.get_registry()
     updated_count = 0
-    
+
     try:
         # List all tools in the namespace
         all_tools = await registry.list_tools()
         namespace_tools = [name for ns, name in all_tools if ns == namespace]
-        
+
         for tool_name in namespace_tools:
             try:
                 tool = await registry.get_tool(tool_name, namespace)
-                if tool and hasattr(tool, 'set_stream_manager'):
+                if tool and hasattr(tool, "set_stream_manager"):
                     tool.set_stream_manager(new_stream_manager)
                     updated_count += 1
                     logger.debug("Updated StreamManager for tool '%s:%s'", namespace, tool_name)
             except Exception as e:
                 logger.warning("Failed to update StreamManager for tool '%s:%s': %s", namespace, tool_name, e)
-        
+
         action = "connected" if new_stream_manager else "disconnected"
         logger.debug("StreamManager %s for %d tools in namespace '%s'", action, updated_count, namespace)
-        
+
     except Exception as e:
         logger.error("Failed to update tools in namespace '%s': %s", namespace, e)
-    
-    return updated_count
+
+    return updated_count