chuk-tool-processor 0.6.4__py3-none-any.whl → 0.9.7__py3-none-any.whl

chuk_tool_processor/execution/strategies/subprocess_strategy.py

@@ -7,31 +7,33 @@ This strategy executes tools in separate Python processes using a process pool,
 providing isolation and potentially better parallelism on multi-core systems.
 
 Enhanced tool name resolution that properly handles:
-- Simple names: "get_current_time" 
+- Simple names: "get_current_time"
 - Namespaced names: "diagnostic_test.get_current_time"
 - Cross-namespace fallback searching
 
 Properly handles tool serialization and ensures tool_name is preserved.
 """
+
 from __future__ import annotations
 
 import asyncio
 import concurrent.futures
+import contextlib
 import functools
 import inspect
 import os
 import pickle
+import platform
 import signal
-import sys
-import traceback
-from datetime import datetime, timezone
-from typing import Any, AsyncIterator, Dict, List, Optional, Tuple, Set
+from collections.abc import AsyncIterator
+from datetime import UTC, datetime
+from typing import Any
 
+from chuk_tool_processor.logging import get_logger, log_context_span
 from chuk_tool_processor.models.execution_strategy import ExecutionStrategy
 from chuk_tool_processor.models.tool_call import ToolCall
 from chuk_tool_processor.models.tool_result import ToolResult
 from chuk_tool_processor.registry.interface import ToolRegistryInterface
-from chuk_tool_processor.logging import get_logger, log_context_span
 
 logger = get_logger("chuk_tool_processor.execution.subprocess_strategy")
 
@@ -44,7 +46,7 @@ def _init_worker():
     """Initialize worker process with signal handlers."""
     # Ignore keyboard interrupt in workers
     signal.signal(signal.SIGINT, signal.SIG_IGN)
-    
+
 
 def _pool_test_func():
     """Simple function to test if the process pool is working."""
@@ -52,38 +54,34 @@ def _pool_test_func():
 
 
 def _serialized_tool_worker(
-    tool_name: str,
-    namespace: str,
-    arguments: Dict[str, Any],
-    timeout: Optional[float],
-    serialized_tool_data: bytes
-) -> Dict[str, Any]:
+    tool_name: str, namespace: str, arguments: dict[str, Any], timeout: float | None, serialized_tool_data: bytes
+) -> dict[str, Any]:
     """
     Worker function that uses serialized tools and ensures tool_name is available.
-    
+
     This worker deserializes the complete tool and executes it, with multiple
     fallbacks to ensure tool_name is properly set.
-    
+
     Args:
         tool_name: Name of the tool
         namespace: Namespace of the tool
         arguments: Arguments to pass to the tool
         timeout: Optional timeout in seconds
         serialized_tool_data: Pickled tool instance
-        
+
     Returns:
         Serialized result data
     """
     import asyncio
-    import pickle
-    import os
     import inspect
-    from datetime import datetime, timezone
-    
-    start_time = datetime.now(timezone.utc)
+    import os
+    import pickle
+    from datetime import datetime
+
+    start_time = datetime.now(UTC)
     pid = os.getpid()
-    hostname = os.uname().nodename
-    
+    hostname = platform.node()
+
     result_data = {
         "tool": tool_name,
         "namespace": namespace,
@@ -94,17 +92,18 @@ def _serialized_tool_worker(
         "result": None,
         "error": None,
     }
-    
+
     try:
         # Deserialize the complete tool
-        tool = pickle.loads(serialized_tool_data)
-        
+        # This is safe as the data comes from the parent process, not untrusted external sources
+        tool = pickle.loads(serialized_tool_data)  # nosec B301
+
         # Multiple fallbacks to ensure tool_name is available
-        
+
         # Fallback 1: If tool doesn't have tool_name, set it directly
-        if not hasattr(tool, 'tool_name') or not tool.tool_name:
+        if not hasattr(tool, "tool_name") or not tool.tool_name:
             tool.tool_name = tool_name
-            
+
         # Fallback 2: If it's a class instead of instance, instantiate it
         if inspect.isclass(tool):
             try:
@@ -112,46 +111,44 @@ def _serialized_tool_worker(
                 tool.tool_name = tool_name
             except Exception as e:
                 result_data["error"] = f"Failed to instantiate tool class: {str(e)}"
-                result_data["end_time"] = datetime.now(timezone.utc).isoformat()
+                result_data["end_time"] = datetime.now(UTC).isoformat()
                 return result_data
-        
+
         # Fallback 3: Ensure tool_name exists using setattr
-        if not getattr(tool, 'tool_name', None):
-            setattr(tool, 'tool_name', tool_name)
-        
+        if not getattr(tool, "tool_name", None):
+            tool.tool_name = tool_name
+
         # Fallback 4: Verify execute method exists
-        if not hasattr(tool, 'execute'):
-            result_data["error"] = f"Tool missing execute method"
-            result_data["end_time"] = datetime.now(timezone.utc).isoformat()
+        if not hasattr(tool, "execute"):
+            result_data["error"] = "Tool missing execute method"
+            result_data["end_time"] = datetime.now(UTC).isoformat()
             return result_data
-        
+
         # Create event loop for execution
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
-        
+
         try:
             # Execute the tool with timeout
             if timeout is not None and timeout > 0:
-                result_value = loop.run_until_complete(
-                    asyncio.wait_for(tool.execute(**arguments), timeout)
-                )
+                result_value = loop.run_until_complete(asyncio.wait_for(tool.execute(**arguments), timeout))
             else:
                 result_value = loop.run_until_complete(tool.execute(**arguments))
-                
+
             result_data["result"] = result_value
-            
-        except asyncio.TimeoutError:
+
+        except TimeoutError:
             result_data["error"] = f"Tool execution timed out after {timeout}s"
         except Exception as e:
             result_data["error"] = f"Tool execution failed: {str(e)}"
-            
+
         finally:
             loop.close()
-            
+
     except Exception as e:
         result_data["error"] = f"Worker error: {str(e)}"
-        
-    result_data["end_time"] = datetime.now(timezone.utc).isoformat()
+
+    result_data["end_time"] = datetime.now(UTC).isoformat()
     return result_data
 
 
@@ -161,11 +158,11 @@ def _serialized_tool_worker(
 class SubprocessStrategy(ExecutionStrategy):
     """
     Execute tools in separate processes for isolation and parallelism.
-    
+
     This strategy creates a pool of worker processes and distributes tool calls
     among them. Each tool executes in its own process, providing isolation and
     parallelism.
-    
+
     Enhanced tool name resolution and proper tool serialization.
     """
 
@@ -174,12 +171,12 @@ class SubprocessStrategy(ExecutionStrategy):
         registry: ToolRegistryInterface,
         *,
         max_workers: int = 4,
-        default_timeout: Optional[float] = None,
+        default_timeout: float | None = None,
         worker_init_timeout: float = 5.0,
     ) -> None:
         """
         Initialize the subprocess execution strategy.
-        
+
         Args:
             registry: Tool registry for tool lookups
             max_workers: Maximum number of worker processes
@@ -190,26 +187,25 @@ class SubprocessStrategy(ExecutionStrategy):
         self.max_workers = max_workers
         self.default_timeout = default_timeout or 30.0  # Always have a default
         self.worker_init_timeout = worker_init_timeout
-        
+
         # Process pool (initialized lazily)
-        self._process_pool: Optional[concurrent.futures.ProcessPoolExecutor] = None
+        self._process_pool: concurrent.futures.ProcessPoolExecutor | None = None
         self._pool_lock = asyncio.Lock()
-        
+
         # Task tracking for cleanup
-        self._active_tasks: Set[asyncio.Task] = set()
+        self._active_tasks: set[asyncio.Task] = set()
         self._shutdown_event = asyncio.Event()
         self._shutting_down = False
-        
-        logger.debug("SubprocessStrategy initialized with timeout: %ss, max_workers: %d", 
-                    self.default_timeout, max_workers)
-        
+
+        logger.debug(
+            "SubprocessStrategy initialized with timeout: %ss, max_workers: %d", self.default_timeout, max_workers
+        )
+
         # Register shutdown handler if in main thread
         try:
             loop = asyncio.get_running_loop()
             for sig in (signal.SIGTERM, signal.SIGINT):
-                loop.add_signal_handler(
-                    sig, lambda s=sig: asyncio.create_task(self._signal_handler(s))
-                )
+                loop.add_signal_handler(sig, lambda s=sig: asyncio.create_task(self._signal_handler(s)))
         except (RuntimeError, NotImplementedError):
             # Not in the main thread or not on Unix
             pass
@@ -218,24 +214,23 @@ class SubprocessStrategy(ExecutionStrategy):
         """Initialize the process pool if not already initialized."""
         if self._process_pool is not None:
             return
-            
+
         async with self._pool_lock:
             if self._process_pool is not None:
                 return
-                
+
             # Create process pool
             self._process_pool = concurrent.futures.ProcessPoolExecutor(
                 max_workers=self.max_workers,
                 initializer=_init_worker,
             )
-            
+
             # Test the pool with a simple task
             loop = asyncio.get_running_loop()
             try:
                 # Use a module-level function instead of a lambda
                 await asyncio.wait_for(
-                    loop.run_in_executor(self._process_pool, _pool_test_func),
-                    timeout=self.worker_init_timeout
+                    loop.run_in_executor(self._process_pool, _pool_test_func), timeout=self.worker_init_timeout
                 )
                 logger.info("Process pool initialized with %d workers", self.max_workers)
             except Exception as e:
@@ -244,16 +239,16 @@ class SubprocessStrategy(ExecutionStrategy):
                 self._process_pool = None
                 logger.error("Failed to initialize process pool: %s", e)
                 raise RuntimeError(f"Failed to initialize process pool: {e}") from e
-    
+
     # ------------------------------------------------------------------ #
     #  🔌 legacy façade for older wrappers                                #
     # ------------------------------------------------------------------ #
     async def execute(
         self,
-        calls: List[ToolCall],
+        calls: list[ToolCall],
         *,
-        timeout: Optional[float] = None,
-    ) -> List[ToolResult]:
+        timeout: float | None = None,
+    ) -> list[ToolResult]:
         """
         Back-compat shim.
 
@@ -262,25 +257,25 @@ class SubprocessStrategy(ExecutionStrategy):
         The real implementation lives in :meth:`run`, so we just forward.
         """
         return await self.run(calls, timeout)
-    
+
     async def run(
         self,
-        calls: List[ToolCall],
-        timeout: Optional[float] = None,
-    ) -> List[ToolResult]:
+        calls: list[ToolCall],
+        timeout: float | None = None,
+    ) -> list[ToolResult]:
         """
         Execute tool calls in separate processes.
-        
+
         Args:
             calls: List of tool calls to execute
             timeout: Optional timeout for each execution (overrides default)
-            
+
         Returns:
             List of tool results in the same order as calls
         """
         if not calls:
             return []
-            
+
         if self._shutting_down:
             # Return early with error results if shutting down
             return [
@@ -288,50 +283,53 @@ class SubprocessStrategy(ExecutionStrategy):
                     tool=call.tool,
                     result=None,
                     error="System is shutting down",
-                    start_time=datetime.now(timezone.utc),
-                    end_time=datetime.now(timezone.utc),
-                    machine=os.uname().nodename,
+                    start_time=datetime.now(UTC),
+                    end_time=datetime.now(UTC),
+                    machine=platform.node(),
                     pid=os.getpid(),
                 )
                 for call in calls
             ]
-        
+
         # Use default_timeout if no timeout specified
         effective_timeout = timeout if timeout is not None else self.default_timeout
         logger.debug("Executing %d calls in subprocesses with %ss timeout each", len(calls), effective_timeout)
-            
+
         # Create tasks for each call
         tasks = []
         for call in calls:
-            task = asyncio.create_task(self._execute_single_call(
-                call, effective_timeout  # Always pass concrete timeout
-            ))
+            task = asyncio.create_task(
+                self._execute_single_call(
+                    call,
+                    effective_timeout,  # Always pass concrete timeout
+                )
+            )
             self._active_tasks.add(task)
             task.add_done_callback(self._active_tasks.discard)
             tasks.append(task)
-            
+
         # Execute all tasks concurrently
         async with log_context_span("subprocess_execution", {"num_calls": len(calls)}):
             return await asyncio.gather(*tasks)
 
     async def stream_run(
         self,
-        calls: List[ToolCall],
-        timeout: Optional[float] = None,
+        calls: list[ToolCall],
+        timeout: float | None = None,
     ) -> AsyncIterator[ToolResult]:
         """
         Execute tool calls and yield results as they become available.
-        
+
         Args:
             calls: List of tool calls to execute
             timeout: Optional timeout for each execution
-            
+
         Yields:
             Tool results as they complete (not necessarily in order)
         """
         if not calls:
             return
-            
+
         if self._shutting_down:
             # Yield error results if shutting down
             for call in calls:
@@ -339,40 +337,42 @@ class SubprocessStrategy(ExecutionStrategy):
                     tool=call.tool,
                     result=None,
                     error="System is shutting down",
-                    start_time=datetime.now(timezone.utc),
-                    end_time=datetime.now(timezone.utc),
-                    machine=os.uname().nodename,
+                    start_time=datetime.now(UTC),
+                    end_time=datetime.now(UTC),
+                    machine=platform.node(),
                     pid=os.getpid(),
                 )
             return
-        
+
         # Use default_timeout if no timeout specified
         effective_timeout = timeout if timeout is not None else self.default_timeout
-            
+
         # Create a queue for results
         queue = asyncio.Queue()
-        
+
         # Start all executions and have them put results in the queue
         pending = set()
         for call in calls:
-            task = asyncio.create_task(self._execute_to_queue(
-                call, queue, effective_timeout  # Always pass concrete timeout
-            ))
+            task = asyncio.create_task(
+                self._execute_to_queue(
+                    call,
+                    queue,
+                    effective_timeout,  # Always pass concrete timeout
+                )
+            )
             self._active_tasks.add(task)
             task.add_done_callback(self._active_tasks.discard)
             pending.add(task)
-            
+
         # Yield results as they become available
         while pending:
             # Get next result from queue
             result = await queue.get()
             yield result
-            
+
             # Check for completed tasks
-            done, pending = await asyncio.wait(
-                pending, timeout=0, return_when=asyncio.FIRST_COMPLETED
-            )
-            
+            done, pending = await asyncio.wait(pending, timeout=0, return_when=asyncio.FIRST_COMPLETED)
+
             # Handle any exceptions
             for task in done:
                 try:
@@ -397,22 +397,22 @@ class SubprocessStrategy(ExecutionStrategy):
     ) -> ToolResult:
         """
         Execute a single tool call with enhanced tool resolution and serialization.
-        
+
         Args:
             call: Tool call to execute
             timeout: Timeout in seconds (required)
-            
+
         Returns:
             Tool execution result
         """
-        start_time = datetime.now(timezone.utc)
-        
+        start_time = datetime.now(UTC)
+
         logger.debug("Executing %s in subprocess with %ss timeout", call.tool, timeout)
-        
+
         try:
             # Ensure pool is initialized
             await self._ensure_pool()
-            
+
             # Use enhanced tool resolution instead of direct lookup
             tool_impl, resolved_namespace = await self._resolve_tool_info(call.tool, call.namespace)
             if tool_impl is None:
@@ -421,29 +421,24 @@ class SubprocessStrategy(ExecutionStrategy):
                     result=None,
                     error=f"Tool '{call.tool}' not found in any namespace",
                     start_time=start_time,
-                    end_time=datetime.now(timezone.utc),
-                    machine=os.uname().nodename,
+                    end_time=datetime.now(UTC),
+                    machine=platform.node(),
                     pid=os.getpid(),
                 )
-            
+
             logger.debug(f"Resolved subprocess tool '{call.tool}' to namespace '{resolved_namespace}'")
-            
+
             # Ensure tool is properly prepared before serialization
-            if inspect.isclass(tool_impl):
-                tool = tool_impl()
-            else:
-                tool = tool_impl
-                
+            tool = tool_impl() if inspect.isclass(tool_impl) else tool_impl
+
             # Ensure tool_name attribute exists
-            if not hasattr(tool, 'tool_name'):
+            if not hasattr(tool, "tool_name") or not tool.tool_name:
                 tool.tool_name = call.tool
-            elif not tool.tool_name:
-                tool.tool_name = call.tool
-                
+
             # Also set _tool_name class attribute for consistency
-            if not hasattr(tool.__class__, '_tool_name'):
+            if not hasattr(tool.__class__, "_tool_name"):
                 tool.__class__._tool_name = call.tool
-            
+
             # Serialize the properly prepared tool
             try:
                 serialized_tool_data = pickle.dumps(tool)
@@ -455,15 +450,15 @@ class SubprocessStrategy(ExecutionStrategy):
                     result=None,
                     error=f"Tool serialization failed: {str(e)}",
                     start_time=start_time,
-                    end_time=datetime.now(timezone.utc),
-                    machine=os.uname().nodename,
+                    end_time=datetime.now(UTC),
+                    machine=platform.node(),
                     pid=os.getpid(),
                 )
-            
+
             # Execute in subprocess using the FIXED worker
             loop = asyncio.get_running_loop()
             safety_timeout = timeout + 5.0
-            
+
             try:
                 result_data = await asyncio.wait_for(
                     loop.run_in_executor(
@@ -474,29 +469,29 @@ class SubprocessStrategy(ExecutionStrategy):
                             resolved_namespace,  # Use resolved namespace
                             call.arguments,
                             timeout,
-                            serialized_tool_data  # Pass serialized tool data
-                        )
+                            serialized_tool_data,  # Pass serialized tool data
+                        ),
                     ),
-                    timeout=safety_timeout
+                    timeout=safety_timeout,
                 )
-                
+
                 # Parse timestamps
                 if isinstance(result_data["start_time"], str):
                     result_data["start_time"] = datetime.fromisoformat(result_data["start_time"])
-                    
+
                 if isinstance(result_data["end_time"], str):
                     result_data["end_time"] = datetime.fromisoformat(result_data["end_time"])
-                
-                end_time = datetime.now(timezone.utc)
+
+                end_time = datetime.now(UTC)
                 actual_duration = (end_time - start_time).total_seconds()
-                
+
                 if result_data.get("error"):
-                    logger.debug("%s subprocess failed after %.3fs: %s", 
-                               call.tool, actual_duration, result_data["error"])
+                    logger.debug(
+                        "%s subprocess failed after %.3fs: %s", call.tool, actual_duration, result_data["error"]
+                    )
                 else:
-                    logger.debug("%s subprocess completed in %.3fs (limit: %ss)", 
-                               call.tool, actual_duration, timeout)
-                
+                    logger.debug("%s subprocess completed in %.3fs (limit: %ss)", call.tool, actual_duration, timeout)
+
                 # Create ToolResult from worker data
                 return ToolResult(
                     tool=result_data.get("tool", call.tool),
@@ -504,42 +499,46 @@ class SubprocessStrategy(ExecutionStrategy):
                     error=result_data.get("error"),
                     start_time=result_data.get("start_time", start_time),
                     end_time=result_data.get("end_time", end_time),
-                    machine=result_data.get("machine", os.uname().nodename),
+                    machine=result_data.get("machine", platform.node()),
                     pid=result_data.get("pid", os.getpid()),
                 )
-                
-            except asyncio.TimeoutError:
-                end_time = datetime.now(timezone.utc)
+
+            except TimeoutError:
+                end_time = datetime.now(UTC)
                 actual_duration = (end_time - start_time).total_seconds()
-                logger.debug("%s subprocess timed out after %.3fs (safety limit: %ss)", 
-                           call.tool, actual_duration, safety_timeout)
-                
+                logger.debug(
+                    "%s subprocess timed out after %.3fs (safety limit: %ss)",
+                    call.tool,
+                    actual_duration,
+                    safety_timeout,
+                )
+
                 return ToolResult(
                     tool=call.tool,
                     result=None,
                     error=f"Worker process timed out after {safety_timeout}s",
                     start_time=start_time,
                     end_time=end_time,
-                    machine=os.uname().nodename,
+                    machine=platform.node(),
                     pid=os.getpid(),
                 )
-                
+
             except concurrent.futures.process.BrokenProcessPool:
                 logger.error("Process pool broke during execution - recreating")
                 if self._process_pool:
                     self._process_pool.shutdown(wait=False)
                     self._process_pool = None
-                    
+
                 return ToolResult(
                     tool=call.tool,
                     result=None,
                     error="Worker process crashed",
                     start_time=start_time,
-                    end_time=datetime.now(timezone.utc),
-                    machine=os.uname().nodename,
+                    end_time=datetime.now(UTC),
+                    machine=platform.node(),
                     pid=os.getpid(),
                 )
-                
+
         except asyncio.CancelledError:
             logger.debug("%s subprocess was cancelled", call.tool)
             return ToolResult(
@@ -547,54 +546,55 @@ class SubprocessStrategy(ExecutionStrategy):
                 result=None,
                 error="Execution was cancelled",
                 start_time=start_time,
-                end_time=datetime.now(timezone.utc),
-                machine=os.uname().nodename,
+                end_time=datetime.now(UTC),
+                machine=platform.node(),
                 pid=os.getpid(),
             )
-            
+
         except Exception as e:
             logger.exception("Error executing %s in subprocess: %s", call.tool, e)
-            end_time = datetime.now(timezone.utc)
+            end_time = datetime.now(UTC)
             actual_duration = (end_time - start_time).total_seconds()
-            logger.debug("%s subprocess setup failed after %.3fs: %s", 
-                       call.tool, actual_duration, e)
-            
+            logger.debug("%s subprocess setup failed after %.3fs: %s", call.tool, actual_duration, e)
+
             return ToolResult(
                 tool=call.tool,
                 result=None,
                 error=f"Error: {str(e)}",
                 start_time=start_time,
                 end_time=end_time,
-                machine=os.uname().nodename,
+                machine=platform.node(),
                 pid=os.getpid(),
             )
 
-    async def _resolve_tool_info(self, tool_name: str, preferred_namespace: str = "default") -> Tuple[Optional[Any], Optional[str]]:
+    async def _resolve_tool_info(
+        self, tool_name: str, preferred_namespace: str = "default"
+    ) -> tuple[Any | None, str | None]:
         """
         Enhanced tool name resolution with comprehensive fallback logic.
-        
+
         This method handles:
         1. Simple names: "get_current_time" -> search in specified namespace first, then all namespaces
         2. Namespaced names: "diagnostic_test.get_current_time" -> extract namespace and tool name
         3. Fallback searching across all namespaces when not found in default
-        
+
         Args:
             tool_name: Name of the tool to resolve
             preferred_namespace: Preferred namespace to search first
-        
+
         Returns:
             Tuple of (tool_object, resolved_namespace) or (None, None) if not found
         """
         logger.debug(f"Resolving tool: '{tool_name}' (preferred namespace: '{preferred_namespace}')")
-        
+
         # Strategy 1: Handle namespaced tool names (namespace.tool_name format)
-        if '.' in tool_name:
-            parts = tool_name.split('.', 1)  # Split on first dot only
+        if "." in tool_name:
+            parts = tool_name.split(".", 1)  # Split on first dot only
             namespace = parts[0]
             actual_tool_name = parts[1]
-            
+
             logger.debug(f"Namespaced lookup: namespace='{namespace}', tool='{actual_tool_name}'")
-            
+
             tool = await self.registry.get_tool(actual_tool_name, namespace)
             if tool is not None:
                 logger.debug(f"Found tool '{actual_tool_name}' in namespace '{namespace}'")
@@ -602,7 +602,7 @@ class SubprocessStrategy(ExecutionStrategy):
             else:
                 logger.debug(f"Tool '{actual_tool_name}' not found in namespace '{namespace}'")
                 return None, None
-        
+
         # Strategy 2: Simple tool name - try preferred namespace first
         if preferred_namespace:
             logger.debug(f"Simple tool lookup: trying preferred namespace '{preferred_namespace}' for '{tool_name}'")
@@ -610,7 +610,7 @@ class SubprocessStrategy(ExecutionStrategy):
             if tool is not None:
                 logger.debug(f"Found tool '{tool_name}' in preferred namespace '{preferred_namespace}'")
                 return tool, preferred_namespace
-        
+
         # Strategy 3: Try default namespace if different from preferred
         if preferred_namespace != "default":
             logger.debug(f"Simple tool lookup: trying default namespace for '{tool_name}'")
@@ -618,30 +618,30 @@ class SubprocessStrategy(ExecutionStrategy):
             if tool is not None:
                 logger.debug(f"Found tool '{tool_name}' in default namespace")
                 return tool, "default"
-        
+
         # Strategy 4: Search all namespaces as fallback
         logger.debug(f"Tool '{tool_name}' not in preferred/default namespace, searching all namespaces...")
-        
+
         try:
             # Get all available namespaces
             namespaces = await self.registry.list_namespaces()
             logger.debug(f"Available namespaces: {namespaces}")
-            
+
             # Search each namespace
             for namespace in namespaces:
                 if namespace in [preferred_namespace, "default"]:
                     continue  # Already tried these
-                    
+
                 logger.debug(f"Searching namespace '{namespace}' for tool '{tool_name}'")
                 tool = await self.registry.get_tool(tool_name, namespace)
                 if tool is not None:
                     logger.debug(f"Found tool '{tool_name}' in namespace '{namespace}'")
                     return tool, namespace
-            
+
             # Strategy 5: Final fallback - list all tools and do fuzzy matching
             logger.debug(f"Tool '{tool_name}' not found in any namespace, trying fuzzy matching...")
             all_tools = await self.registry.list_tools()
-            
+
             # Look for exact matches in tool name (ignoring namespace)
             for namespace, registered_name in all_tools:
                 if registered_name == tool_name:
@@ -649,13 +649,13 @@ class SubprocessStrategy(ExecutionStrategy):
                     tool = await self.registry.get_tool(registered_name, namespace)
                     if tool is not None:
                         return tool, namespace
-            
+
             # Log all available tools for debugging
             logger.debug(f"Available tools: {all_tools}")
-            
+
         except Exception as e:
             logger.error(f"Error during namespace search: {e}")
-        
+
         logger.warning(f"Tool '{tool_name}' not found in any namespace")
         return None, None
 
@@ -663,26 +663,26 @@ class SubprocessStrategy(ExecutionStrategy):
     def supports_streaming(self) -> bool:
         """Check if this strategy supports streaming execution."""
         return True
-        
+
     async def _signal_handler(self, sig: int) -> None:
         """Handle termination signals."""
         signame = signal.Signals(sig).name
         logger.info("Received %s, shutting down process pool", signame)
         await self.shutdown()
-        
+
     async def shutdown(self) -> None:
         """Enhanced shutdown with graceful task handling and proper null checks."""
         if self._shutting_down:
             return
-            
+
         self._shutting_down = True
         self._shutdown_event.set()
-        
+
         # Handle active tasks gracefully
         active_tasks = list(self._active_tasks)
         if active_tasks:
             logger.debug(f"Completing {len(active_tasks)} active operations")
-            
+
             # Cancel tasks with brief intervals for clean handling
             for task in active_tasks:
                 try:
@@ -691,22 +691,18 @@ class SubprocessStrategy(ExecutionStrategy):
                 except Exception:
                     pass
                 # Small delay to prevent overwhelming the event loop
-                try:
+                with contextlib.suppress(Exception):
                     await asyncio.sleep(0.001)
-                except Exception:
-                    pass
-            
+
             # Allow reasonable time for completion
             try:
-                completion_task = asyncio.create_task(
-                    asyncio.gather(*active_tasks, return_exceptions=True)
-                )
+                completion_task = asyncio.create_task(asyncio.gather(*active_tasks, return_exceptions=True))
                 await asyncio.wait_for(completion_task, timeout=2.0)
-            except asyncio.TimeoutError:
+            except TimeoutError:
                 logger.debug("Active operations completed within timeout constraints")
             except Exception:
                 logger.debug("Active operations completed successfully")
-        
+
         # Handle process pool shutdown with proper null checks
         if self._process_pool is not None:
             logger.debug("Finalizing process pool")
@@ -714,18 +710,18 @@ class SubprocessStrategy(ExecutionStrategy):
                 # Store reference and null check before async operation
                 pool_to_shutdown = self._process_pool
                 self._process_pool = None  # Clear immediately to prevent race conditions
-                
+
                 # Create shutdown task with the stored reference
                 shutdown_task = asyncio.create_task(
                     asyncio.get_event_loop().run_in_executor(
                         None, lambda: pool_to_shutdown.shutdown(wait=False) if pool_to_shutdown else None
                     )
                 )
-                
+
                 try:
                     await asyncio.wait_for(shutdown_task, timeout=1.0)
                     logger.debug("Process pool shutdown completed")
-                except asyncio.TimeoutError:
+                except TimeoutError:
                     logger.debug("Process pool shutdown timed out, forcing cleanup")
                     if not shutdown_task.done():
                         shutdown_task.cancel()
@@ -734,4 +730,4 @@ class SubprocessStrategy(ExecutionStrategy):
             except Exception as e:
                 logger.debug(f"Process pool finalization completed: {e}")
         else:
-            logger.debug("Process pool already cleaned up")
+            logger.debug("Process pool already cleaned up")