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

chuk_tool_processor/mcp/transport/stdio_transport.py

@@ -3,20 +3,26 @@ from __future__ import annotations
 
 import asyncio
 import json
+import logging
+import os
 import time
-import signal
+from typing import Any
+
 import psutil
-from typing import Dict, Any, List, Optional
-import logging
+from chuk_mcp.protocol.messages import (  # type: ignore[import-untyped]
+    send_initialize,
+    send_ping,
+    send_prompts_get,
+    send_prompts_list,
+    send_resources_list,
+    send_resources_read,
+    send_tools_call,
+    send_tools_list,
+)
+from chuk_mcp.transports.stdio import stdio_client  # type: ignore[import-untyped]
+from chuk_mcp.transports.stdio.parameters import StdioParameters  # type: ignore[import-untyped]
 
 from .base_transport import MCPBaseTransport
-from chuk_mcp.transports.stdio import stdio_client
-from chuk_mcp.transports.stdio.parameters import StdioParameters
-from chuk_mcp.protocol.messages import (
-    send_initialize, send_ping, send_tools_list, send_tools_call,
-    send_resources_list, send_resources_read,
-    send_prompts_list, send_prompts_get,
-)
 
 logger = logging.getLogger(__name__)
 
@@ -24,19 +30,22 @@ logger = logging.getLogger(__name__)
 class StdioTransport(MCPBaseTransport):
     """
     STDIO transport for MCP communication using process pipes.
-    
-    ENHANCED: Now matches SSE transport robustness with improved process 
+
+    ENHANCED: Now matches SSE transport robustness with improved process
     management, health monitoring, and comprehensive error handling.
     """
 
-    def __init__(self, server_params, 
-                 connection_timeout: float = 30.0,
-                 default_timeout: float = 30.0,
-                 enable_metrics: bool = True,
-                 process_monitor: bool = True):  # NEW
+    def __init__(
+        self,
+        server_params,
+        connection_timeout: float = 30.0,
+        default_timeout: float = 30.0,
+        enable_metrics: bool = True,
+        process_monitor: bool = True,
+    ):  # NEW
         """
         Initialize STDIO transport with enhanced configuration.
-        
+
         Args:
             server_params: Server parameters (dict or StdioParameters object)
             connection_timeout: Timeout for initial connection setup
@@ -46,31 +55,46 @@ class StdioTransport(MCPBaseTransport):
         """
         # Convert dict to StdioParameters if needed
         if isinstance(server_params, dict):
+            # Merge provided env with system environment to ensure PATH is available
+            merged_env = os.environ.copy()
+            if server_params.get("env"):
+                merged_env.update(server_params["env"])
+
             self.server_params = StdioParameters(
-                command=server_params.get('command', 'python'),
-                args=server_params.get('args', []),
-                env=server_params.get('env')
+                command=server_params.get("command", "python"),
+                args=server_params.get("args", []),
+                env=merged_env,
             )
         else:
-            self.server_params = server_params
-        
+            # Also handle StdioParameters object - merge env if provided
+            # Create a new StdioParameters with merged env (Pydantic models are immutable)
+            merged_env = os.environ.copy()
+            if hasattr(server_params, "env") and server_params.env:
+                merged_env.update(server_params.env)
+
+            self.server_params = StdioParameters(
+                command=server_params.command,
+                args=server_params.args,
+                env=merged_env,
+            )
+
         self.connection_timeout = connection_timeout
         self.default_timeout = default_timeout
         self.enable_metrics = enable_metrics
         self.process_monitor = process_monitor  # NEW
-        
+
         # Connection state
         self._context = None
         self._streams = None
         self._initialized = False
-        
+
         # Process monitoring (NEW - like SSE's health monitoring)
         self._process_id = None
         self._process_start_time = None
         self._last_successful_ping = None
         self._consecutive_failures = 0
         self._max_consecutive_failures = 3
-        
+
         # Enhanced performance metrics (like SSE)
         self._metrics = {
             "total_calls": 0,
@@ -87,20 +111,19 @@ class StdioTransport(MCPBaseTransport):
             "memory_usage_mb": 0.0,  # NEW
             "cpu_percent": 0.0,  # NEW
         }
-        
-        logger.debug("STDIO transport initialized for command: %s", 
-                    getattr(self.server_params, 'command', 'unknown'))
 
-    async def _get_process_info(self) -> Optional[Dict[str, Any]]:
+        logger.debug("STDIO transport initialized for command: %s", getattr(self.server_params, "command", "unknown"))
+
+    async def _get_process_info(self) -> dict[str, Any] | None:
         """Get process information for monitoring (NEW)."""
         if not self._process_id or not self.process_monitor:
             return None
-        
+
         try:
             # FIXED: Validate PID is a real integer before using psutil
             if not isinstance(self._process_id, int) or self._process_id <= 0:
                 return None
-                
+
             process = psutil.Process(self._process_id)
             if process.is_running():
                 memory_info = process.memory_info()
@@ -110,7 +133,7 @@ class StdioTransport(MCPBaseTransport):
                     "memory_mb": memory_info.rss / 1024 / 1024,
                     "cpu_percent": process.cpu_percent(),
                     "create_time": process.create_time(),
-                    "uptime": time.time() - self._process_start_time if self._process_start_time else 0
+                    "uptime": time.time() - self._process_start_time if self._process_start_time else 0,
                 }
         except (psutil.NoSuchProcess, psutil.AccessDenied, AttributeError, TypeError, ValueError):
             # FIXED: Handle all possible errors including TypeError from mock objects
@@ -121,32 +144,32 @@ class StdioTransport(MCPBaseTransport):
         """Monitor subprocess health (NEW - like SSE's health monitoring)."""
         if not self.process_monitor:
             return True
-        
+
         # FIXED: Check if process_id is valid before monitoring
         if not self._process_id or not isinstance(self._process_id, int) or self._process_id <= 0:
             return True  # No monitoring if no valid PID
-        
+
         process_info = await self._get_process_info()
         if not process_info:
             logger.debug("Process monitoring unavailable (may be in test environment)")
             return True  # Don't fail in test environments
-        
+
         # Update metrics with process info
         if self.enable_metrics:
             self._metrics["memory_usage_mb"] = process_info["memory_mb"]
             self._metrics["cpu_percent"] = process_info["cpu_percent"]
-        
+
         # Check for concerning process states
         status = process_info.get("status", "unknown")
         if status in ["zombie", "dead"]:
             logger.error("Process is in %s state", status)
             return False
-        
+
         # Check for excessive memory usage (warn at 1GB)
         memory_mb = process_info.get("memory_mb", 0)
         if memory_mb > 1024:
             logger.warning("Process using excessive memory: %.1f MB", memory_mb)
-        
+
         return True
 
     async def initialize(self) -> bool:
@@ -154,53 +177,47 @@ class StdioTransport(MCPBaseTransport):
         if self._initialized:
             logger.warning("Transport already initialized")
             return True
-        
+
         start_time = time.time()
-        
+
         try:
             logger.debug("Initializing STDIO transport...")
-            
+
             # Create context with timeout protection
             self._context = stdio_client(self.server_params)
-            self._streams = await asyncio.wait_for(
-                self._context.__aenter__(),
-                timeout=self.connection_timeout
-            )
-            
+            self._streams = await asyncio.wait_for(self._context.__aenter__(), timeout=self.connection_timeout)
+
             # Capture process information for monitoring (NEW)
-            if self.process_monitor and hasattr(self._context, '_process'):
-                self._process_id = getattr(self._context._process, 'pid', None)
+            if self.process_monitor and hasattr(self._context, "_process"):
+                self._process_id = getattr(self._context._process, "pid", None)
                 self._process_start_time = time.time()
                 logger.debug("Subprocess PID: %s", self._process_id)
-            
+
             # Send initialize message with timeout
-            init_result = await asyncio.wait_for(
-                send_initialize(*self._streams),
-                timeout=self.default_timeout
-            )
-            
+            init_result = await asyncio.wait_for(send_initialize(*self._streams), timeout=self.default_timeout)
+
             if init_result:
                 # Enhanced health verification (like SSE)
                 logger.debug("Verifying connection with ping...")
                 ping_start = time.time()
-                ping_success = await asyncio.wait_for(
-                    send_ping(*self._streams),
-                    timeout=10.0
-                )
+                ping_success = await asyncio.wait_for(send_ping(*self._streams), timeout=10.0)
                 ping_time = time.time() - ping_start
-                
+
                 if ping_success:
                     self._initialized = True
                     self._last_successful_ping = time.time()
                     self._consecutive_failures = 0
-                    
+
                     if self.enable_metrics:
                         init_time = time.time() - start_time
                         self._metrics["initialization_time"] = init_time
                         self._metrics["last_ping_time"] = ping_time
-                    
-                    logger.debug("STDIO transport initialized successfully in %.3fs (ping: %.3fs)", 
-                               time.time() - start_time, ping_time)
+
+                    logger.debug(
+                        "STDIO transport initialized successfully in %.3fs (ping: %.3fs)",
+                        time.time() - start_time,
+                        ping_time,
+                    )
                     return True
                 else:
                     logger.warning("STDIO connection established but ping failed")
@@ -214,8 +231,8 @@ class StdioTransport(MCPBaseTransport):
                 logger.error("STDIO initialization failed")
                 await self._cleanup()
                 return False
-                
-        except asyncio.TimeoutError:
+
+        except TimeoutError:
             logger.error("STDIO initialization timed out after %ss", self.connection_timeout)
             await self._cleanup()
             if self.enable_metrics:
@@ -233,16 +250,16 @@ class StdioTransport(MCPBaseTransport):
         if self.enable_metrics:
             self._metrics["recovery_attempts"] += 1
             self._metrics["process_restarts"] += 1
-        
+
         logger.warning("Attempting STDIO process recovery...")
-        
+
         try:
             # Force cleanup of existing process
             await self._cleanup()
-            
+
             # Brief delay before restart
             await asyncio.sleep(1.0)
-            
+
             # Re-initialize
             return await self.initialize()
         except Exception as e:
@@ -253,10 +270,10 @@ class StdioTransport(MCPBaseTransport):
         """Enhanced close with process monitoring and metrics."""
         if not self._initialized:
             return
-        
+
         # Enhanced metrics logging (like SSE)
         if self.enable_metrics and self._metrics["total_calls"] > 0:
-            success_rate = (self._metrics["successful_calls"] / self._metrics["total_calls"] * 100)
+            success_rate = self._metrics["successful_calls"] / self._metrics["total_calls"] * 100
             logger.debug(
                 "STDIO transport closing - Calls: %d, Success: %.1f%%, "
                 "Avg time: %.3fs, Restarts: %d, Crashes: %d, Memory: %.1f MB",
@@ -265,9 +282,9 @@ class StdioTransport(MCPBaseTransport):
                 self._metrics["avg_response_time"],
                 self._metrics["process_restarts"],
                 self._metrics["process_crashes"],
-                self._metrics["memory_usage_mb"]
+                self._metrics["memory_usage_mb"],
             )
-        
+
         if self._context:
             try:
                 await self._context.__aexit__(None, None, None)
@@ -288,7 +305,7 @@ class StdioTransport(MCPBaseTransport):
                     if process.is_running():
                         logger.debug("Terminating subprocess %s", self._process_id)
                         process.terminate()
-                        
+
                         # Wait briefly for graceful termination
                         try:
                             process.wait(timeout=2.0)
@@ -298,7 +315,7 @@ class StdioTransport(MCPBaseTransport):
             except (psutil.NoSuchProcess, psutil.AccessDenied, TypeError, ValueError):
                 # FIXED: Handle all possible errors including TypeError from mock objects
                 logger.debug("Could not terminate process %s (may be mock or already dead)", self._process_id)
-        
+
         self._context = None
         self._streams = None
         self._initialized = False
@@ -309,35 +326,36 @@ class StdioTransport(MCPBaseTransport):
         """Enhanced ping with process health monitoring."""
         if not self._initialized:
             return False
-        
+
         # Check process health first (NEW) - but only if we have a real process
-        if self.process_monitor and self._process_id and isinstance(self._process_id, int):
-            if not await self._monitor_process_health():
-                self._consecutive_failures += 1
-                return False
-        
+        if (
+            self.process_monitor
+            and self._process_id
+            and isinstance(self._process_id, int)
+            and not await self._monitor_process_health()
+        ):
+            self._consecutive_failures += 1
+            return False
+
         start_time = time.time()
         try:
-            result = await asyncio.wait_for(
-                send_ping(*self._streams),
-                timeout=self.default_timeout
-            )
-            
+            result = await asyncio.wait_for(send_ping(*self._streams), timeout=self.default_timeout)
+
             success = bool(result)
-            
+
             if success:
                 self._last_successful_ping = time.time()
                 self._consecutive_failures = 0
             else:
                 self._consecutive_failures += 1
-            
+
             if self.enable_metrics:
                 ping_time = time.time() - start_time
                 self._metrics["last_ping_time"] = ping_time
                 logger.debug("STDIO ping completed in %.3fs: %s", ping_time, success)
-            
+
             return success
-        except asyncio.TimeoutError:
+        except TimeoutError:
             logger.error("STDIO ping timed out")
             self._consecutive_failures += 1
             return False
@@ -352,27 +370,24 @@ class StdioTransport(MCPBaseTransport):
         """Enhanced connection status check (like SSE)."""
         if not self._initialized or not self._streams:
             return False
-        
+
         # Check for too many consecutive failures (like SSE)
         if self._consecutive_failures >= self._max_consecutive_failures:
             logger.warning("Connection marked unhealthy after %d failures", self._consecutive_failures)
             return False
-        
+
         return True
 
-    async def get_tools(self) -> List[Dict[str, Any]]:
+    async def get_tools(self) -> list[dict[str, Any]]:
         """Enhanced tools retrieval with recovery."""
         if not self._initialized:
             logger.error("Cannot get tools: transport not initialized")
             return []
-        
+
         start_time = time.time()
         try:
-            response = await asyncio.wait_for(
-                send_tools_list(*self._streams),
-                timeout=self.default_timeout
-            )
-            
+            response = await asyncio.wait_for(send_tools_list(*self._streams), timeout=self.default_timeout)
+
             # Normalize response
             if isinstance(response, dict):
                 tools = response.get("tools", [])
@@ -381,17 +396,17 @@ class StdioTransport(MCPBaseTransport):
             else:
                 logger.warning("Unexpected tools response type: %s", type(response))
                 tools = []
-            
+
             # Reset failure count on success
             self._consecutive_failures = 0
-            
+
             if self.enable_metrics:
                 response_time = time.time() - start_time
                 logger.debug("Retrieved %d tools in %.3fs", len(tools), response_time)
-            
+
             return tools
-            
-        except asyncio.TimeoutError:
+
+        except TimeoutError:
             logger.error("Get tools timed out")
             self._consecutive_failures += 1
             return []
@@ -402,89 +417,80 @@ class StdioTransport(MCPBaseTransport):
                 self._metrics["pipe_errors"] += 1
             return []
 
-    async def call_tool(self, tool_name: str, arguments: Dict[str, Any], 
-                       timeout: Optional[float] = None) -> Dict[str, Any]:
+    async def call_tool(
+        self, tool_name: str, arguments: dict[str, Any], timeout: float | None = None
+    ) -> dict[str, Any]:
         """Enhanced tool calling with recovery and process monitoring."""
         if not self._initialized:
             return {"isError": True, "error": "Transport not initialized"}
 
         tool_timeout = timeout or self.default_timeout
         start_time = time.time()
-        
+
         if self.enable_metrics:
             self._metrics["total_calls"] += 1
 
         try:
             logger.debug("Calling tool '%s' with timeout %ss", tool_name, tool_timeout)
-            
+
             # Enhanced connection check with recovery attempt
             if not self.is_connected():
                 logger.warning("Connection unhealthy, attempting recovery...")
                 if not await self._attempt_recovery():
                     if self.enable_metrics:
                         self._update_metrics(time.time() - start_time, False)
-                    return {
-                        "isError": True,
-                        "error": "Failed to recover connection"
-                    }
-            
+                    return {"isError": True, "error": "Failed to recover connection"}
+
             response = await asyncio.wait_for(
-                send_tools_call(*self._streams, tool_name, arguments),
-                timeout=tool_timeout
+                send_tools_call(*self._streams, tool_name, arguments), timeout=tool_timeout
             )
-            
+
             response_time = time.time() - start_time
             result = self._normalize_mcp_response(response)
-            
+
             # Reset failure count and update health on success
             self._consecutive_failures = 0
             self._last_successful_ping = time.time()
-            
+
             if self.enable_metrics:
                 self._update_metrics(response_time, not result.get("isError", False))
-            
+
             if not result.get("isError", False):
                 logger.debug("Tool '%s' completed successfully in %.3fs", tool_name, response_time)
             else:
-                logger.warning("Tool '%s' failed in %.3fs: %s", tool_name, response_time, 
-                             result.get('error', 'Unknown error'))
-            
+                logger.warning(
+                    "Tool '%s' failed in %.3fs: %s", tool_name, response_time, result.get("error", "Unknown error")
+                )
+
             return result
-            
-        except asyncio.TimeoutError:
+
+        except TimeoutError:
             response_time = time.time() - start_time
             self._consecutive_failures += 1
             if self.enable_metrics:
                 self._update_metrics(response_time, False)
-            
+
             error_msg = f"Tool execution timed out after {tool_timeout}s"
             logger.error("Tool '%s' %s", tool_name, error_msg)
-            return {
-                "isError": True,
-                "error": error_msg
-            }
+            return {"isError": True, "error": error_msg}
         except Exception as e:
             response_time = time.time() - start_time
             self._consecutive_failures += 1
             if self.enable_metrics:
                 self._update_metrics(response_time, False)
                 self._metrics["pipe_errors"] += 1
-            
+
             # Enhanced process error detection
             error_str = str(e).lower()
-            if any(indicator in error_str for indicator in 
-                   ["broken pipe", "process", "eof", "connection", "died"]):
+            if any(indicator in error_str for indicator in ["broken pipe", "process", "eof", "connection", "died"]):
                 logger.warning("Process error detected: %s", e)
                 self._initialized = False
                 if self.enable_metrics:
                     self._metrics["process_crashes"] += 1
-            
+
             error_msg = f"Tool execution failed: {str(e)}"
             logger.error("Tool '%s' error: %s", tool_name, error_msg)
-            return {
-                "isError": True,
-                "error": error_msg
-            }
+            return {"isError": True, "error": error_msg}
 
     def _update_metrics(self, response_time: float, success: bool) -> None:
         """Enhanced metrics tracking (like SSE)."""
@@ -492,18 +498,16 @@ class StdioTransport(MCPBaseTransport):
             self._metrics["successful_calls"] += 1
         else:
             self._metrics["failed_calls"] += 1
-            
+
         self._metrics["total_time"] += response_time
         if self._metrics["total_calls"] > 0:
-            self._metrics["avg_response_time"] = (
-                self._metrics["total_time"] / self._metrics["total_calls"]
-            )
+            self._metrics["avg_response_time"] = self._metrics["total_time"] / self._metrics["total_calls"]
 
-    def _normalize_mcp_response(self, response: Dict[str, Any]) -> Dict[str, Any]:
+    def _normalize_mcp_response(self, response: dict[str, Any]) -> dict[str, Any]:
         """
         Enhanced response normalization with STDIO-specific handling.
-        
-        STDIO preserves string representations of numeric values for 
+
+        STDIO preserves string representations of numeric values for
         backward compatibility with existing tests.
         """
         # Handle explicit error in response
@@ -511,63 +515,62 @@ class StdioTransport(MCPBaseTransport):
             error_info = response["error"]
             error_msg = error_info.get("message", str(error_info)) if isinstance(error_info, dict) else str(error_info)
             return {"isError": True, "error": error_msg}
-        
+
         # Handle successful response with result
         if "result" in response:
             result = response["result"]
             if isinstance(result, dict) and "content" in result:
                 return {"isError": False, "content": self._extract_stdio_content(result["content"])}
             return {"isError": False, "content": result}
-        
+
         # Handle direct content-based response
         if "content" in response:
             return {"isError": False, "content": self._extract_stdio_content(response["content"])}
-        
+
         return {"isError": False, "content": response}
 
     def _extract_stdio_content(self, content_list: Any) -> Any:
         """
         Enhanced content extraction with STDIO-specific string preservation.
-        
+
         STDIO transport preserves string representations of numeric values
         for backward compatibility with existing tests.
         """
         if not isinstance(content_list, list) or not content_list:
             return content_list
-        
+
         if len(content_list) == 1:
             item = content_list[0]
             if isinstance(item, dict) and item.get("type") == "text":
                 text = item.get("text", "")
-                
+
                 # STDIO-specific: preserve string format for numeric values
                 try:
                     parsed = json.loads(text)
                     # If the parsed result is a simple type and the original was a string,
                     # keep it as a string to maintain compatibility
-                    if isinstance(parsed, (int, float, bool)) and isinstance(text, str):
-                        # Check if this looks like a simple numeric string
-                        if text.strip().isdigit() or (text.strip().replace('.', '', 1).isdigit()):
-                            return text  # Return as string for numeric values
+                    if (
+                        isinstance(parsed, int | float | bool)
+                        and isinstance(text, str)
+                        and (text.strip().isdigit() or text.strip().replace(".", "", 1).isdigit())
+                    ):
+                        return text  # Return as string for numeric values
                     return parsed
                 except json.JSONDecodeError:
                     return text
             return item
-        
+
         return content_list
 
-    async def list_resources(self) -> Dict[str, Any]:
+    async def list_resources(self) -> dict[str, Any]:
         """Enhanced resource listing with error handling."""
         if not self._initialized:
             return {}
         try:
-            response = await asyncio.wait_for(
-                send_resources_list(*self._streams),
-                timeout=self.default_timeout
-            )
+            response = await asyncio.wait_for(send_resources_list(*self._streams), timeout=self.default_timeout)
             self._consecutive_failures = 0  # Reset on success
             return response if isinstance(response, dict) else {}
-        except asyncio.TimeoutError:
+        except TimeoutError:
             logger.error("List resources timed out")
             self._consecutive_failures += 1
             return {}
@@ -576,18 +579,15 @@ class StdioTransport(MCPBaseTransport):
             self._consecutive_failures += 1
             return {}
 
-    async def list_prompts(self) -> Dict[str, Any]:
+    async def list_prompts(self) -> dict[str, Any]:
         """Enhanced prompt listing with error handling."""
         if not self._initialized:
             return {}
         try:
-            response = await asyncio.wait_for(
-                send_prompts_list(*self._streams),
-                timeout=self.default_timeout
-            )
+            response = await asyncio.wait_for(send_prompts_list(*self._streams), timeout=self.default_timeout)
             self._consecutive_failures = 0  # Reset on success
             return response if isinstance(response, dict) else {}
-        except asyncio.TimeoutError:
+        except TimeoutError:
             logger.error("List prompts timed out")
             self._consecutive_failures += 1
             return {}
@@ -596,18 +596,15 @@ class StdioTransport(MCPBaseTransport):
             self._consecutive_failures += 1
             return {}
 
-    async def read_resource(self, uri: str) -> Dict[str, Any]:
+    async def read_resource(self, uri: str) -> dict[str, Any]:
         """Read a specific resource."""
         if not self._initialized:
             return {}
         try:
-            response = await asyncio.wait_for(
-                send_resources_read(*self._streams, uri),
-                timeout=self.default_timeout
-            )
+            response = await asyncio.wait_for(send_resources_read(*self._streams, uri), timeout=self.default_timeout)
             self._consecutive_failures = 0  # Reset on success
             return response if isinstance(response, dict) else {}
-        except asyncio.TimeoutError:
+        except TimeoutError:
             logger.error("Read resource timed out")
             self._consecutive_failures += 1
             return {}
@@ -616,18 +613,17 @@ class StdioTransport(MCPBaseTransport):
             self._consecutive_failures += 1
             return {}
 
-    async def get_prompt(self, name: str, arguments: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    async def get_prompt(self, name: str, arguments: dict[str, Any] | None = None) -> dict[str, Any]:
         """Get a specific prompt."""
         if not self._initialized:
             return {}
         try:
             response = await asyncio.wait_for(
-                send_prompts_get(*self._streams, name, arguments or {}),
-                timeout=self.default_timeout
+                send_prompts_get(*self._streams, name, arguments or {}), timeout=self.default_timeout
             )
             self._consecutive_failures = 0  # Reset on success
             return response if isinstance(response, dict) else {}
-        except asyncio.TimeoutError:
+        except TimeoutError:
             logger.error("Get prompt timed out")
             self._consecutive_failures += 1
             return {}
@@ -636,17 +632,19 @@ class StdioTransport(MCPBaseTransport):
             self._consecutive_failures += 1
             return {}
 
-    def get_metrics(self) -> Dict[str, Any]:
+    def get_metrics(self) -> dict[str, Any]:
         """Enhanced metrics with process and health information."""
         metrics = self._metrics.copy()
-        metrics.update({
-            "is_connected": self.is_connected(),
-            "consecutive_failures": self._consecutive_failures,
-            "last_successful_ping": self._last_successful_ping,
-            "max_consecutive_failures": self._max_consecutive_failures,
-            "process_id": self._process_id,
-            "process_uptime": (time.time() - self._process_start_time) if self._process_start_time else 0,
-        })
+        metrics.update(
+            {
+                "is_connected": self.is_connected(),
+                "consecutive_failures": self._consecutive_failures,
+                "last_successful_ping": self._last_successful_ping,
+                "max_consecutive_failures": self._max_consecutive_failures,
+                "process_id": self._process_id,
+                "process_uptime": (time.time() - self._process_start_time) if self._process_start_time else 0,
+            }
+        )
         return metrics
 
     def reset_metrics(self) -> None:
@@ -654,7 +652,7 @@ class StdioTransport(MCPBaseTransport):
         preserved_init_time = self._metrics.get("initialization_time")
         preserved_last_ping = self._metrics.get("last_ping_time")
         preserved_restarts = self._metrics.get("process_restarts", 0)
-        
+
         self._metrics = {
             "total_calls": 0,
             "successful_calls": 0,
@@ -671,7 +669,7 @@ class StdioTransport(MCPBaseTransport):
             "cpu_percent": 0.0,
         }
 
-    def get_streams(self) -> List[tuple]:
+    def get_streams(self) -> list[tuple]:
         """Enhanced streams access with connection check."""
         return [self._streams] if self._streams else []
 
@@ -684,4 +682,4 @@ class StdioTransport(MCPBaseTransport):
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """Enhanced context manager cleanup."""
-        await self.close()
+        await self.close()