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

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/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/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/execution/wrappers/retry.py

@@ -2,36 +2,31 @@
 """
 Async-native retry wrapper for tool execution.
 
-This module provides a retry mechanism for tool calls that can automatically
-retry failed executions based on configurable criteria and backoff strategies.
+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 logging
 import random
+import time
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional, Type, Union
+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
-from chuk_tool_processor.logging import get_logger
 
 logger = get_logger("chuk_tool_processor.execution.wrappers.retry")
 
 
+# --------------------------------------------------------------------------- #
+# Retry configuration
+# --------------------------------------------------------------------------- #
 class RetryConfig:
-    """
-    Configuration for retry behavior.
-    
-    Attributes:
-        max_retries: Maximum number of retry attempts
-        base_delay: Base delay between retries in seconds
-        max_delay: Maximum delay between retries in seconds
-        jitter: Whether to add random jitter to delays
-        retry_on_exceptions: List of exception types to retry on
-        retry_on_error_substrings: List of error message substrings to retry on
-    """
+    """Configuration object that decides *whether* and *when* to retry."""
+
     def __init__(
         self,
         max_retries: int = 3,
@@ -39,248 +34,242 @@ class RetryConfig:
         max_delay: float = 60.0,
         jitter: bool = True,
         retry_on_exceptions: Optional[List[Type[Exception]]] = None,
-        retry_on_error_substrings: Optional[List[str]] = 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 []
-    
-    def should_retry(self, attempt: int, error: Optional[Exception] = None, error_str: Optional[str] = None) -> bool:
-        """
-        Determine if a retry should be attempted.
-        
-        Args:
-            attempt: Current attempt number (0-based)
-            error: Exception that caused the failure, if any
-            error_str: Error message string, if any
-            
-        Returns:
-            True if a retry should be attempted, False otherwise
-        """
+
+    # --------------------------------------------------------------------- #
+    # 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:
-        """
-        Calculate the delay for the current attempt with exponential backoff.
-        
-        Args:
-            attempt: Current attempt number (0-based)
-            
-        Returns:
-            Delay in seconds
-        """
+        """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())
+            delay *= 0.5 + random.random()  # jitter in [0.5, 1.5)
         return delay
 
 
+# --------------------------------------------------------------------------- #
+# Retryable executor
+# --------------------------------------------------------------------------- #
 class RetryableToolExecutor:
     """
-    Wrapper for a tool executor that applies retry logic.
-    
-    This executor wraps another executor and automatically retries failed
-    tool calls based on configured retry policies.
+    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
+        tool_configs: Optional[Dict[str, RetryConfig]] = None,
     ):
-        """
-        Initialize the retryable executor.
-        
-        Args:
-            executor: The underlying executor to wrap
-            default_config: Default retry configuration for all tools
-            tool_configs: Tool-specific retry configurations
-        """
         self.executor = executor
         self.default_config = default_config or RetryConfig()
         self.tool_configs = tool_configs or {}
-    
-    def _get_config(self, tool: str) -> RetryConfig:
-        """Get the retry configuration for a specific tool."""
+
+    # --------------------------------------------------------------------- #
+    # 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
+        use_cache: bool = True,
     ) -> List[ToolResult]:
-        """
-        Execute tool calls with retry logic.
-        
-        Args:
-            calls: List of tool calls to execute
-            timeout: Optional timeout for each execution
-            use_cache: Whether to use cached results (passed to underlying executor)
-            
-        Returns:
-            List of tool results
-        """
-        # Handle empty calls list
         if not calls:
             return []
-            
-        # Execute each call with retries
-        results: List[ToolResult] = []
+
+        out: List[ToolResult] = []
         for call in calls:
-            config = self._get_config(call.tool)
-            result = await self._execute_with_retry(call, config, timeout, use_cache)
-            results.append(result)
-        return results
-    
-    async def _execute_with_retry(
+            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,
-        config: RetryConfig,
+        cfg: RetryConfig,
         timeout: Optional[float],
-        use_cache: bool
+        use_cache: bool,
     ) -> ToolResult:
-        """
-        Execute a single tool call with retries.
-        
-        Args:
-            call: Tool call to execute
-            config: Retry configuration to use
-            timeout: Optional timeout for execution
-            use_cache: Whether to use cached results
-            
-        Returns:
-            Tool result after retries
-        """
         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:
-                # Pass the use_cache parameter if the executor supports it
-                executor_kwargs = {"timeout": timeout}
+                kwargs = {"timeout": remaining} if remaining is not None else {}
                 if hasattr(self.executor, "use_cache"):
-                    executor_kwargs["use_cache"] = use_cache
-                
-                # Execute call
-                tool_results = await self.executor.execute([call], **executor_kwargs)
-                result = tool_results[0]
+                    kwargs["use_cache"] = use_cache
+
+                result = (await self.executor.execute([call], **kwargs))[0]
                 pid = result.pid
                 machine = result.machine
-                
-                # Check for error in result
-                if result.error:
-                    last_error = result.error
-                    if config.should_retry(attempt, error_str=result.error):
-                        logger.debug(
-                            f"Retrying tool {call.tool} after error: {result.error} (attempt {attempt + 1}/{config.max_retries})"
-                        )
-                        await asyncio.sleep(config.get_delay(attempt))
-                        attempt += 1
-                        continue
-                        
-                    # No retry: if any retries happened, wrap final error
-                    if attempt > 0:
-                        end_time = datetime.now(timezone.utc)
-                        final = ToolResult(
-                            tool=call.tool,
-                            result=None,
-                            error=f"Max retries reached ({config.max_retries}): {last_error}",
-                            start_time=start_time,
-                            end_time=end_time,
-                            machine=machine,
-                            pid=pid
-                        )
-                        # Attach attempts
-                        final.attempts = attempt + 1  # Include the original attempt
-                        return final
-                        
-                    # No retries occurred, return the original failure
-                    result.attempts = 1
+
+                # Success?
+                if not result.error:
+                    result.attempts = attempt + 1
                     return result
-                
-                # Success: attach attempts and return
-                result.attempts = attempt + 1  # Include the original attempt
+
+                # 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
-                
-            except Exception as e:
-                err_str = str(e)
+
+            # ---------------------------------------------------------------- #
+            # Exception path
+            # ---------------------------------------------------------------- #
+            except Exception as exc:  # noqa: BLE001
+                err_str = str(exc)
                 last_error = err_str
-                
-                if config.should_retry(attempt, error=e):
-                    logger.info(
-                        f"Retrying tool {call.tool} after exception: {err_str} (attempt {attempt + 1}/{config.max_retries})"
-                    )
-                    await asyncio.sleep(config.get_delay(attempt))
+                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
-                    
-                # No more retries: return error result
+
                 end_time = datetime.now(timezone.utc)
-                final_exc = ToolResult(
+                return ToolResult(
                     tool=call.tool,
                     result=None,
-                    error=err_str,
+                    error=self._wrap_error(err_str, attempt, cfg),
                     start_time=start_time,
                     end_time=end_time,
                     machine=machine,
-                    pid=pid
+                    pid=pid,
+                    attempts=attempt + 1,
                 )
-                final_exc.attempts = attempt + 1  # Include the original attempt
-                return final_exc
 
+    # --------------------------------------------------------------------- #
+    # 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
+    retry_on_error_substrings: Optional[List[str]] = None,
 ):
     """
-    Decorator for tool classes to configure retry behavior.
-    
-    Example:
-        @retryable(max_retries=5, base_delay=2.0)
-        class MyTool:
-            async def execute(self, x: int, y: int) -> int:
-                return x + y
-                
-    Args:
-        max_retries: Maximum number of retry attempts
-        base_delay: Base delay between retries in seconds
-        max_delay: Maximum delay between retries in seconds
-        jitter: Whether to add random jitter to delays
-        retry_on_exceptions: List of exception types to retry on
-        retry_on_error_substrings: List of error message substrings to retry on
-        
-    Returns:
-        Decorated class with retry configuration
+    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):
+
+    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
+            retry_on_error_substrings=retry_on_error_substrings,
         )
         return cls
-    return decorator
+
+    return _decorator

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/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

@@ -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/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

@@ -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/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.
     """
 

chuk_tool_processor/plugins/parsers/xml_tool.py

@@ -68,7 +68,7 @@ class XmlToolPlugin(ParserPlugin):
         return calls
 
     # ------------------------------------------------------------------ #
-    # Helper – robust JSON decode for the args attribute
+    # Helper - robust JSON decode for the args attribute
     # ------------------------------------------------------------------ #
     @staticmethod
     def _decode_args(raw_args: str) -> dict:
@@ -89,7 +89,7 @@ class XmlToolPlugin(ParserPlugin):
             except json.JSONDecodeError:
                 parsed = None
 
-        # 3️⃣ Last resort – naive unescaping of \" → "
+        # 3️⃣ Last resort - naive unescaping of \" → "
         if parsed is None:
             try:
                 parsed = json.loads(raw_args.replace(r"\"", "\""))

chuk_tool_processor/registry/auto_register.py

@@ -22,7 +22,7 @@ from pydantic import BaseModel, create_model
 try:  # optional dependency
     from langchain.tools.base import BaseTool  # type: ignore
 except ModuleNotFoundError:  # pragma: no cover
-    BaseTool = None  # noqa: N816  – keep the name for isinstance() checks
+    BaseTool = None  # noqa: N816  - keep the name for isinstance() checks
 
 # registry
 from .decorators import register_tool
@@ -30,7 +30,7 @@ from .provider import ToolRegistryProvider
 
 
 # ────────────────────────────────────────────────────────────────────────────
-# internals – build a Pydantic schema from an arbitrary callable
+# internals - build a Pydantic schema from an arbitrary callable
 # ────────────────────────────────────────────────────────────────────────────
 
 
@@ -39,7 +39,7 @@ def _auto_schema(func: Callable) -> Type[BaseModel]:
     Turn a function signature into a `pydantic.BaseModel` subclass.
 
     *Unknown* or *un-imported* annotations (common with third-party libs that
-    use forward-refs without importing the target – e.g. ``uuid.UUID`` in
+    use forward-refs without importing the target - e.g. ``uuid.UUID`` in
     LangChain's `CallbackManagerForToolRun`) default to ``str`` instead of
     crashing `get_type_hints()`.
     """
@@ -90,7 +90,7 @@ async def register_fn_tool(
     tool_description = (description or func.__doc__ or "").strip()
     
     # Create the tool wrapper class
-    class _Tool:  # noqa: D401, N801 – internal auto-wrapper
+    class _Tool:  # noqa: D401, N801 - internal auto-wrapper
         """Auto-generated tool wrapper for function."""
         
         async def execute(self, **kwargs: Any) -> Any:
@@ -154,7 +154,7 @@ async def register_langchain_tool(
 
     if not isinstance(tool, BaseTool):  # pragma: no cover
         raise TypeError(
-            "Expected a langchain.tools.base.BaseTool instance – got "
+            "Expected a langchain.tools.base.BaseTool instance - got "
             f"{type(tool).__name__}"
         )
 

chuk_tool_processor/registry/interface.py

@@ -104,8 +104,8 @@ class ToolRegistryInterface(Protocol):
 
         Args:
             namespace: Optional filter by namespace.
-                • None (default) – metadata from all namespaces
-                • "some_ns" – only that namespace
+                • None (default) - metadata from all namespaces
+                • "some_ns" - only that namespace
 
         Returns:
             List of ToolMetadata objects.

chuk_tool_processor/registry/providers/memory.py

@@ -125,8 +125,8 @@ class InMemoryToolRegistry(ToolRegistryInterface):
 
         Args:
             namespace: Optional filter by namespace.
-                • None (default) – metadata from all namespaces
-                • "some_ns" – only that namespace
+                • None (default) - metadata from all namespaces
+                • "some_ns" - only that namespace
 
         Returns:
             List of ToolMetadata objects.

chuk_tool_processor/utils/validation.py

@@ -25,7 +25,7 @@ __all__ = [
 ]
 
 # --------------------------------------------------------------------------- #
-# helpers – create & cache ad-hoc pydantic models
+# helpers - create & cache ad-hoc pydantic models
 # --------------------------------------------------------------------------- #
 
 

{chuk_tool_processor-0.4.dist-info → chuk_tool_processor-0.4.1.dist-info}/METADATA

@@ -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.dist-info → chuk_tool_processor-0.4.1.dist-info}/RECORD

@@ -1,58 +1,58 @@
 chuk_tool_processor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/core/__init__.py,sha256=slM7pZna88tyZrF3KtN22ApYyCqGNt5Yscv-knsLOOA,38
 chuk_tool_processor/core/exceptions.py,sha256=h4zL1jpCY1Ud1wT8xDeMxZ8GR8ttmkObcv36peUHJEA,1571
-chuk_tool_processor/core/processor.py,sha256=ttEYZTQHctXXiUP8gxAMCCSjbRvyOHojQe_UJezJYRs,18369
+chuk_tool_processor/core/processor.py,sha256=diquzXCQax6wxK-MLfezIJIjdCm9rkRYSFsWMHXU2A4,18367
 chuk_tool_processor/execution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/execution/tool_executor.py,sha256=SGnOrsQJ8b9dPD_2rYlRyp1WLcwn7pLfbrm5APOsQvo,14387
 chuk_tool_processor/execution/strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chuk_tool_processor/execution/strategies/inprocess_strategy.py,sha256=UJIv1g3Z9LpMsTYa9cqJB376StsI0up3cftH4OkqC2I,22582
+chuk_tool_processor/execution/strategies/inprocess_strategy.py,sha256=Mn4gPC9ocxUNHYUMhtALLyR2-DOZphWmBoFSx6_Aelo,22578
 chuk_tool_processor/execution/strategies/subprocess_strategy.py,sha256=Rb5GTffl-4dkAQG_zz8wjggqyWznVOr9gReLGHmE2io,22469
 chuk_tool_processor/execution/wrappers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chuk_tool_processor/execution/wrappers/caching.py,sha256=1pSyouYT4H7AGkNcK_7wWAIT1d4AKnHJlKBODPO8tZw,20416
+chuk_tool_processor/execution/wrappers/caching.py,sha256=3KDb84ARhDKjUQXrpJT1FaO2pM8ciXFuEdr5zmeLiBM,20410
 chuk_tool_processor/execution/wrappers/rate_limiting.py,sha256=CBBsI1VLosjo8dZXLeJ3IaclGvy9VdjGyqgunY089KQ,9231
-chuk_tool_processor/execution/wrappers/retry.py,sha256=oK6g0Ey8zbAubOgOvDbTFyvP1bVCI53knjXgfd_b3dw,10350
+chuk_tool_processor/execution/wrappers/retry.py,sha256=UgJ1UzOGx-HOXfMYmqVfRcMQKT6Q4l2eb4nJJ6nSSps,10144
 chuk_tool_processor/logging/__init__.py,sha256=Uux0QnL6Xcd4vNjtt54rNei3yvxUZ-sOuAahlcPAez0,3382
-chuk_tool_processor/logging/context.py,sha256=8wLE6yoDxush7rGu_wTzVCautqq-Jq_0R9SBxLOjpwI,8520
+chuk_tool_processor/logging/context.py,sha256=vPK7Z4TgLfsSl90exIE6mCqwdrjax_aDa9P6JqnbCsA,8508
 chuk_tool_processor/logging/formatter.py,sha256=RhlV6NqBYRBOtytDY49c9Y1J4l02ZjNXIgVRn03tfSQ,3061
 chuk_tool_processor/logging/helpers.py,sha256=c1mS1sb_rh4bKG0hisyvT7l7cirQfXPSyWeBqmqALRw,5941
 chuk_tool_processor/logging/metrics.py,sha256=s59Au8q0eqGGtJMDqmJBZhbJHh4BWGE1CzT0iI8lRS8,3624
 chuk_tool_processor/mcp/__init__.py,sha256=vR9HHxLpXlKTIIwJJRr3QTmZegcdedR1YKyb46j6FIM,689
-chuk_tool_processor/mcp/mcp_tool.py,sha256=a7WnBiu8DaSuZ8RI0Ums4M5A7v46RvijlqZa0020wWg,4922
-chuk_tool_processor/mcp/register_mcp_tools.py,sha256=0q73gafC1d0ei_gqNidcUeY7NUg13UZdjhVOKEFcD5o,3642
-chuk_tool_processor/mcp/setup_mcp_sse.py,sha256=T0V27azQy06yc-RSc5uzEKyhbyAXFT-7O3pIn4k10HQ,3769
-chuk_tool_processor/mcp/setup_mcp_stdio.py,sha256=P9qSgmxoNQbsOlGp83DlLLpN9BsG__MhlRsxFplNP3M,2753
-chuk_tool_processor/mcp/stream_manager.py,sha256=Wro1csV8S-V-PBan-4-c3cCyhJPmxG1wQJa4MLh02Dc,16914
+chuk_tool_processor/mcp/mcp_tool.py,sha256=VOyz8uvUGlHOtfypuuOy8qkJx8cc7IIMIjZovQHSuCw,4870
+chuk_tool_processor/mcp/register_mcp_tools.py,sha256=ZqR9kikHCbD7InL5cYl9ttUkhA5e4q2S76lbPLWe98I,3636
+chuk_tool_processor/mcp/setup_mcp_sse.py,sha256=Sja3y1uBkqKfpGS69Y90KBb9XNDxKDu3GgQsFqgFiTU,3761
+chuk_tool_processor/mcp/setup_mcp_stdio.py,sha256=emSL1IabdHoFdNUpEJNdzlc9-0qA51ZMuNJHpsYtw5o,2749
+chuk_tool_processor/mcp/stream_manager.py,sha256=oho45ZdxJqYhDk3V9gTDQUvdxFaiPhyj2QRr4rLw4Mw,16902
 chuk_tool_processor/mcp/transport/__init__.py,sha256=7QQqeSKVKv0N9GcyJuYF0R4FDZeooii5RjggvFFg5GY,296
-chuk_tool_processor/mcp/transport/base_transport.py,sha256=1E29LjWw5vLQrPUDF_9TJt63P5dxAAN7n6E_KiZbGUY,3427
-chuk_tool_processor/mcp/transport/sse_transport.py,sha256=2nyuc04Clc4FmJWxxZ2TmwiRd9NI7fpLqSN-g1wvRAI,19689
-chuk_tool_processor/mcp/transport/stdio_transport.py,sha256=lFXL7p8ca4z_J0RBL8UCHrQ1UH7C2-LbC0tZhpya4V4,7763
+chuk_tool_processor/mcp/transport/base_transport.py,sha256=bqId34OMQMxzMXtrKq_86sot0_x0NS_ecaIllsCyy6I,3423
+chuk_tool_processor/mcp/transport/sse_transport.py,sha256=ZvPJzTJHLEOYCLs1fugyHIofhPzCvlh_3lGH7HxxM4I,19691
+chuk_tool_processor/mcp/transport/stdio_transport.py,sha256=X9NgK_rU1Rw4DpHJ54Et8mICnRbutTZItHdP3PX3dU4,7759
 chuk_tool_processor/models/__init__.py,sha256=TC__rdVa0lQsmJHM_hbLDPRgToa_pQT_UxRcPZk6iVw,40
 chuk_tool_processor/models/execution_strategy.py,sha256=UVW35YIeMY2B3mpIKZD2rAkyOPayI6ckOOUALyf0YiQ,2115
 chuk_tool_processor/models/streaming_tool.py,sha256=0v2PSPTgZ5TS_PpVdohvVhh99fPwPQM_R_z4RU0mlLM,3541
 chuk_tool_processor/models/tool_call.py,sha256=t3QOQVzUaNRBea_n5fsrCgK4_ILiZlT8LvF7UwaZU84,1748
 chuk_tool_processor/models/tool_export_mixin.py,sha256=U9NJvn9fqH3pW50ozdDAHlA0fQSnjUt-lYhEoW_leZU,998
 chuk_tool_processor/models/tool_result.py,sha256=-8LdlaE9Ajfb1t-UyN9lW0XB2abQWALD7j8PZc-txhQ,5029
-chuk_tool_processor/models/validated_tool.py,sha256=LYc9-IBCiQmoMUotyByinRQQ-jfrC6g6tflMtSf9MUg,5908
+chuk_tool_processor/models/validated_tool.py,sha256=m12jmaOsKek5pib1uXEOuDMILf9qoDzb-aqlp9wedMc,5896
 chuk_tool_processor/plugins/__init__.py,sha256=QO_ipvlsWG-rbaqGzj6-YtD7zi7Lx26hw-Cqha4MuWc,48
-chuk_tool_processor/plugins/discovery.py,sha256=kHRpOrcRnHiviKHCCdQN04cpSUqbifAZdSbU81Wc0fA,7112
+chuk_tool_processor/plugins/discovery.py,sha256=ZKWTJgrKzKnIuCPHg1CPu0j7e1L4R8y10Tq9IKXkj5M,7106
 chuk_tool_processor/plugins/parsers/__init__.py,sha256=07waNfAGuytn-Dntx2IxjhgSkM9F40TBYNUXC8G4VVo,49
-chuk_tool_processor/plugins/parsers/base.py,sha256=r-15AZUmlGwWC3EQHRxiqPgivNv-mro6aTKqOwhuAtg,752
+chuk_tool_processor/plugins/parsers/base.py,sha256=sqBngdyCoUwUsTTJlT6722jN0QxxYz-ijtD4hmEK6mU,750
 chuk_tool_processor/plugins/parsers/function_call_tool.py,sha256=kaUTMhIpDP4jZa_CJZiGchIoszK3AboZM2BJOXzPJmg,3198
 chuk_tool_processor/plugins/parsers/json_tool.py,sha256=jljG7jR9070oHSTFqcrXbtFjYorw1cb4ZpwfrsLgFSE,1556
 chuk_tool_processor/plugins/parsers/openai_tool.py,sha256=O33DyXN0Llqv7AHygE9sVQkbSDVNIOcNqqa1CaZF6vo,2849
-chuk_tool_processor/plugins/parsers/xml_tool.py,sha256=V-JSWWy1ncXwX6-Of45zaLEGXryjKMTDEgTmEl6-XlY,3186
+chuk_tool_processor/plugins/parsers/xml_tool.py,sha256=oIDSWOk38IUKBAMoGuN2hnrAhrhDuO_9L0-p77rEHJw,3182
 chuk_tool_processor/registry/__init__.py,sha256=PBv5QyzHmUJEjgFQW1zgcUmppa5xUTjXTLVsYoVnDQI,2036
-chuk_tool_processor/registry/auto_register.py,sha256=wanaibx9CNsI1et0v2I25xzi5I_w8YaSlvW05ENEpIU,7252
+chuk_tool_processor/registry/auto_register.py,sha256=cPod3t1Gng9Dz2-ujqpZBsrpOOcLd7UBJ7L6NqXzXqU,7242
 chuk_tool_processor/registry/decorators.py,sha256=qFK-z7wd53BY7rEbqqWMrWQXbP4UaTLVTCQRI2iUhHI,5035
-chuk_tool_processor/registry/interface.py,sha256=dqThCnHd2KCgX8j96j_hZxF2rigGClrI-hRc5n_nv2M,3467
+chuk_tool_processor/registry/interface.py,sha256=sFacGnhcZXmeK7iF5fSm21ktecYTVzRiyGjxGWSkt-k,3463
 chuk_tool_processor/registry/metadata.py,sha256=lR9FO__lhPr-ax7PhFk8Se1bJdN_48rabiN7qegx4Ns,4582
 chuk_tool_processor/registry/provider.py,sha256=YUCGCFARNxnzV2Dm72Ur4DOrDs_ZYDtCzd6OBBzlis8,5162
 chuk_tool_processor/registry/tool_export.py,sha256=FEdMsfZ3uhiOjoDHqcnSwNehAN7Z5mgi4nI1UKu2hgs,7569
 chuk_tool_processor/registry/providers/__init__.py,sha256=eigwG_So11j7WbDGSWaKd3KwVen3Rap-aNQCSWA6T4k,2705
-chuk_tool_processor/registry/providers/memory.py,sha256=LlpPUU9E7S8Se6Q3VyKxLwpNm82SvmP8GLUmI8MkHxQ,5188
+chuk_tool_processor/registry/providers/memory.py,sha256=6cMtUwLO6zrk3pguQRgxJ2CReHAzewgZsizWZhsoStk,5184
 chuk_tool_processor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chuk_tool_processor/utils/validation.py,sha256=fiTSsHq7zx-kyd755GaFCvPCa-EVasSpg0A1liNHkxU,4138
-chuk_tool_processor-0.4.dist-info/METADATA,sha256=yk5rGA3xmEMCEZtikLNE508Q7oY1GwbTZR2jzOR2P5I,24312
-chuk_tool_processor-0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-chuk_tool_processor-0.4.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
-chuk_tool_processor-0.4.dist-info/RECORD,,
+chuk_tool_processor/utils/validation.py,sha256=V5N1dH9sJlHepFIbiI2k2MU82o7nvnh0hKyIt2jdgww,4136
+chuk_tool_processor-0.4.1.dist-info/METADATA,sha256=fk4FL20xDVBGSZEa96BLL2R0ulRbGbUGnKgCruGzWIg,24314
+chuk_tool_processor-0.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chuk_tool_processor-0.4.1.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
+chuk_tool_processor-0.4.1.dist-info/RECORD,,