chuk-tool-processor 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

chuk_tool_processor/registry/providers/memory.py

@@ -1,8 +1,11 @@
 # chuk_tool_processor/registry/providers/memory.py
+# chuk_tool_processor/registry/providers/memory.py
 """
 In-memory implementation of the tool registry.
 """
 
+from __future__ import annotations
+
 import inspect
 from typing import Any, Dict, List, Optional, Tuple
 
@@ -14,152 +17,114 @@ from chuk_tool_processor.registry.metadata import ToolMetadata
 class InMemoryToolRegistry(ToolRegistryInterface):
     """
     In-memory implementation of ToolRegistryInterface with namespace support.
-    
-    This implementation stores tools and their metadata in memory,
-    organized by namespace. It's suitable for single-process applications
-    or for testing, but doesn't provide persistence or sharing across
-    multiple processes.
+
+    Suitable for single-process apps or tests; not persisted across processes.
     """
-    def __init__(self):
-        """Initialize the in-memory registry."""
-        # Store tools as {namespace: {name: tool}}
+
+    # ------------------------------------------------------------------ #
+    # construction
+    # ------------------------------------------------------------------ #
+
+    def __init__(self) -> None:
+        # {namespace: {tool_name: tool_obj}}
         self._tools: Dict[str, Dict[str, Any]] = {}
-        # Store metadata as {namespace: {name: metadata}}
+        # {namespace: {tool_name: ToolMetadata}}
         self._metadata: Dict[str, Dict[str, ToolMetadata]] = {}
 
+    # ------------------------------------------------------------------ #
+    # registration
+    # ------------------------------------------------------------------ #
+
     def register_tool(
-        self, 
-        tool: Any, 
+        self,
+        tool: Any,
         name: Optional[str] = None,
         namespace: str = "default",
-        metadata: Optional[Dict[str, Any]] = None
+        metadata: Optional[Dict[str, Any]] = None,
     ) -> None:
-        """
-        Register a tool implementation.
+        # ensure namespace buckets
+        self._tools.setdefault(namespace, {})
+        self._metadata.setdefault(namespace, {})
 
-        Args:
-            tool: The tool class or instance with an `execute` method.
-            name: Optional explicit name; if omitted, uses tool.__name__.
-            namespace: Namespace for the tool (default: "default").
-            metadata: Optional additional metadata for the tool.
-        """
-        # Ensure the namespace exists
-        if namespace not in self._tools:
-            self._tools[namespace] = {}
-            self._metadata[namespace] = {}
-            
-        # Determine tool name
         key = name or getattr(tool, "__name__", None) or repr(tool)
-        
-        # Register the tool
         self._tools[namespace][key] = tool
-        
-        # Create and store metadata
+
+        # build metadata -------------------------------------------------
         is_async = inspect.iscoroutinefunction(getattr(tool, "execute", None))
-        
-        # Get description from docstring if available
-        description = None
-        if hasattr(tool, "__doc__") and tool.__doc__:
-            description = inspect.getdoc(tool)
-        
-        # Create metadata object
-        meta_dict = {
+
+        # default description -> docstring
+        description = (
+            (inspect.getdoc(tool) or "").strip()
+            if not (metadata and "description" in metadata)
+            else None
+        )
+
+        meta_dict: Dict[str, Any] = {
             "name": key,
             "namespace": namespace,
-            "is_async": is_async
+            "is_async": is_async,
         }
-        
-        # Add description if available (but don't override metadata if provided)
-        if description and not (metadata and "description" in metadata):
+        if description:
             meta_dict["description"] = description
-            
-        # Add any additional metadata
         if metadata:
             meta_dict.update(metadata)
-            
-        tool_metadata = ToolMetadata(**meta_dict)
-        
-        self._metadata[namespace][key] = tool_metadata
+
+        self._metadata[namespace][key] = ToolMetadata(**meta_dict)
+
+    # ------------------------------------------------------------------ #
+    # retrieval
+    # ------------------------------------------------------------------ #
 
     def get_tool(self, name: str, namespace: str = "default") -> Optional[Any]:
-        """
-        Retrieve a registered tool by name and namespace.
-        
-        Args:
-            name: The name of the tool.
-            namespace: The namespace of the tool (default: "default").
-            
-        Returns:
-            The tool implementation or None if not found.
-        """
-        if namespace not in self._tools:
-            return None
-        return self._tools[namespace].get(name)
+        return self._tools.get(namespace, {}).get(name)
 
     def get_tool_strict(self, name: str, namespace: str = "default") -> Any:
-        """
-        Retrieve a registered tool by name and namespace, raising an exception if not found.
-        
-        Args:
-            name: The name of the tool.
-            namespace: The namespace of the tool (default: "default").
-            
-        Returns:
-            The tool implementation.
-            
-        Raises:
-            ToolNotFoundError: If the tool is not found.
-        """
         tool = self.get_tool(name, namespace)
         if tool is None:
             raise ToolNotFoundError(f"{namespace}.{name}")
         return tool
 
-    def get_metadata(self, name: str, namespace: str = "default") -> Optional[ToolMetadata]:
-        """
-        Retrieve metadata for a registered tool.
-        
-        Args:
-            name: The name of the tool.
-            namespace: The namespace of the tool (default: "default").
-            
-        Returns:
-            ToolMetadata if found, None otherwise.
-        """
-        if namespace not in self._metadata:
-            return None
-        return self._metadata[namespace].get(name)
+    def get_metadata(
+        self, name: str, namespace: str = "default"
+    ) -> Optional[ToolMetadata]:
+        return self._metadata.get(namespace, {}).get(name)
+
+    # ------------------------------------------------------------------ #
+    # listing helpers
+    # ------------------------------------------------------------------ #
 
     def list_tools(self, namespace: Optional[str] = None) -> List[Tuple[str, str]]:
         """
-        List all registered tool names, optionally filtered by namespace.
-        
-        Args:
-            namespace: Optional namespace filter.
-            
-        Returns:
-            List of (namespace, name) tuples.
+        Return a list of ``(namespace, name)`` tuples.
         """
-        result = []
-        
         if namespace:
-            # List tools in specific namespace
-            if namespace in self._tools:
-                for name in self._tools[namespace].keys():
-                    result.append((namespace, name))
-        else:
-            # List all tools
-            for ns, tools in self._tools.items():
-                for name in tools.keys():
-                    result.append((ns, name))
-                    
+            return [
+                (namespace, n) for n in self._tools.get(namespace, {}).keys()
+            ]
+
+        result: List[Tuple[str, str]] = []
+        for ns, tools in self._tools.items():
+            result.extend((ns, n) for n in tools.keys())
         return result
 
     def list_namespaces(self) -> List[str]:
+        return list(self._tools.keys())
+
+    def list_metadata(self, namespace: str | None = None) -> List[ToolMetadata]:
         """
-        List all registered namespaces.
-        
-        Returns:
-            List of namespace names.
+        Return *all* :class:`ToolMetadata` objects.
+
+        Parameters
+        ----------
+        namespace
+            • ``None`` *(default)* – metadata from **all** namespaces  
+            • ``"some_ns"``        – only that namespace
         """
-        return list(self._tools.keys())
+        if namespace is not None:
+            return list(self._metadata.get(namespace, {}).values())
+
+        # flatten
+        result: List[ToolMetadata] = []
+        for ns_meta in self._metadata.values():
+            result.extend(ns_meta.values())
+        return result

chuk_tool_processor/registry/tool_export.py

@@ -0,0 +1,76 @@
+# chuk_tool_processor/registry/tool_export.py
+"""
+Helpers that expose all registered tools in various formats and
+translate an OpenAI `function.name` back to the matching tool.
+"""
+from __future__ import annotations
+
+from typing import Dict, List
+
+from .provider import ToolRegistryProvider
+
+# --------------------------------------------------------------------------- #
+# internal cache so tool-name lookup is O(1)
+# --------------------------------------------------------------------------- #
+_OPENAI_NAME_CACHE: dict[str, object] | None = None
+
+
+def _build_openai_name_cache() -> None:
+    """Populate the global reverse-lookup table once."""
+    global _OPENAI_NAME_CACHE
+    if _OPENAI_NAME_CACHE is not None:  # already built
+        return
+
+    _OPENAI_NAME_CACHE = {}
+    reg = ToolRegistryProvider.get_registry()
+
+    for ns, key in reg.list_tools():
+        tool = reg.get_tool(key, ns)
+
+        # ▸ registry key  -> tool
+        _OPENAI_NAME_CACHE[key] = tool
+
+        # ▸ class name    -> tool  (legacy)
+        _OPENAI_NAME_CACHE[tool.__class__.__name__] = tool
+
+        # ▸ OpenAI name   -> tool  (may differ from both above)
+        _OPENAI_NAME_CACHE[tool.to_openai()["function"]["name"]] = tool
+
+
+# --------------------------------------------------------------------------- #
+# public helpers
+# --------------------------------------------------------------------------- #
+def openai_functions() -> List[Dict]:
+    """
+    Return **all** registered tools in the exact schema the Chat-Completions
+    API expects in its ``tools=[ … ]`` parameter.
+
+    The ``function.name`` is always the *registry key* so that the round-trip
+    (export → model → parser) stays consistent even when the class name and
+    the registered key differ.
+    """
+    reg = ToolRegistryProvider.get_registry()
+    specs: list[dict] = []
+
+    for ns, key in reg.list_tools():
+        tool = reg.get_tool(key, ns)
+        spec = tool.to_openai()
+        spec["function"]["name"] = key  # ensure round-trip consistency
+        specs.append(spec)
+
+    # Ensure the cache is built the first time we export
+    _build_openai_name_cache()
+    return specs
+
+
+def tool_by_openai_name(name: str):
+    """
+    Map an OpenAI ``function.name`` back to the registered tool.
+
+    Raises ``KeyError`` if the name is unknown.
+    """
+    _build_openai_name_cache()
+    try:
+        return _OPENAI_NAME_CACHE[name]  # type: ignore[index]
+    except (KeyError, TypeError):
+        raise KeyError(f"No tool registered for OpenAI name {name!r}") from None

chuk_tool_processor/utils/validation.py

@@ -1,192 +1,121 @@
 # chuk_tool_processor/utils/validation.py
-from typing import Any, Dict, Optional, Type, get_type_hints, Union, List, Callable
-from pydantic import BaseModel, ValidationError, create_model
+"""
+Runtime helpers for validating tool inputs / outputs with Pydantic.
+
+Public API
+----------
+validate_arguments(tool_name, fn, args) -> dict
+validate_result(tool_name, fn, result)  -> Any
+@with_validation                        -> class decorator
+"""
+from __future__ import annotations
 import inspect
-from functools import wraps
+from functools import lru_cache, wraps
+from typing import Any, Callable, Dict, get_type_hints
+from pydantic import BaseModel, ValidationError, create_model, Extra
 
+# excpetion
 from chuk_tool_processor.core.exceptions import ToolValidationError
 
+__all__ = [
+    "validate_arguments",
+    "validate_result",
+    "with_validation",
+]
 
-def validate_arguments(tool_name: str, tool_func: Callable, args: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Validate tool arguments against function signature.
-    
-    Args:
-        tool_name: Name of the tool for error reporting.
-        tool_func: Tool function to validate against.
-        args: Arguments to validate.
-        
-    Returns:
-        Validated arguments dict.
-        
-    Raises:
-        ToolValidationError: If validation fails.
-    """
+# --------------------------------------------------------------------------- #
+# helpers – create & cache ad-hoc pydantic models
+# --------------------------------------------------------------------------- #
+
+
+@lru_cache(maxsize=256)
+def _arg_model(tool_name: str, fn: Callable) -> type[BaseModel]:
+    """Return (and memoise) a pydantic model derived from *fn*'s signature."""
+    hints = get_type_hints(fn)
+    hints.pop("return", None)
+
+    sig = inspect.signature(fn)
+    fields: Dict[str, tuple[Any, Any]] = {}
+    for name, hint in hints.items():
+        param = sig.parameters[name]
+        default = param.default if param.default is not inspect.Parameter.empty else ...
+        fields[name] = (hint, default)
+
+    return create_model(
+        f"{tool_name}Args",
+        __config__=type(
+            "Cfg",
+            (),
+            {"extra": Extra.forbid},  # disallow unknown keys
+        ),
+        **fields,
+    )
+
+
+@lru_cache(maxsize=256)
+def _result_model(tool_name: str, fn: Callable) -> type[BaseModel] | None:
+    """Return a pydantic model for the annotated return type (or None)."""
+    return_hint = get_type_hints(fn).get("return")
+    if return_hint is None or return_hint is type(None):  # noqa: E721
+        return None
+
+    return create_model(
+        f"{tool_name}Result",
+        result=(return_hint, ...),
+    )
+
+
+# --------------------------------------------------------------------------- #
+# public validation helpers
+# --------------------------------------------------------------------------- #
+
+
+def validate_arguments(tool_name: str, fn: Callable, args: Dict[str, Any]) -> Dict[str, Any]:
     try:
-        # Get type hints from function
-        type_hints = get_type_hints(tool_func)
-        
-        # Remove return type hint if present
-        if 'return' in type_hints:
-            type_hints.pop('return')
-        
-        # Create dynamic Pydantic model for validation
-        field_definitions = {
-            name: (type_hint, ...) for name, type_hint in type_hints.items()
-        }
-        
-        # Add optional fields based on default values
-        sig = inspect.signature(tool_func)
-        for param_name, param in sig.parameters.items():
-            if param.default is not inspect.Parameter.empty:
-                if param_name in field_definitions:
-                    field_type, _ = field_definitions[param_name]
-                    field_definitions[param_name] = (field_type, param.default)
-        
-        # Create model
-        model = create_model(f"{tool_name}Args", **field_definitions)
-        
-        # Validate args
-        validated = model(**args)
-        return validated.dict()
-    
-    except ValidationError as e:
-        raise ToolValidationError(tool_name, e.errors())
-    except Exception as e:
-        raise ToolValidationError(tool_name, {"general": str(e)})
-
-
-def validate_result(tool_name: str, tool_func: Callable, result: Any) -> Any:
-    """
-    Validate tool result against function return type.
-    
-    Args:
-        tool_name: Name of the tool for error reporting.
-        tool_func: Tool function to validate against.
-        result: Result to validate.
-        
-    Returns:
-        Validated result.
-        
-    Raises:
-        ToolValidationError: If validation fails.
-    """
+        model = _arg_model(tool_name, fn)
+        return model(**args).dict()
+    except ValidationError as exc:
+        raise ToolValidationError(tool_name, exc.errors()) from exc
+
+
+def validate_result(tool_name: str, fn: Callable, result: Any) -> Any:
+    model = _result_model(tool_name, fn)
+    if model is None:  # no annotation ⇒ no validation
+        return result
     try:
-        # Get return type hint
-        type_hints = get_type_hints(tool_func)
-        return_type = type_hints.get('return')
-        
-        if return_type is None:
-            # No return type to validate against
-            return result
-        
-        # Create dynamic Pydantic model for validation
-        model = create_model(
-            f"{tool_name}Result",
-            result=(return_type, ...)
-        )
-        
-        # Validate result
-        validated = model(result=result)
-        return validated.result
-    
-    except ValidationError as e:
-        raise ToolValidationError(tool_name, e.errors())
-    except Exception as e:
-        raise ToolValidationError(tool_name, {"general": str(e)})
+        return model(result=result).result
+    except ValidationError as exc:
+        raise ToolValidationError(tool_name, exc.errors()) from exc
+
+
+# --------------------------------------------------------------------------- #
+# decorator for classic “imperative” tools
+# --------------------------------------------------------------------------- #
 
 
 def with_validation(cls):
     """
-    Class decorator to add type validation to tool classes.
-    
-    Example:
-        @with_validation
-        class MyTool:
-            def execute(self, x: int, y: str) -> float:
-                return float(x) + float(y)
+    Wrap *execute* / *_execute* so that their arguments & return values
+    are type-checked each call.
+
+    ```
+    @with_validation
+    class MyTool:
+        def execute(self, x: int, y: int) -> int:
+            return x + y
+    ```
     """
-    original_execute = cls.execute
-    
-    @wraps(original_execute)
-    def execute_with_validation(self, **kwargs):
-        # Get tool name
-        tool_name = getattr(cls, "__name__", repr(cls))
-        
-        # Validate arguments
-        validated_args = validate_arguments(tool_name, original_execute, kwargs)
-        
-        # Execute the tool
-        result = original_execute(self, **validated_args)
-        
-        # Validate result
-        return validate_result(tool_name, original_execute, result)
-    
-    cls.execute = execute_with_validation
-    return cls
 
+    # Which method did the user provide?
+    fn_name = "_execute" if hasattr(cls, "_execute") else "execute"
+    original = getattr(cls, fn_name)
 
-class ValidatedTool(BaseModel):
-    """
-    Base class for tools with built-in validation.
-    
-    Example:
-        class AddTool(ValidatedTool):
-            class Arguments(BaseModel):
-                x: int
-                y: int
-                
-            class Result(BaseModel):
-                sum: int
-                
-            def execute(self, x: int, y: int) -> Result:
-                return self.Result(sum=x + y)
-    """
-    class Arguments(BaseModel):
-        """Base arguments model to be overridden by subclasses."""
-        pass
-    
-    class Result(BaseModel):
-        """Base result model to be overridden by subclasses."""
-        pass
-    
-    def execute(self, **kwargs) -> Any:
-        """
-        Execute the tool with validated arguments.
-        
-        Args:
-            **kwargs: Arguments to validate against Arguments model.
-            
-        Returns:
-            Validated result according to Result model.
-            
-        Raises:
-            ToolValidationError: If validation fails.
-        """
-        try:
-            # Validate arguments
-            validated_args = self.Arguments(**kwargs)
-            
-            # Execute implementation
-            result = self._execute(**validated_args.dict())
-            
-            # Validate result if it's not already a Result instance
-            if not isinstance(result, self.Result):
-                result = self.Result(**result if isinstance(result, dict) else {"value": result})
-                
-            return result
-            
-        except ValidationError as e:
-            raise ToolValidationError(self.__class__.__name__, e.errors())
-    
-    def _execute(self, **kwargs) -> Any:
-        """
-        Implementation method to be overridden by subclasses.
-        
-        Args:
-            **kwargs: Validated arguments.
-            
-        Returns:
-            Result that will be validated against Result model.
-        """
-        raise NotImplementedError("Subclasses must implement _execute")
+    @wraps(original)
+    def _validated(self, **kwargs):
+        name = cls.__name__
+        kwargs = validate_arguments(name, original, kwargs)
+        res = original(self, **kwargs)
+        return validate_result(name, original, res)
+
+    setattr(cls, fn_name, _validated)
+    return cls

{chuk_tool_processor-0.1.0.dist-info → chuk_tool_processor-0.1.2.dist-info}/METADATA

@@ -1,10 +1,13 @@
 Metadata-Version: 2.4
 Name: chuk-tool-processor
-Version: 0.1.0
+Version: 0.1.2
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
+Requires-Dist: dotenv>=0.9.9
+Requires-Dist: openai>=1.76.0
 Requires-Dist: pydantic>=2.11.3
+Requires-Dist: uuid>=1.30
 
 # CHUK Tool Processor
 
@@ -222,7 +225,7 @@ plugin_registry.register_plugin("parser", "BracketToolParser", BracketToolParser
 ### Structured Logging
 
 ```python
-from chuk_tool_processor.utils.logging import get_logger, log_context_span
+from chuk_tool_processor.logging import get_logger, log_context_span
 
 logger = get_logger("my_module")