chuk-tool-processor 0.6.4__py3-none-any.whl → 0.9.7__py3-none-any.whl

chuk_tool_processor/utils/validation.py

@@ -8,12 +8,15 @@ validate_arguments(tool_name, fn, args) -> dict
 validate_result(tool_name, fn, result)  -> Any
 @with_validation                        -> class decorator
 """
+
 from __future__ import annotations
+
 import inspect
-import asyncio
+from collections.abc import Callable
 from functools import lru_cache, wraps
-from typing import Any, Callable, Dict, get_type_hints, Awaitable
-from pydantic import BaseModel, ValidationError, create_model, Extra
+from typing import Any, get_type_hints
+
+from pydantic import BaseModel, ConfigDict, ValidationError, create_model
 
 # exception
 from chuk_tool_processor.core.exceptions import ToolValidationError
@@ -36,19 +39,15 @@ def _arg_model(tool_name: str, fn: Callable) -> type[BaseModel]:
     hints.pop("return", None)
 
     sig = inspect.signature(fn)
-    fields: Dict[str, tuple[Any, Any]] = {}
+    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(
+    return create_model(  # type: ignore[call-overload, no-any-return]
         f"{tool_name}Args",
-        __config__=type(
-            "Cfg",
-            (),
-            {"extra": Extra.forbid},  # disallow unknown keys
-        ),
+        __config__=ConfigDict(extra="forbid"),  # disallow unknown keys
         **fields,
     )
 
@@ -71,13 +70,13 @@ def _result_model(tool_name: str, fn: Callable) -> type[BaseModel] | None:
 # --------------------------------------------------------------------------- #
 
 
-def validate_arguments(tool_name: str, fn: Callable, args: Dict[str, Any]) -> Dict[str, Any]:
+def validate_arguments(tool_name: str, fn: Callable, args: dict[str, Any]) -> dict[str, Any]:
     """Validate function arguments against type hints."""
     try:
         model = _arg_model(tool_name, fn)
         return model(**args).model_dump()
     except ValidationError as exc:
-        raise ToolValidationError(tool_name, exc.errors()) from exc
+        raise ToolValidationError(tool_name, {"errors": exc.errors()}) from exc
 
 
 def validate_result(tool_name: str, fn: Callable, result: Any) -> Any:
@@ -86,9 +85,9 @@ def validate_result(tool_name: str, fn: Callable, result: Any) -> Any:
     if model is None:  # no annotation ⇒ no validation
         return result
     try:
-        return model(result=result).result
+        return model(result=result).result  # type: ignore[attr-defined]
     except ValidationError as exc:
-        raise ToolValidationError(tool_name, exc.errors()) from exc
+        raise ToolValidationError(tool_name, {"errors": exc.errors()}) from exc
 
 
 # --------------------------------------------------------------------------- #
@@ -110,7 +109,7 @@ def with_validation(cls):
     # Which method did the user provide?
     fn_name = "_execute" if hasattr(cls, "_execute") else "execute"
     original = getattr(cls, fn_name)
-    
+
     # Ensure the method is async
     if not inspect.iscoroutinefunction(original):
         raise TypeError(f"Tool {cls.__name__} must have an async {fn_name} method")
@@ -123,4 +122,4 @@ def with_validation(cls):
         return validate_result(name, original, res)
 
     setattr(cls, fn_name, _validated)
-    return cls
+    return cls