chuk-tool-processor 0.4__tar.gz → 0.4.1__tar.gz

{chuk_tool_processor-0.4 → chuk_tool_processor-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chuk-tool-processor
-Version: 0.4
+Version: 0.4.1
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{chuk_tool_processor-0.4 → chuk_tool_processor-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "chuk-tool-processor"
-version = "0.4"
+version = "0.4.1"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"

{chuk_tool_processor-0.4 → chuk_tool_processor-0.4.1}/src/chuk_tool_processor/core/processor.py

@@ -367,7 +367,7 @@ class ToolProcessor:
                     all_calls.extend(result)
 
         # ------------------------------------------------------------------ #
-        # Remove duplicates – use a stable digest instead of hashing a
+        # Remove duplicates - use a stable digest instead of hashing a
         # frozenset of argument items (which breaks on unhashable types).
         # ------------------------------------------------------------------ #
         def _args_digest(args: Dict[str, Any]) -> str:

{chuk_tool_processor-0.4 → chuk_tool_processor-0.4.1}/src/chuk_tool_processor/execution/strategies/inprocess_strategy.py

@@ -393,7 +393,7 @@ class InProcessStrategy(ExecutionStrategy):
         """
         Execute a single tool call with guaranteed timeout.
 
-        The entire invocation – including argument validation – is wrapped
+        The entire invocation - including argument validation - is wrapped
         by the semaphore to honour *max_concurrency*.
         
         Args:

{chuk_tool_processor-0.4 → chuk_tool_processor-0.4.1}/src/chuk_tool_processor/execution/wrappers/caching.py

@@ -4,9 +4,9 @@ Async-native caching wrapper for tool execution.
 
 This module provides:
 
-* **CacheInterface** – abstract async cache contract for custom implementations
-* **InMemoryCache** – simple, thread-safe in-memory cache with TTL support
-* **CachingToolExecutor** – executor wrapper that transparently caches results
+* **CacheInterface** - abstract async cache contract for custom implementations
+* **InMemoryCache** - simple, thread-safe in-memory cache with TTL support
+* **CachingToolExecutor** - executor wrapper that transparently caches results
 
 Results retrieved from cache are marked with `cached=True` and `machine="cache"`
 for easy detection.

chuk_tool_processor-0.4.1/src/chuk_tool_processor/execution/wrappers/retry.py

@@ -0,0 +1,275 @@
+# chuk_tool_processor/execution/wrappers/retry.py
+"""
+Async-native retry wrapper for tool execution.
+
+Adds exponential–back-off retry logic and *deadline-aware* timeout handling so a
+`timeout=` passed by callers is treated as the **total wall-clock budget** for
+all attempts of a single tool call.
+"""
+from __future__ import annotations
+
+import asyncio
+import random
+import time
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Type
+
+from chuk_tool_processor.logging import get_logger
+from chuk_tool_processor.models.tool_call import ToolCall
+from chuk_tool_processor.models.tool_result import ToolResult
+
+logger = get_logger("chuk_tool_processor.execution.wrappers.retry")
+
+
+# --------------------------------------------------------------------------- #
+# Retry configuration
+# --------------------------------------------------------------------------- #
+class RetryConfig:
+    """Configuration object that decides *whether* and *when* to retry."""
+
+    def __init__(
+        self,
+        max_retries: int = 3,
+        base_delay: float = 1.0,
+        max_delay: float = 60.0,
+        jitter: bool = True,
+        retry_on_exceptions: Optional[List[Type[Exception]]] = None,
+        retry_on_error_substrings: Optional[List[str]] = None,
+    ):
+        if max_retries < 0:
+            raise ValueError("max_retries cannot be negative")
+        self.max_retries = max_retries
+        self.base_delay = base_delay
+        self.max_delay = max_delay
+        self.jitter = jitter
+        self.retry_on_exceptions = retry_on_exceptions or []
+        self.retry_on_error_substrings = retry_on_error_substrings or []
+
+    # --------------------------------------------------------------------- #
+    # Decision helpers
+    # --------------------------------------------------------------------- #
+    def should_retry(  # noqa: D401  (imperative mood is fine)
+        self,
+        attempt: int,
+        *,
+        error: Optional[Exception] = None,
+        error_str: Optional[str] = None,
+    ) -> bool:
+        """Return *True* iff another retry is allowed for this attempt."""
+        if attempt >= self.max_retries:
+            return False
+
+        # Nothing specified → always retry until max_retries reached
+        if not self.retry_on_exceptions and not self.retry_on_error_substrings:
+            return True
+
+        if error is not None and any(isinstance(error, exc) for exc in self.retry_on_exceptions):
+            return True
+
+        if error_str and any(substr in error_str for substr in self.retry_on_error_substrings):
+            return True
+
+        return False
+
+    # --------------------------------------------------------------------- #
+    # Back-off
+    # --------------------------------------------------------------------- #
+    def get_delay(self, attempt: int) -> float:
+        """Exponential back-off delay for *attempt* (0-based)."""
+        delay = min(self.base_delay * (2 ** attempt), self.max_delay)
+        if self.jitter:
+            delay *= 0.5 + random.random()  # jitter in [0.5, 1.5)
+        return delay
+
+
+# --------------------------------------------------------------------------- #
+# Retryable executor
+# --------------------------------------------------------------------------- #
+class RetryableToolExecutor:
+    """
+    Wraps another executor and re-invokes it according to a :class:`RetryConfig`.
+    """
+
+    def __init__(
+        self,
+        executor: Any,
+        *,
+        default_config: Optional[RetryConfig] = None,
+        tool_configs: Optional[Dict[str, RetryConfig]] = None,
+    ):
+        self.executor = executor
+        self.default_config = default_config or RetryConfig()
+        self.tool_configs = tool_configs or {}
+
+    # --------------------------------------------------------------------- #
+    # Public helpers
+    # --------------------------------------------------------------------- #
+    def _config_for(self, tool: str) -> RetryConfig:
+        return self.tool_configs.get(tool, self.default_config)
+
+    async def execute(
+        self,
+        calls: List[ToolCall],
+        *,
+        timeout: Optional[float] = None,
+        use_cache: bool = True,
+    ) -> List[ToolResult]:
+        if not calls:
+            return []
+
+        out: List[ToolResult] = []
+        for call in calls:
+            cfg = self._config_for(call.tool)
+            out.append(await self._execute_single(call, cfg, timeout, use_cache))
+        return out
+
+    # --------------------------------------------------------------------- #
+    # Core retry loop (per call)
+    # --------------------------------------------------------------------- #
+    async def _execute_single(
+        self,
+        call: ToolCall,
+        cfg: RetryConfig,
+        timeout: Optional[float],
+        use_cache: bool,
+    ) -> ToolResult:
+        attempt = 0
+        last_error: Optional[str] = None
+        pid = 0
+        machine = "unknown"
+
+        # ---------------------------------------------------------------- #
+        # Deadline budget (wall-clock)
+        # ---------------------------------------------------------------- #
+        deadline = None
+        if timeout is not None:
+            deadline = time.monotonic() + timeout
+
+        while True:
+            # ---------------------------------------------------------------- #
+            # Check whether we have any time left *before* trying the call
+            # ---------------------------------------------------------------- #
+            if deadline is not None:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    return ToolResult(
+                        tool=call.tool,
+                        result=None,
+                        error=f"Timeout after {timeout}s",
+                        start_time=datetime.now(timezone.utc),
+                        end_time=datetime.now(timezone.utc),
+                        machine=machine,
+                        pid=pid,
+                        attempts=attempt,
+                    )
+            else:
+                remaining = None  # unlimited
+
+            # ---------------------------------------------------------------- #
+            # Execute one attempt
+            # ---------------------------------------------------------------- #
+            start_time = datetime.now(timezone.utc)
+            try:
+                kwargs = {"timeout": remaining} if remaining is not None else {}
+                if hasattr(self.executor, "use_cache"):
+                    kwargs["use_cache"] = use_cache
+
+                result = (await self.executor.execute([call], **kwargs))[0]
+                pid = result.pid
+                machine = result.machine
+
+                # Success?
+                if not result.error:
+                    result.attempts = attempt + 1
+                    return result
+
+                # Error: decide on retry
+                last_error = result.error
+                if cfg.should_retry(attempt, error_str=result.error):
+                    delay = cfg.get_delay(attempt)
+                    # never overshoot the deadline
+                    if deadline is not None:
+                        delay = min(delay, max(deadline - time.monotonic(), 0))
+                    if delay:
+                        await asyncio.sleep(delay)
+                    attempt += 1
+                    continue
+
+                # No more retries wanted
+                result.error = self._wrap_error(last_error, attempt, cfg)
+                result.attempts = attempt + 1
+                return result
+
+            # ---------------------------------------------------------------- #
+            # Exception path
+            # ---------------------------------------------------------------- #
+            except Exception as exc:  # noqa: BLE001
+                err_str = str(exc)
+                last_error = err_str
+                if cfg.should_retry(attempt, error=exc):
+                    delay = cfg.get_delay(attempt)
+                    if deadline is not None:
+                        delay = min(delay, max(deadline - time.monotonic(), 0))
+                    if delay:
+                        await asyncio.sleep(delay)
+                    attempt += 1
+                    continue
+
+                end_time = datetime.now(timezone.utc)
+                return ToolResult(
+                    tool=call.tool,
+                    result=None,
+                    error=self._wrap_error(err_str, attempt, cfg),
+                    start_time=start_time,
+                    end_time=end_time,
+                    machine=machine,
+                    pid=pid,
+                    attempts=attempt + 1,
+                )
+
+    # --------------------------------------------------------------------- #
+    # Helpers
+    # --------------------------------------------------------------------- #
+    @staticmethod
+    def _wrap_error(err: str, attempt: int, cfg: RetryConfig) -> str:
+        if attempt >= cfg.max_retries and attempt > 0:
+            return f"Max retries reached ({cfg.max_retries}): {err}"
+        return err
+
+
+# --------------------------------------------------------------------------- #
+# Decorator helper
+# --------------------------------------------------------------------------- #
+def retryable(
+    *,
+    max_retries: int = 3,
+    base_delay: float = 1.0,
+    max_delay: float = 60.0,
+    jitter: bool = True,
+    retry_on_exceptions: Optional[List[Type[Exception]]] = None,
+    retry_on_error_substrings: Optional[List[str]] = None,
+):
+    """
+    Class decorator that attaches a :class:`RetryConfig` to a *tool* class.
+
+    Example
+    -------
+    ```python
+    @retryable(max_retries=5, base_delay=0.5)
+    class MyTool:
+        ...
+    ```
+    """
+
+    def _decorator(cls):
+        cls._retry_config = RetryConfig(
+            max_retries=max_retries,
+            base_delay=base_delay,
+            max_delay=max_delay,
+            jitter=jitter,
+            retry_on_exceptions=retry_on_exceptions,
+            retry_on_error_substrings=retry_on_error_substrings,
+        )
+        return cls
+
+    return _decorator

{chuk_tool_processor-0.4 → chuk_tool_processor-0.4.1}/src/chuk_tool_processor/logging/context.py

@@ -4,12 +4,12 @@ Async-safe context management for structured logging.
 
 This module provides:
 
-* **LogContext** – an `asyncio`-aware container that keeps a per-task dict of
+* **LogContext** - an `asyncio`-aware container that keeps a per-task dict of
   contextual data (request IDs, span IDs, arbitrary metadata, …).
-* **log_context** – a global instance of `LogContext` for convenience.
-* **StructuredAdapter** – a `logging.LoggerAdapter` that injects the current
+* **log_context** - a global instance of `LogContext` for convenience.
+* **StructuredAdapter** - a `logging.LoggerAdapter` that injects the current
   `log_context.context` into every log record.
-* **get_logger** – helper that returns a configured `StructuredAdapter`.
+* **get_logger** - helper that returns a configured `StructuredAdapter`.
 """
 
 from __future__ import annotations
@@ -75,7 +75,7 @@ class LogContext:
     Async-safe context container.
 
     Holds a mutable dict that is *local* to the current asyncio task, so
-    concurrent coroutines don’t interfere with each other.
+    concurrent coroutines don't interfere with each other.
     """
 
     # ------------------------------------------------------------------ #
@@ -196,7 +196,7 @@ class StructuredAdapter(logging.LoggerAdapter):
     """
 
     # --------------------------- core hook -------------------------------- #
-    def process(self, msg, kwargs):  # noqa: D401 – keep signature from base
+    def process(self, msg, kwargs):  # noqa: D401 - keep signature from base
         kwargs = kwargs or {}
         extra = kwargs.get("extra", {}).copy()
         ctx = log_context.context

{chuk_tool_processor-0.4 → chuk_tool_processor-0.4.1}/src/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-0.4 → chuk_tool_processor-0.4.1}/src/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-0.4 → chuk_tool_processor-0.4.1}/src/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-0.4 → chuk_tool_processor-0.4.1}/src/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-0.4 → chuk_tool_processor-0.4.1}/src/chuk_tool_processor/mcp/stream_manager.py

@@ -77,7 +77,7 @@ class StreamManager:
         return inst
 
     # ------------------------------------------------------------------ #
-    #  initialisation – stdio / sse                                      #
+    #  initialisation - stdio / sse                                      #
     # ------------------------------------------------------------------ #
     async def initialize(
         self,
@@ -143,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),
             )
@@ -194,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),
             )
@@ -245,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):

{chuk_tool_processor-0.4 → chuk_tool_processor-0.4.1}/src/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-0.4 → chuk_tool_processor-0.4.1}/src/chuk_tool_processor/mcp/transport/sse_transport.py

@@ -351,7 +351,7 @@ class SSETransport(MCPBaseTransport):
         """
         # 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"}

{chuk_tool_processor-0.4 → chuk_tool_processor-0.4.1}/src/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:
         {