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

chuk_tool_processor/plugins/discovery.py

@@ -8,10 +8,10 @@ import inspect
 import logging
 import pkgutil
 from types import ModuleType
-from typing import Any, Dict, List, Optional, Set, Type
+from typing import Any
 
-from chuk_tool_processor.plugins.parsers.base import ParserPlugin
 from chuk_tool_processor.models.execution_strategy import ExecutionStrategy
+from chuk_tool_processor.plugins.parsers.base import ParserPlugin
 
 __all__ = [
     "plugin_registry",
@@ -33,7 +33,7 @@ class PluginRegistry:
 
     def __init__(self) -> None:
         # category → {name → object}
-        self._plugins: Dict[str, Dict[str, Any]] = {}
+        self._plugins: dict[str, dict[str, Any]] = {}
 
     # --------------------------------------------------------------------- #
     # Public API
@@ -42,10 +42,10 @@ class PluginRegistry:
         self._plugins.setdefault(category, {})[name] = plugin
         logger.debug("Registered plugin %s.%s", category, name)
 
-    def get_plugin(self, category: str, name: str) -> Optional[Any]:  # noqa: D401
+    def get_plugin(self, category: str, name: str) -> Any | None:  # noqa: D401
         return self._plugins.get(category, {}).get(name)
 
-    def list_plugins(self, category: str | None = None) -> Dict[str, List[str]]:
+    def list_plugins(self, category: str | None = None) -> dict[str, list[str]]:
         if category is not None:
             return {category: sorted(self._plugins.get(category, {}))}
         return {cat: sorted(names) for cat, names in self._plugins.items()}
@@ -70,10 +70,10 @@ class PluginDiscovery:
     # ------------------------------------------------------------------ #
     def __init__(self, registry: PluginRegistry) -> None:
         self._registry = registry
-        self._seen_modules: Set[str] = set()
+        self._seen_modules: set[str] = set()
 
     # ------------------------------------------------------------------ #
-    def discover_plugins(self, package_paths: List[str]) -> None:
+    def discover_plugins(self, package_paths: list[str]) -> None:
         """Import every package in *package_paths* and walk its subtree."""
         for pkg_path in package_paths:
             self._walk(pkg_path)
@@ -113,7 +113,7 @@ class PluginDiscovery:
                 self._maybe_register(attr)
 
     # ------------------------------------------------------------------ #
-    def _maybe_register(self, cls: Type) -> None:
+    def _maybe_register(self, cls: type) -> None:
         """Register *cls* in all matching plugin categories."""
         if inspect.isabstract(cls):
             return
@@ -133,7 +133,7 @@ class PluginDiscovery:
             self._registry.register_plugin("execution_strategy", cls.__name__, cls)
 
         # ------------- Explicit @plugin decorator ------------------
-        meta: Optional[dict] = getattr(cls, "_plugin_meta", None)
+        meta: dict | None = getattr(cls, "_plugin_meta", None)
         if meta:
             category = meta.get("category", "unknown")
             name = meta.get("name", cls.__name__)
@@ -178,6 +178,6 @@ def discover_default_plugins() -> None:
     PluginDiscovery(plugin_registry).discover_plugins(["chuk_tool_processor.plugins"])
 
 
-def discover_plugins(package_paths: List[str]) -> None:
+def discover_plugins(package_paths: list[str]) -> None:
     """Discover plugins from arbitrary external *package_paths*."""
     PluginDiscovery(plugin_registry).discover_plugins(package_paths)

chuk_tool_processor/plugins/parsers/__init__.py

@@ -1 +1 @@
-# chuk_tool_processor/plugins/parsers/__init__.py
+# chuk_tool_processor/plugins/parsers/__init__.py

chuk_tool_processor/plugins/parsers/base.py

@@ -4,7 +4,6 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import List
 
 from chuk_tool_processor.models.tool_call import ToolCall
 
@@ -21,6 +20,6 @@ class ParserPlugin(ABC):
     """
 
     @abstractmethod
-    async def try_parse(self, raw: str | object) -> List[ToolCall]:  # noqa: D401
+    async def try_parse(self, raw: str | object) -> list[ToolCall]:  # noqa: D401
         """Attempt to parse *raw* into one or more :class:`ToolCall` objects."""
         ...

chuk_tool_processor/plugins/parsers/function_call_tool.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 
 import json
 import re
-from typing import Any, Dict, List
+from typing import Any
 
 from pydantic import ValidationError
 
@@ -26,8 +26,7 @@ class PluginMeta:
 
     name: str = "function_call"
     description: str = (
-        "Parses a single OpenAI-style `function_call` JSON object (including "
-        "strings that embed such an object)."
+        "Parses a single OpenAI-style `function_call` JSON object (including strings that embed such an object)."
     )
     version: str = "1.0.0"
     author: str = "chuk_tool_processor"
@@ -40,19 +39,25 @@ class FunctionCallPlugin(ParserPlugin):
     # Public API
     # --------------------------------------------------------------------- #
 
-    async def try_parse(self, raw: str | Dict[str, Any]) -> List[ToolCall]:
-        payload: Dict[str, Any] | None
+    async def try_parse(self, raw: Any) -> list[ToolCall]:
+        # Handle non-string, non-dict inputs gracefully
+        if not isinstance(raw, str | dict):
+            return []
+
+        payload: dict[str, Any] | None
 
         # 1️⃣  Primary path ─ whole payload is JSON
         if isinstance(raw, dict):
             payload = raw
-        else:
+        elif isinstance(raw, str):
             try:
                 payload = json.loads(raw)
             except json.JSONDecodeError:
                 payload = None
+        else:
+            return []
 
-        calls: List[ToolCall] = []
+        calls: list[ToolCall] = []
 
         if isinstance(payload, dict):
             calls.extend(self._extract_from_payload(payload))
@@ -72,7 +77,7 @@ class FunctionCallPlugin(ParserPlugin):
     # Helpers
     # ------------------------------------------------------------------ #
 
-    def _extract_from_payload(self, payload: Dict[str, Any]) -> List[ToolCall]:
+    def _extract_from_payload(self, payload: dict[str, Any]) -> list[ToolCall]:
         fc = payload.get("function_call")
         if not isinstance(fc, dict):
             return []

chuk_tool_processor/plugins/parsers/json_tool.py

@@ -4,7 +4,7 @@
 from __future__ import annotations
 
 import json
-from typing import Any, List
+from typing import Any
 
 from pydantic import ValidationError
 
@@ -19,6 +19,7 @@ logger = get_logger(__name__)
 
 class PluginMeta:
     """Optional self-description consumed by the plugin-discovery subsystem."""
+
     name: str = "json_tool_calls"
     description: str = "Parses a JSON object containing a `tool_calls` array."
     version: str = "1.0.0"
@@ -28,7 +29,7 @@ class PluginMeta:
 class JsonToolPlugin(ParserPlugin):
     """Extracts a *list* of :class:`ToolCall` objects from a `tool_calls` array."""
 
-    async def try_parse(self, raw: str | Any) -> List[ToolCall]:  # noqa: D401
+    async def try_parse(self, raw: str | Any) -> list[ToolCall]:  # noqa: D401
         # Decode JSON if we were given a string
         try:
             data = json.loads(raw) if isinstance(raw, str) else raw
@@ -39,7 +40,7 @@ class JsonToolPlugin(ParserPlugin):
         if not isinstance(data, dict):
             return []
 
-        calls: List[ToolCall] = []
+        calls: list[ToolCall] = []
         for entry in data.get("tool_calls", []):
             try:
                 calls.append(ToolCall(**entry))

chuk_tool_processor/plugins/parsers/openai_tool.py

@@ -4,7 +4,7 @@
 from __future__ import annotations
 
 import json
-from typing import Any, List
+from typing import Any
 
 from pydantic import ValidationError
 
@@ -19,6 +19,7 @@ logger = get_logger(__name__)
 
 class PluginMeta:
     """Optional descriptor consumed by the plugin-discovery system."""
+
     name: str = "openai_tool_calls"
     description: str = "Parses Chat-Completions responses containing `tool_calls`."
     version: str = "1.0.0"
@@ -43,7 +44,7 @@ class OpenAIToolPlugin(ParserPlugin):
         }
     """
 
-    async def try_parse(self, raw: str | Any) -> List[ToolCall]:  # noqa: D401
+    async def try_parse(self, raw: str | Any) -> list[ToolCall]:  # noqa: D401
         # ------------------------------------------------------------------ #
         # 1. Decode JSON when the input is a string
         # ------------------------------------------------------------------ #
@@ -59,8 +60,14 @@ class OpenAIToolPlugin(ParserPlugin):
         # ------------------------------------------------------------------ #
         # 2. Build ToolCall objects
         # ------------------------------------------------------------------ #
-        calls: List[ToolCall] = []
-        for entry in data["tool_calls"]:
+        calls: list[ToolCall] = []
+
+        # Ensure tool_calls is a list
+        tool_calls = data.get("tool_calls", [])
+        if not isinstance(tool_calls, list):
+            return []
+
+        for entry in tool_calls:
             fn = entry.get("function", {})
             name = fn.get("name")
             args = fn.get("arguments", {})
@@ -76,9 +83,7 @@ class OpenAIToolPlugin(ParserPlugin):
                 continue
 
             try:
-                calls.append(
-                    ToolCall(tool=name, arguments=args if isinstance(args, dict) else {})
-                )
+                calls.append(ToolCall(tool=name, arguments=args if isinstance(args, dict) else {}))
             except ValidationError:
                 logger.debug(
                     "openai_tool_plugin: validation error while building ToolCall for %s",

chuk_tool_processor/plugins/parsers/xml_tool.py

@@ -17,7 +17,6 @@ from __future__ import annotations
 
 import json
 import re
-from typing import List
 
 from pydantic import ValidationError
 
@@ -32,6 +31,7 @@ logger = get_logger(__name__)
 
 class PluginMeta:
     """Optional descriptor that can be used by the plugin-discovery mechanism."""
+
     name: str = "xml_tool_tag"
     description: str = "Parses <tool …/> XML tags into ToolCall objects."
     version: str = "1.0.0"
@@ -49,11 +49,11 @@ class XmlToolPlugin(ParserPlugin):
     )
 
     # ------------------------------------------------------------------ #
-    async def try_parse(self, raw: str | object) -> List[ToolCall]:  # noqa: D401
+    async def try_parse(self, raw: str | object) -> list[ToolCall]:  # noqa: D401
         if not isinstance(raw, str):
             return []
 
-        calls: List[ToolCall] = []
+        calls: list[ToolCall] = []
 
         for match in self._TAG.finditer(raw):
             name = match.group("tool")
@@ -92,7 +92,7 @@ class XmlToolPlugin(ParserPlugin):
         # 3️⃣ Last resort - naive unescaping of \" → "
         if parsed is None:
             try:
-                parsed = json.loads(raw_args.replace(r"\"", "\""))
+                parsed = json.loads(raw_args.replace(r"\"", '"'))
             except json.JSONDecodeError:
                 parsed = {}
 

chuk_tool_processor/registry/__init__.py

@@ -3,13 +3,11 @@
 Async-native tool registry package for managing and accessing tool implementations.
 """
 
-import asyncio
-from typing import Optional
-
+from chuk_tool_processor.registry.decorators import discover_decorated_tools, ensure_registrations, register_tool
 from chuk_tool_processor.registry.interface import ToolRegistryInterface
-from chuk_tool_processor.registry.metadata import ToolMetadata, StreamingToolMetadata
+from chuk_tool_processor.registry.metadata import StreamingToolMetadata, ToolMetadata
 from chuk_tool_processor.registry.provider import ToolRegistryProvider, get_registry
-from chuk_tool_processor.registry.decorators import register_tool, ensure_registrations, discover_decorated_tools
+
 
 # --------------------------------------------------------------------------- #
 # The default_registry is now an async function instead of direct property access
@@ -17,14 +15,15 @@ from chuk_tool_processor.registry.decorators import register_tool, ensure_regist
 async def get_default_registry() -> ToolRegistryInterface:
     """
     Get the default registry instance.
-    
+
     This is a convenience function that calls ToolRegistryProvider.get_registry()
-    
+
     Returns:
         The default tool registry
     """
     return await ToolRegistryProvider.get_registry()
 
+
 __all__ = [
     "ToolRegistryInterface",
     "ToolMetadata",
@@ -37,24 +36,25 @@ __all__ = [
     "get_registry",
 ]
 
+
 # --------------------------------------------------------------------------- #
 # Initialization helper that should be called at application startup
 # --------------------------------------------------------------------------- #
 async def initialize():
     """
     Initialize the registry system.
-    
+
     This function should be called during application startup to:
     1. Ensure the registry is created
     2. Register all tools decorated with @register_tool
-    
+
     Returns:
         The initialized registry
     """
     # Initialize registry
     registry = await get_default_registry()
-    
+
     # Process all pending tool registrations
     await ensure_registrations()
-    
-    return registry
+
+    return registry

chuk_tool_processor/registry/auto_register.py

@@ -11,10 +11,9 @@ These tools will immediately show up in the global registry.
 
 from __future__ import annotations
 
-import asyncio
 import inspect
-import types
-from typing import Callable, ForwardRef, Type, get_type_hints, Any, Optional, Dict, Union
+from collections.abc import Callable
+from typing import Any, ForwardRef, get_type_hints
 
 import anyio
 from pydantic import BaseModel, create_model
@@ -25,16 +24,14 @@ except ModuleNotFoundError:  # pragma: no cover
     BaseTool = None  # noqa: N816  - keep the name for isinstance() checks
 
 # registry
-from .decorators import register_tool
 from .provider import ToolRegistryProvider
 
-
 # ────────────────────────────────────────────────────────────────────────────
 # internals - build a Pydantic schema from an arbitrary callable
 # ────────────────────────────────────────────────────────────────────────────
 
 
-def _auto_schema(func: Callable) -> Type[BaseModel]:
+def _auto_schema(func: Callable) -> type[BaseModel]:
     """
     Turn a function signature into a `pydantic.BaseModel` subclass.
 
@@ -55,8 +52,7 @@ def _auto_schema(func: Callable) -> Type[BaseModel]:
         # couldn't resolve the type.
         hint: type = (
             raw_hint
-            if raw_hint not in (inspect._empty, None, str)
-            and not isinstance(raw_hint, (str, ForwardRef))
+            if raw_hint not in (inspect._empty, None, str) and not isinstance(raw_hint, str | ForwardRef)
             else str
         )
         fields[param.name] = (hint, ...)  # "..."  → required
@@ -78,7 +74,7 @@ async def register_fn_tool(
 ) -> None:
     """
     Register a plain function as a tool asynchronously.
-    
+
     Args:
         func: The function to register (can be sync or async)
         name: Optional name for the tool (defaults to function name)
@@ -88,21 +84,23 @@ async def register_fn_tool(
     schema = _auto_schema(func)
     tool_name = name or func.__name__
     tool_description = (description or func.__doc__ or "").strip()
-    
+
     # Create the tool wrapper class
     class _Tool:  # noqa: D401, N801 - internal auto-wrapper
         """Auto-generated tool wrapper for function."""
-        
+
         async def execute(self, **kwargs: Any) -> Any:
             """Execute the wrapped function."""
             if inspect.iscoroutinefunction(func):
                 return await func(**kwargs)
             # off-load blocking sync work
-            return await anyio.to_thread.run_sync(func, **kwargs)
-    
+            import functools
+
+            return await anyio.to_thread.run_sync(functools.partial(func, **kwargs))
+
     # Set the docstring
     _Tool.__doc__ = tool_description
-    
+
     # Get the registry and register directly
     registry = await ToolRegistryProvider.get_registry()
     await registry.register_tool(
@@ -115,7 +113,7 @@ async def register_fn_tool(
             "argument_schema": schema.model_json_schema(),
             "source": "function",
             "source_name": func.__qualname__,
-        }
+        },
     )
 
 
@@ -133,7 +131,7 @@ async def register_langchain_tool(
 ) -> None:
     """
     Register a **LangChain** `BaseTool` instance asynchronously.
-    
+
     Works with any object exposing `.run` / `.arun` methods.
 
     Args:
@@ -141,45 +139,39 @@ async def register_langchain_tool(
         name: Optional name for the tool (defaults to tool.name)
         description: Optional description (defaults to tool.description)
         namespace: Registry namespace (defaults to "default")
-        
+
     Raises:
         RuntimeError: If LangChain isn't installed
         TypeError: If the object isn't a LangChain BaseTool
     """
     if BaseTool is None:
-        raise RuntimeError(
-            "register_langchain_tool() requires LangChain - "
-            "install with `pip install langchain`"
-        )
+        raise RuntimeError("register_langchain_tool() requires LangChain - install with `pip install langchain`")
 
     if not isinstance(tool, BaseTool):  # pragma: no cover
-        raise TypeError(
-            "Expected a langchain.tools.base.BaseTool instance - got "
-            f"{type(tool).__name__}"
-        )
+        raise TypeError(f"Expected a langchain.tools.base.BaseTool instance - got {type(tool).__name__}")
 
     # Prefer async implementation if available
     fn = tool.arun if hasattr(tool, "arun") else tool.run
-    
+
     tool_name = name or tool.name or tool.__class__.__name__
     tool_description = description or tool.description or (tool.__doc__ or "")
-    
+
     await register_fn_tool(
         fn,
         name=tool_name,
         description=tool_description,
         namespace=namespace,
     )
-    
+
     # Update the metadata to include LangChain info
     registry = await ToolRegistryProvider.get_registry()
     metadata = await registry.get_metadata(tool_name, namespace)
-    
+
     if metadata:
         updated_metadata = metadata.model_copy()
         # Update source info
         updated_metadata.tags.add("langchain")
-        
+
         # Re-register with updated metadata
         await registry.register_tool(
             await registry.get_tool(tool_name, namespace),