chuk-tool-processor 0.3__py3-none-any.whl → 0.4.1__py3-none-any.whl

chuk_tool_processor/mcp/mcp_tool.py

@@ -36,11 +36,11 @@ class MCPTool:
         servers: Optional[List[str]] = None,
         server_names: Optional[Dict[int, str]] = None,
         namespace: str = "stdio",
-        default_timeout: Optional[float] = None,  # Add default timeout support
+        default_timeout: Optional[float] = None
     ) -> None:
         self.tool_name = tool_name
         self._sm: Optional[StreamManager] = stream_manager
-        self.default_timeout = default_timeout or 30.0  # Default to 30s if not specified
+        self.default_timeout = default_timeout
 
         # Boot-strap parameters (only needed if _sm is None)
         self._cfg_file = cfg_file
@@ -79,55 +79,67 @@ class MCPTool:
 
         return self._sm  # type: ignore[return-value]
 
-    # ------------------------------------------------------------------ #
     async def execute(self, timeout: Optional[float] = None, **kwargs: Any) -> Any:
         """
-        Forward the call to the remote MCP tool with timeout support.
+        Invoke the remote MCP tool, guaranteeing that *one* timeout is enforced.
 
-        Args:
-            timeout: Optional timeout for this specific call. If not provided,
-                    uses the instance's default_timeout.
-            **kwargs: Arguments to pass to the MCP tool.
+        Parameters
+        ----------
+        timeout : float | None
+            If provided, forward this to StreamManager.  Otherwise fall back
+            to ``self.default_timeout``.
+        **kwargs
+            Arguments forwarded to the tool.
 
-        Returns:
-            The result from the MCP tool call.
+        Returns
+        -------
+        Any
+            The ``content`` of the remote tool response.
 
         Raises
         ------
         RuntimeError
-            If the server returns an error payload.
+            The remote tool returned an error payload.
         asyncio.TimeoutError
-            If the call times out.
+            The call exceeded the chosen timeout.
         """
         sm = await self._ensure_stream_manager()
-        
-        # Use provided timeout, fall back to instance default, then global default
-        effective_timeout = timeout if timeout is not None else self.default_timeout
-        
-        logger.debug("Calling MCP tool '%s' with timeout: %ss", self.tool_name, effective_timeout)
-        
-        try:
-            # Pass timeout directly to StreamManager instead of wrapping with wait_for
-            result = await sm.call_tool(
-                tool_name=self.tool_name, 
-                arguments=kwargs,
-                timeout=effective_timeout
+
+        # Pick the timeout we will enforce (may be None = no limit).
+        effective_timeout: Optional[float] = (
+            timeout if timeout is not None else self.default_timeout
+        )
+
+        call_kwargs: dict[str, Any] = {
+            "tool_name": self.tool_name,
+            "arguments": kwargs,
+        }
+        if effective_timeout is not None:
+            call_kwargs["timeout"] = effective_timeout
+            logger.debug(
+                "Forwarding timeout=%ss to StreamManager for tool '%s'",
+                effective_timeout,
+                self.tool_name,
             )
-            
-            if result.get("isError"):
-                err = result.get("error", "Unknown error")
-                logger.error("Remote MCP error from '%s': %s", self.tool_name, err)
-                raise RuntimeError(err)
-
-            return result.get("content")
-            
+
+        try:
+            result = await sm.call_tool(**call_kwargs)
         except asyncio.TimeoutError:
-            logger.warning("MCP tool '%s' timed out after %ss", self.tool_name, effective_timeout)
-            raise
-        except Exception as e:
-            logger.error("Error calling MCP tool '%s': %s", self.tool_name, e)
+            logger.warning(
+                "MCP tool '%s' timed out after %ss",
+                self.tool_name,
+                effective_timeout,
+            )
             raise
 
+        if result.get("isError"):
+            err = result.get("error", "Unknown error")
+            logger.error("Remote MCP error from '%s': %s", self.tool_name, err)
+            raise RuntimeError(err)
+
+        return result.get("content")
+
+
     # ------------------------------------------------------------------ #
     # Legacy method name support
     async def _aexecute(self, timeout: Optional[float] = None, **kwargs: Any) -> Any:

chuk_tool_processor/mcp/register_mcp_tools.py

@@ -4,7 +4,7 @@
 Discover the remote MCP tools exposed by a :class:`~chuk_tool_processor.mcp.stream_manager.StreamManager`
 instance and register them in the local CHUK registry.
 
-The helper is now **async-native** – call it with ``await``.
+The helper is now **async-native** - call it with ``await``.
 """
 
 from __future__ import annotations
@@ -55,7 +55,7 @@ async def register_mcp_tools(
     for tool_def in mcp_tools:
         tool_name = tool_def.get("name")
         if not tool_name:
-            logger.warning("Remote tool definition without a 'name' field – skipped")
+            logger.warning("Remote tool definition without a 'name' field - skipped")
             continue
 
         description = tool_def.get("description") or f"MCP tool • {tool_name}"
@@ -96,5 +96,5 @@ async def register_mcp_tools(
         except Exception as exc:  # noqa: BLE001
             logger.error("Failed to register MCP tool '%s': %s", tool_name, exc)
 
-    logger.info("MCP registration complete – %d tool(s) available", len(registered))
+    logger.info("MCP registration complete - %d tool(s) available", len(registered))
     return registered

chuk_tool_processor/mcp/setup_mcp_sse.py

@@ -8,7 +8,7 @@ Utility that wires up:
 2. The remote MCP tools exposed by that manager (via
    :pyfunc:`~chuk_tool_processor.mcp.register_mcp_tools.register_mcp_tools`).
 3. A fully-featured :class:`~chuk_tool_processor.core.processor.ToolProcessor`
-   instance that can execute those tools – with optional caching,
+   instance that can execute those tools - with optional caching,
    rate-limiting, retries, etc.
 """
 
@@ -28,7 +28,7 @@ logger = get_logger("chuk_tool_processor.mcp.setup_sse")
 # --------------------------------------------------------------------------- #
 # public helper
 # --------------------------------------------------------------------------- #
-async def setup_mcp_sse(  # noqa: C901 – long, but just a config wrapper
+async def setup_mcp_sse(  # noqa: C901 - long, but just a config wrapper
     *,
     servers: List[Dict[str, str]],
     server_names: Optional[Dict[int, str]] = None,
@@ -47,7 +47,7 @@ async def setup_mcp_sse(  # noqa: C901 – long, but just a config wrapper
     Spin up an SSE-backed *StreamManager*, register all its remote tools,
     and return a ready-to-go :class:`ToolProcessor`.
 
-    Everything is **async-native** – call with ``await``.
+    Everything is **async-native** - call with ``await``.
     
     NEW: Automatically detects and adds bearer token from MCP_BEARER_TOKEN
     environment variable if not explicitly provided in server config.
@@ -91,7 +91,7 @@ async def setup_mcp_sse(  # noqa: C901 – long, but just a config wrapper
     )
 
     logger.info(
-        "MCP (SSE) initialised – %s tool%s registered into namespace '%s'",
+        "MCP (SSE) initialised - %s tool%s registered into namespace '%s'",
         len(registered),
         "" if len(registered) == 1 else "s",
         namespace,

chuk_tool_processor/mcp/setup_mcp_stdio.py

@@ -26,7 +26,7 @@ logger = get_logger("chuk_tool_processor.mcp.setup_stdio")
 # --------------------------------------------------------------------------- #
 # public helper
 # --------------------------------------------------------------------------- #
-async def setup_mcp_stdio(  # noqa: C901 – long but just a config facade
+async def setup_mcp_stdio(  # noqa: C901 - long but just a config facade
     *,
     config_file: str,
     servers: List[str],
@@ -72,7 +72,7 @@ async def setup_mcp_stdio(  # noqa: C901 – long but just a config facade
     )
 
     logger.info(
-        "MCP (stdio) initialised – %s tool%s registered into namespace '%s'",
+        "MCP (stdio) initialised - %s tool%s registered into namespace '%s'",
         len(registered),
         "" if len(registered) == 1 else "s",
         namespace,

chuk_tool_processor/mcp/stream_manager.py

@@ -47,9 +47,16 @@ class StreamManager:
         servers: List[str],
         server_names: Optional[Dict[int, str]] = None,
         transport_type: str = "stdio",
+        default_timeout: float = 30.0,  # ADD: For consistency
     ) -> "StreamManager":
         inst = cls()
-        await inst.initialize(config_file, servers, server_names, transport_type)
+        await inst.initialize(
+            config_file, 
+            servers, 
+            server_names, 
+            transport_type,
+            default_timeout=default_timeout  # PASS THROUGH
+        )
         return inst
 
     @classmethod
@@ -57,13 +64,20 @@ class StreamManager:
         cls,
         servers: List[Dict[str, str]],
         server_names: Optional[Dict[int, str]] = None,
+        connection_timeout: float = 10.0,  # ADD: For SSE connection setup
+        default_timeout: float = 30.0,     # ADD: For tool execution
     ) -> "StreamManager":
         inst = cls()
-        await inst.initialize_with_sse(servers, server_names)
+        await inst.initialize_with_sse(
+            servers, 
+            server_names,
+            connection_timeout=connection_timeout,  # PASS THROUGH
+            default_timeout=default_timeout         # PASS THROUGH
+        )
         return inst
 
     # ------------------------------------------------------------------ #
-    #  initialisation – stdio / sse                                      #
+    #  initialisation - stdio / sse                                      #
     # ------------------------------------------------------------------ #
     async def initialize(
         self,
@@ -71,6 +85,7 @@ class StreamManager:
         servers: List[str],
         server_names: Optional[Dict[int, str]] = None,
         transport_type: str = "stdio",
+        default_timeout: float = 30.0,  # ADD: For consistency
     ) -> None:
         async with self._lock:
             self.server_names = server_names or {}
@@ -81,7 +96,24 @@ class StreamManager:
                         params = await load_config(config_file, server_name)
                         transport: MCPBaseTransport = StdioTransport(params)
                     elif transport_type == "sse":
-                        transport = SSETransport("http://localhost:8000")
+                        # WARNING: For SSE transport, prefer using create_with_sse() instead
+                        # This is a fallback for backward compatibility
+                        logger.warning("Using SSE transport in initialize() - consider using initialize_with_sse() instead")
+                        
+                        # Try to extract URL from params or use localhost as fallback
+                        if isinstance(params, dict) and 'url' in params:
+                            sse_url = params['url']
+                            api_key = params.get('api_key')
+                        else:
+                            sse_url = "http://localhost:8000"
+                            api_key = None
+                            logger.warning(f"No URL configured for SSE transport, using default: {sse_url}")
+                        
+                        transport = SSETransport(
+                            sse_url,
+                            api_key,
+                            default_timeout=default_timeout
+                        )
                     else:
                         logger.error("Unsupported transport type: %s", transport_type)
                         continue
@@ -111,12 +143,12 @@ class StreamManager:
                             "status": status,
                         }
                     )
-                    logger.info("Initialised %s – %d tool(s)", server_name, len(tools))
+                    logger.info("Initialised %s - %d tool(s)", server_name, len(tools))
                 except Exception as exc:  # noqa: BLE001
                     logger.error("Error initialising %s: %s", server_name, exc)
 
             logger.info(
-                "StreamManager ready – %d server(s), %d tool(s)",
+                "StreamManager ready - %d server(s), %d tool(s)",
                 len(self.transports),
                 len(self.all_tools),
             )
@@ -125,6 +157,8 @@ class StreamManager:
         self,
         servers: List[Dict[str, str]],
         server_names: Optional[Dict[int, str]] = None,
+        connection_timeout: float = 10.0,  # ADD: For SSE connection setup
+        default_timeout: float = 30.0,     # ADD: For tool execution
     ) -> None:
         async with self._lock:
             self.server_names = server_names or {}
@@ -135,7 +169,14 @@ class StreamManager:
                     logger.error("Bad server config: %s", cfg)
                     continue
                 try:
-                    transport = SSETransport(url, cfg.get("api_key"))
+                    # FIXED: Pass timeout parameters to SSETransport
+                    transport = SSETransport(
+                        url, 
+                        cfg.get("api_key"),
+                        connection_timeout=connection_timeout,  # ADD THIS
+                        default_timeout=default_timeout         # ADD THIS
+                    )
+                    
                     if not await transport.initialize():
                         logger.error("Failed to init SSE %s", name)
                         continue
@@ -153,12 +194,12 @@ class StreamManager:
                     self.server_info.append(
                         {"id": idx, "name": name, "tools": len(tools), "status": status}
                     )
-                    logger.info("Initialised SSE %s – %d tool(s)", name, len(tools))
+                    logger.info("Initialised SSE %s - %d tool(s)", name, len(tools))
                 except Exception as exc:  # noqa: BLE001
                     logger.error("Error initialising SSE %s: %s", name, exc)
 
             logger.info(
-                "StreamManager ready – %d SSE server(s), %d tool(s)",
+                "StreamManager ready - %d SSE server(s), %d tool(s)",
                 len(self.transports),
                 len(self.all_tools),
             )
@@ -204,7 +245,7 @@ class StreamManager:
             return []
 
     # ------------------------------------------------------------------ #
-    #  EXTRA HELPERS – ping / resources / prompts                        #
+    #  EXTRA HELPERS - ping / resources / prompts                        #
     # ------------------------------------------------------------------ #
     async def ping_servers(self) -> List[Dict[str, Any]]:
         async def _ping_one(name: str, tr: MCPBaseTransport):
@@ -265,7 +306,7 @@ class StreamManager:
         tool_name: str,
         arguments: Dict[str, Any],
         server_name: Optional[str] = None,
-        timeout: Optional[float] = None,  # Add timeout parameter
+        timeout: Optional[float] = None,  # Timeout parameter already exists
     ) -> Dict[str, Any]:
         """
         Call a tool on the appropriate server with timeout support.
@@ -293,10 +334,25 @@ class StreamManager:
         if timeout is not None:
             logger.debug("Calling tool '%s' with %ss timeout", tool_name, timeout)
             try:
-                return await asyncio.wait_for(
-                    transport.call_tool(tool_name, arguments),
-                    timeout=timeout
-                )
+                # ENHANCED: Pass timeout to transport.call_tool if it supports it
+                if hasattr(transport, 'call_tool'):
+                    import inspect
+                    sig = inspect.signature(transport.call_tool)
+                    if 'timeout' in sig.parameters:
+                        # Transport supports timeout parameter - pass it through
+                        return await transport.call_tool(tool_name, arguments, timeout=timeout)
+                    else:
+                        # Transport doesn't support timeout - use asyncio.wait_for wrapper
+                        return await asyncio.wait_for(
+                            transport.call_tool(tool_name, arguments),
+                            timeout=timeout
+                        )
+                else:
+                    # Fallback to asyncio.wait_for
+                    return await asyncio.wait_for(
+                        transport.call_tool(tool_name, arguments),
+                        timeout=timeout
+                    )
             except asyncio.TimeoutError:
                 logger.warning("Tool '%s' timed out after %ss", tool_name, timeout)
                 return {
@@ -350,4 +406,4 @@ class StreamManager:
     # convenience alias
     @property
     def streams(self) -> List[Tuple[Any, Any]]:  # pragma: no cover
-        return self.get_streams()
+        return self.get_streams()

chuk_tool_processor/mcp/transport/base_transport.py

@@ -73,7 +73,7 @@ class MCPBaseTransport(ABC):
     @abstractmethod
     async def list_resources(self) -> Dict[str, Any]:
         """
-        Retrieve the server’s resources catalogue.
+        Retrieve the server's resources catalogue.
 
         Expected shape::
             { "resources": [ {...}, ... ], "nextCursor": "…", … }
@@ -83,7 +83,7 @@ class MCPBaseTransport(ABC):
     @abstractmethod
     async def list_prompts(self) -> Dict[str, Any]:
         """
-        Retrieve the server’s prompt catalogue.
+        Retrieve the server's prompt catalogue.
 
         Expected shape::
             { "prompts": [ {...}, ... ], "nextCursor": "…", … }

chuk_tool_processor/mcp/transport/sse_transport.py

@@ -8,6 +8,8 @@ This transport:
 3. Sends MCP initialize handshake FIRST
 4. Only then proceeds with tools/list and tool calls
 5. Handles async responses via SSE message events
+
+FIXED: All hardcoded timeouts are now configurable parameters.
 """
 from __future__ import annotations
 
@@ -24,7 +26,8 @@ from .base_transport import MCPBaseTransport
 # --------------------------------------------------------------------------- #
 # Helpers                                                                     #
 # --------------------------------------------------------------------------- #
-DEFAULT_TIMEOUT = 30.0  # Longer timeout for real servers
+DEFAULT_TIMEOUT = 30.0  # Default timeout for tool calls
+DEFAULT_CONNECTION_TIMEOUT = 10.0  # Default timeout for connection setup
 HEADERS_JSON: Dict[str, str] = {"accept": "application/json"}
 
 
@@ -47,9 +50,26 @@ class SSETransport(MCPBaseTransport):
     5. Waits for async responses via SSE message events
     """
 
-    def __init__(self, url: str, api_key: Optional[str] = None) -> None:
+    def __init__(
+        self, 
+        url: str, 
+        api_key: Optional[str] = None,
+        connection_timeout: float = DEFAULT_CONNECTION_TIMEOUT,
+        default_timeout: float = DEFAULT_TIMEOUT
+    ) -> None:
+        """
+        Initialize SSE Transport with configurable timeouts.
+        
+        Args:
+            url: Base URL for the MCP server
+            api_key: Optional API key for authentication
+            connection_timeout: Timeout for connection setup (default: 10.0s)
+            default_timeout: Default timeout for tool calls (default: 30.0s)
+        """
         self.base_url = url.rstrip("/")
         self.api_key = api_key
+        self.connection_timeout = connection_timeout
+        self.default_timeout = default_timeout
         
         # NEW: Auto-detect bearer token from environment if not provided
         if not self.api_key:
@@ -92,7 +112,7 @@ class SSETransport(MCPBaseTransport):
 
         self._client = httpx.AsyncClient(
             headers=headers,
-            timeout=DEFAULT_TIMEOUT,
+            timeout=self.default_timeout,  # Use configurable timeout
         )
         self.session = self._client
 
@@ -100,8 +120,8 @@ class SSETransport(MCPBaseTransport):
         self._sse_task = asyncio.create_task(self._handle_sse_connection())
         
         try:
-            # Wait for endpoint event (up to 10 seconds)
-            await asyncio.wait_for(self._connected.wait(), timeout=10.0)
+            # FIXED: Use configurable connection timeout instead of hardcoded 10.0
+            await asyncio.wait_for(self._connected.wait(), timeout=self.connection_timeout)
             
             # NEW: Send MCP initialize handshake
             if await self._initialize_mcp_session():
@@ -285,7 +305,8 @@ class SSETransport(MCPBaseTransport):
         if not self._initialized.is_set():
             print("⏳ Waiting for MCP initialization...")
             try:
-                await asyncio.wait_for(self._initialized.wait(), timeout=10.0)
+                # FIXED: Use configurable connection timeout instead of hardcoded 10.0
+                await asyncio.wait_for(self._initialized.wait(), timeout=self.connection_timeout)
             except asyncio.TimeoutError:
                 print("❌ Timeout waiting for MCP initialization")
                 return []
@@ -311,11 +332,26 @@ class SSETransport(MCPBaseTransport):
             
         return []
 
-    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
-        """Execute a tool call using the MCP protocol."""
+    async def call_tool(
+        self, 
+        tool_name: str, 
+        arguments: Dict[str, Any],
+        timeout: Optional[float] = None
+    ) -> Dict[str, Any]:
+        """
+        Execute a tool call using the MCP protocol.
+        
+        Args:
+            tool_name: Name of the tool to call
+            arguments: Arguments to pass to the tool
+            timeout: Optional timeout for this specific call
+            
+        Returns:
+            Dictionary containing the tool result or error
+        """
         # NEW: Ensure initialization before tool calls
         if not self._initialized.is_set():
-            return {"isError": True, "error": "MCP session not initialized"}
+            return {"isError": True, "error": "SSE transport not implemented"}
             
         if not self._message_url:
             return {"isError": True, "error": "No message endpoint available"}
@@ -331,7 +367,9 @@ class SSETransport(MCPBaseTransport):
                 }
             }
             
-            response = await self._send_message(message)
+            # Use provided timeout or fall back to default
+            effective_timeout = timeout if timeout is not None else self.default_timeout
+            response = await self._send_message(message, timeout=effective_timeout)
             
             # Process MCP response
             if "error" in response:
@@ -363,8 +401,21 @@ class SSETransport(MCPBaseTransport):
         except Exception as e:
             return {"isError": True, "error": str(e)}
 
-    async def _send_message(self, message: Dict[str, Any]) -> Dict[str, Any]:
-        """Send a JSON-RPC message to the server and wait for async response."""
+    async def _send_message(
+        self, 
+        message: Dict[str, Any],
+        timeout: Optional[float] = None
+    ) -> Dict[str, Any]:
+        """
+        Send a JSON-RPC message to the server and wait for async response.
+        
+        Args:
+            message: JSON-RPC message to send
+            timeout: Optional timeout for this specific message
+            
+        Returns:
+            Response message from the server
+        """
         if not self._client or not self._message_url:
             raise RuntimeError("Transport not properly initialized")
 
@@ -372,6 +423,9 @@ class SSETransport(MCPBaseTransport):
         if not message_id:
             raise ValueError("Message must have an ID")
 
+        # Use provided timeout or fall back to default
+        effective_timeout = timeout if timeout is not None else self.default_timeout
+
         # Create a future for this request
         future = asyncio.Future()
         async with self._message_lock:
@@ -391,7 +445,8 @@ class SSETransport(MCPBaseTransport):
             if response.status_code == 202:
                 # Server accepted - wait for async response via SSE
                 try:
-                    response_message = await asyncio.wait_for(future, timeout=30.0)
+                    # FIXED: Use effective_timeout instead of hardcoded 30.0
+                    response_message = await asyncio.wait_for(future, timeout=effective_timeout)
                     return response_message
                 except asyncio.TimeoutError:
                     raise RuntimeError(f"Timeout waiting for response to message {message_id}")

chuk_tool_processor/mcp/transport/stdio_transport.py

@@ -131,7 +131,7 @@ class StdioTransport(MCPBaseTransport):
     def get_streams(self):
         """
         Expose the low-level streams so legacy callers can access them
-        directly.  The base-class’ default returns an empty list; here we
+        directly.  The base-class' default returns an empty list; here we
         return a single-element list when the transport is active.
         """
         if self.read_stream and self.write_stream:
@@ -145,7 +145,7 @@ class StdioTransport(MCPBaseTransport):
         self, tool_name: str, arguments: Dict[str, Any]
     ) -> Dict[str, Any]:
         """
-        Execute *tool_name* with *arguments* and normalise the server’s reply.
+        Execute *tool_name* with *arguments* and normalise the server's reply.
 
         The echo-server often returns:
         {

chuk_tool_processor/models/validated_tool.py

@@ -35,7 +35,7 @@ T_Validated = TypeVar("T_Validated", bound="ValidatedTool")
 
 
 # --------------------------------------------------------------------------- #
-# Helper mix-in – serialise a *class* into assorted formats
+# Helper mix-in - serialise a *class* into assorted formats
 # --------------------------------------------------------------------------- #
 class _ExportMixin:
     """Static helpers that expose a tool class in other specs."""
@@ -79,7 +79,7 @@ class _ExportMixin:
         return cls.Arguments.model_json_schema()  # type: ignore[attr-defined]
 
     # ------------------------------------------------------------------ #
-    # Tiny XML tag – handy for unit-tests / demos
+    # Tiny XML tag - handy for unit-tests / demos
     # ------------------------------------------------------------------ #
     @classmethod
     def to_xml_tag(cls: type[T_Validated], **arguments: Any) -> str:
@@ -96,9 +96,9 @@ class ValidatedTool(_ExportMixin, BaseModel):
     """Pydantic-validated base for new async-native tools."""
 
     # ------------------------------------------------------------------ #
-    # Inner models – override in subclasses
+    # Inner models - override in subclasses
     # ------------------------------------------------------------------ #
-    class Arguments(BaseModel):  # noqa: D401 – acts as a namespace
+    class Arguments(BaseModel):  # noqa: D401 - acts as a namespace
         """Input model"""
 
     class Result(BaseModel):  # noqa: D401
@@ -124,14 +124,14 @@ class ValidatedTool(_ExportMixin, BaseModel):
     # ------------------------------------------------------------------ #
     # Sub-classes must implement this
     # ------------------------------------------------------------------ #
-    async def _execute(self, **_kwargs: Any):  # noqa: D401 – expected override
+    async def _execute(self, **_kwargs: Any):  # noqa: D401 - expected override
         raise NotImplementedError("Tool must implement async _execute()")
 
 
 # --------------------------------------------------------------------------- #
 # Decorator to retrofit validation onto classic "imperative" tools
 # --------------------------------------------------------------------------- #
-def with_validation(cls):  # noqa: D401 – factory
+def with_validation(cls):  # noqa: D401 - factory
     """
     Decorator that wraps an existing async ``execute`` method with:
 

chuk_tool_processor/plugins/discovery.py

@@ -58,13 +58,13 @@ class PluginDiscovery:
     """
     Recursively scans *package_paths* for plugin classes and registers them.
 
-    * Parser plugins – concrete subclasses of :class:`ParserPlugin`
+    * Parser plugins - concrete subclasses of :class:`ParserPlugin`
       with an **async** ``try_parse`` coroutine.
 
-    * Execution strategies – concrete subclasses of
+    * Execution strategies - concrete subclasses of
       :class:`ExecutionStrategy`.
 
-    * Explicitly-decorated plugins – classes tagged with ``@plugin(...)``.
+    * Explicitly-decorated plugins - classes tagged with ``@plugin(...)``.
     """
 
     # ------------------------------------------------------------------ #

chuk_tool_processor/plugins/parsers/base.py

@@ -16,7 +16,7 @@ class ParserPlugin(ABC):
     Every parser plugin **must** implement the async ``try_parse`` coroutine.
 
     The processor awaits it and expects *a list* of :class:`ToolCall`
-    objects. If the plugin doesn’t recognise the input it should return an
+    objects. If the plugin doesn't recognise the input it should return an
     empty list.
     """