mirascope 2.0.0__py3-none-any.whl → 2.0.0a0__py3-none-any.whl

mirascope/llm/tools/decorator.py

@@ -14,24 +14,20 @@ from .tools import AsyncContextTool, AsyncTool, ContextTool, Tool
 class ToolDecorator:
     """Protocol for the tool decorator."""
 
-    strict: bool | None = None
-    """Whether to use strict tool calling, if supported by the provider.
-    
-    If set to None, then it will use the provider's default setting (usually the 
-    strictest possible).
-    """
+    strict: bool
+    """Whether to use strict tool calling, if supported by the provider."""
 
     @overload
     def __call__(  # pyright:ignore[reportOverlappingOverload]
         self, fn: ContextToolFn[DepsT, P, JsonableCovariantT]
-    ) -> ContextTool[DepsT, JsonableCovariantT, P]:
+    ) -> ContextTool[DepsT, P, JsonableCovariantT]:
         """Call the decorator with a context function."""
         ...
 
     @overload
     def __call__(  # pyright:ignore[reportOverlappingOverload]
         self, fn: AsyncContextToolFn[DepsT, P, JsonableCovariantT]
-    ) -> AsyncContextTool[DepsT, JsonableCovariantT, P]:
+    ) -> AsyncContextTool[DepsT, P, JsonableCovariantT]:
         """Call the decorator with an async context function."""
         ...
 
@@ -56,8 +52,8 @@ class ToolDecorator:
         | ToolFn[P, JsonableCovariantT]
         | AsyncToolFn[P, JsonableCovariantT],
     ) -> (
-        ContextTool[DepsT, JsonableCovariantT, P]
-        | AsyncContextTool[DepsT, JsonableCovariantT, P]
+        ContextTool[DepsT, P, JsonableCovariantT]
+        | AsyncContextTool[DepsT, P, JsonableCovariantT]
         | Tool[P, JsonableCovariantT]
         | AsyncTool[P, JsonableCovariantT]
     ):
@@ -66,25 +62,21 @@ class ToolDecorator:
         is_async = _tool_utils.is_async_tool_fn(fn)
 
         if is_context and is_async:
-            return AsyncContextTool[DepsT, JsonableCovariantT, P].from_function(
+            return AsyncContextTool[DepsT, P, JsonableCovariantT](
                 fn, strict=self.strict
             )
         elif is_context:
-            return ContextTool[DepsT, JsonableCovariantT, P].from_function(
-                fn, strict=self.strict
-            )
+            return ContextTool[DepsT, P, JsonableCovariantT](fn, strict=self.strict)
         elif is_async:
-            return AsyncTool[P, JsonableCovariantT].from_function(
-                fn, strict=self.strict
-            )
+            return AsyncTool[P, JsonableCovariantT](fn, strict=self.strict)
         else:
-            return Tool[P, JsonableCovariantT].from_function(fn, strict=self.strict)
+            return Tool[P, JsonableCovariantT](fn, strict=self.strict)
 
 
 @overload
 def tool(  # pyright:ignore[reportOverlappingOverload]
     __fn: AsyncContextToolFn[DepsT, P, JsonableCovariantT],
-) -> AsyncContextTool[DepsT, JsonableCovariantT, P]:
+) -> AsyncContextTool[DepsT, P, JsonableCovariantT]:
     """Overload for async context tool functions."""
     ...
 
@@ -92,7 +84,7 @@ def tool(  # pyright:ignore[reportOverlappingOverload]
 @overload
 def tool(  # pyright:ignore[reportOverlappingOverload]
     __fn: ContextToolFn[DepsT, P, JsonableCovariantT],
-) -> ContextTool[DepsT, JsonableCovariantT, P]:
+) -> ContextTool[DepsT, P, JsonableCovariantT]:
     """Overload for context tool functions."""
     ...
 
@@ -110,7 +102,7 @@ def tool(__fn: ToolFn[P, JsonableCovariantT]) -> Tool[P, JsonableCovariantT]:
 
 
 @overload
-def tool(*, strict: bool | None = None) -> ToolDecorator:
+def tool(*, strict: bool = False) -> ToolDecorator:
     """Overload for setting non-default arguments."""
     ...
 
@@ -122,10 +114,10 @@ def tool(
     | AsyncToolFn[P, JsonableCovariantT]
     | None = None,
     *,
-    strict: bool | None = None,
+    strict: bool = False,
 ) -> (
-    ContextTool[DepsT, JsonableCovariantT, P]
-    | AsyncContextTool[DepsT, JsonableCovariantT, P]
+    ContextTool[DepsT, P, JsonableCovariantT]
+    | AsyncContextTool[DepsT, P, JsonableCovariantT]
     | Tool[P, JsonableCovariantT]
     | AsyncTool[P, JsonableCovariantT]
     | ToolDecorator
@@ -141,7 +133,6 @@ def tool(
 
     Args:
         strict: Whether the tool should use strict mode when supported by the model.
-            If None, uses provider's default (usually as strict as possible).
 
     Returns:
         A decorator function that converts the function into a Tool or ContextTool.

mirascope/llm/tools/protocols.py

@@ -52,7 +52,7 @@ class AsyncContextToolFn(Protocol[DepsT, P, JsonableCovariantT]):
         raise NotImplementedError()
 
 
-class KwargsCallable(Protocol[JsonableCovariantT]):
+class _KwargsCallable(Protocol[JsonableCovariantT]):
     """Protocol for functions that can be called with `Any`-typed kwargs.
 
     Used internally to type-cast tool functions for compatibility with
@@ -62,7 +62,7 @@ class KwargsCallable(Protocol[JsonableCovariantT]):
     def __call__(self, **kwargs: dict[str, Any]) -> JsonableCovariantT: ...
 
 
-class AsyncKwargsCallable(Protocol[JsonableCovariantT]):
+class _AsyncKwargsCallable(Protocol[JsonableCovariantT]):
     """Protocol for async functions that can be called with `Any`-typed kwargs.
 
     Used internally to type-cast async tool functions for compatibility with
@@ -72,7 +72,7 @@ class AsyncKwargsCallable(Protocol[JsonableCovariantT]):
     async def __call__(self, **kwargs: dict[str, Any]) -> JsonableCovariantT: ...
 
 
-class ContextKwargsCallable(Protocol[DepsT, JsonableCovariantT]):
+class _ContextKwargsCallable(Protocol[DepsT, JsonableCovariantT]):
     """Protocol for context functions that can be called with `Any`-typed kwargs.
 
     Used internally to type-cast context tool functions for compatibility with
@@ -84,7 +84,7 @@ class ContextKwargsCallable(Protocol[DepsT, JsonableCovariantT]):
     ) -> JsonableCovariantT: ...
 
 
-class AsyncJsonKwargsCallable(Protocol[DepsT, JsonableCovariantT]):
+class _AsyncJsonKwargsCallable(Protocol[DepsT, JsonableCovariantT]):
     """Protocol for async context functions that can be called with `Any`-typed kwargs.
 
     Used internally to type-cast async context tool functions for compatibility with

mirascope/llm/tools/tool_schema.py

@@ -3,16 +3,13 @@
 from __future__ import annotations
 
 import inspect
+from collections import namedtuple
 from dataclasses import dataclass
 from typing import (
     Annotated,
     Any,
     Generic,
-    NamedTuple,
-    TypeAlias,
-    TypedDict,
     TypeVar,
-    cast,
     get_args,
     get_origin,
     get_type_hints,
@@ -23,48 +20,16 @@ from pydantic import BaseModel, Field, create_model
 from pydantic.fields import FieldInfo
 
 from ..content import ToolCall
-from ..types import Jsonable
 from .protocols import AsyncContextToolFn, AsyncToolFn, ContextToolFn, ToolFn
 
-AnyToolFn: TypeAlias = (
-    ToolFn[..., Jsonable]
-    | AsyncToolFn[..., Jsonable]
-    | ContextToolFn[Any, ..., Jsonable]
-    | AsyncContextToolFn[Any, ..., Jsonable]
-)
-
 ToolFnT = TypeVar(
     "ToolFnT",
-    bound=AnyToolFn,
+    bound=ToolFn | AsyncToolFn | ContextToolFn | AsyncContextToolFn,
     covariant=True,
 )
+ToolSchemaT = TypeVar("ToolSchemaT", bound="ToolSchema")
 
-AnyToolSchema: TypeAlias = "ToolSchema[AnyToolFn]"
-ToolSchemaT = TypeVar("ToolSchemaT", bound=AnyToolSchema, covariant=True)
-
-
-ModelJsonSchema = TypedDict(
-    "ModelJsonSchema",
-    {
-        "properties": dict[str, dict[str, Any]],
-        "required": list[str],
-        "$defs": dict[str, dict[str, Any]],
-    },
-    total=False,
-)
-"""Type for Pydantic's model_json_schema() output.
-
-This TypedDict defines the structure of JSON schemas returned by Pydantic models,
-allowing us to avoid type casts when extracting schema components.
-"""
-
-
-class DocstringArg(NamedTuple):
-    """A parameter from a docstring."""
-
-    name: str
-    description: str
-
+DocstringArg = namedtuple("DocstringArg", ["name", "description"])
 
 FORMAT_TOOL_NAME = "__mirascope_formatted_output_tool__"
 """Reserved name of the formatted output tool. 
@@ -98,7 +63,7 @@ def _parse_docstring_params(docstring: str | None) -> ParsedDocstring:
         return ParsedDocstring(args=[])
 
     parsed = parse(docstring)
-    args: list[DocstringArg] = []
+    args = []
 
     for param in parsed.params:
         if param.description:
@@ -157,12 +122,8 @@ class ToolSchema(Generic[ToolFnT]):
     it should **not be modified** after the ToolSchema is created.
     """
 
-    strict: bool | None
-    """Whether the tool should use strict mode when supported by the model.
-    
-    If set to None, will use the provider's default setting (usually as strict as 
-    possible).
-    """
+    strict: bool
+    """Whether the tool should use strict mode when supported by the model."""
 
     def __hash__(self) -> int:
         if not hasattr(self, "_hash"):
@@ -179,36 +140,10 @@ class ToolSchema(Generic[ToolFnT]):
     def __init__(
         self,
         fn: ToolFnT,
-        name: str,
-        description: str,
-        parameters: ToolParameterSchema,
         *,
-        strict: bool | None = None,
-    ) -> None:
-        """Create a `ToolSchema` with the provided values.
-
-        Args:
-            fn: The function that implements the tool's functionality
-            name: The name of the tool
-            description: Description of what the tool does
-            parameters: JSON Schema describing the parameters accepted by the tool
-            strict: Whether the tool should use strict mode when supported.
-                If None, uses provider's default (usually as strict as possible).
-        """
-        self.fn = fn
-        self.name = name
-        self.description = description
-        self.parameters = parameters
-        self.strict = strict
-
-    @classmethod
-    def from_function(
-        cls,
-        fn: AnyToolFn,
-        *,
-        strict: bool | None = None,
+        strict: bool = False,
         is_context_tool: bool = False,
-    ) -> ToolSchema[AnyToolFn]:
+    ) -> None:
         """Create a `ToolSchema` by inspecting a function and its docstring.
 
         Uses Pydantic's create_model to dynamically build a model from the function
@@ -217,8 +152,7 @@ class ToolSchema(Generic[ToolFnT]):
 
         Args:
             fn: The function to extract schema from
-            strict: Whether the tool should use strict mode when supported.
-                If None, uses provider's default (usually as strict as possible).
+            strict: Whether the tool should use strict mode when supported
             is_context_tool: Whether this is a context tool (skips the context parameter)
 
         Returns:
@@ -236,7 +170,7 @@ class ToolSchema(Generic[ToolFnT]):
 
         param_descriptions = _parse_docstring_params(fn.__doc__)
 
-        field_definitions: dict[str, tuple[Any, Any]] = {}
+        field_definitions = {}
         hints = get_type_hints(fn, include_extras=True)
 
         context_param_skipped = False
@@ -269,7 +203,7 @@ class ToolSchema(Generic[ToolFnT]):
                     description=field_info.description,
                 )
             else:
-                docstring_description: str | None = None
+                docstring_description = None
                 for arg in param_descriptions.args:
                     if arg.name == param.name:
                         docstring_description = arg.description
@@ -283,9 +217,9 @@ class ToolSchema(Generic[ToolFnT]):
 
             field_definitions[param.name] = (param_type, field_value)
 
-        TempModel = create_model("TempModel", **cast(dict[str, Any], field_definitions))
+        TempModel = create_model("TempModel", **field_definitions)
 
-        schema = cast(ModelJsonSchema, TempModel.model_json_schema())
+        schema = TempModel.model_json_schema()
 
         parameters = ToolParameterSchema(
             properties=schema.get("properties", {}),
@@ -295,13 +229,11 @@ class ToolSchema(Generic[ToolFnT]):
         if "$defs" in schema:
             parameters.defs = schema["$defs"]
 
-        return cls(
-            fn=cast(ToolFnT, fn),
-            name=name,
-            description=description,
-            parameters=parameters,
-            strict=strict,
-        )
+        self.fn = fn
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.strict = strict
 
     def can_execute(self, tool_call: ToolCall) -> bool:
         """Check if a `ToolCall` can be executed by tools with this `ToolSchema`.

mirascope/llm/tools/toolkit.py

@@ -60,7 +60,7 @@ class BaseToolkit(Generic[ToolSchemaT]):
         """
         tool = self.tools_dict.get(tool_call.name, None)
         if not tool:
-            raise ToolNotFoundError(tool_call.name)
+            raise ToolNotFoundError(f"Tool not found in toolkit: {tool_call.name}")
         return tool
 
 
@@ -75,14 +75,12 @@ class Toolkit(BaseToolkit[Tool]):
 
         Returns:
             The output from executing the `Tool`.
+
+        Raises:
+            ToolNotFoundError: If the requested tool is not found.
         """
-        try:
-            tool = self.get(tool_call)
-            return tool.execute(tool_call)
-        except ToolNotFoundError as e:
-            return ToolOutput(
-                id=tool_call.id, result=str(e), error=e, name=tool_call.name
-            )
+        tool = self.get(tool_call)
+        return tool.execute(tool_call)
 
 
 class AsyncToolkit(BaseToolkit[AsyncTool]):
@@ -96,14 +94,12 @@ class AsyncToolkit(BaseToolkit[AsyncTool]):
 
         Returns:
             The output from executing the `AsyncTool`.
+
+        Raises:
+            ToolNotFoundError: If the requested tool is not found.
         """
-        try:
-            tool = self.get(tool_call)
-            return await tool.execute(tool_call)
-        except ToolNotFoundError as e:
-            return ToolOutput(
-                id=tool_call.id, result=str(e), error=e, name=tool_call.name
-            )
+        tool = self.get(tool_call)
+        return await tool.execute(tool_call)
 
 
 class ContextToolkit(BaseToolkit[Tool | ContextTool[DepsT]], Generic[DepsT]):
@@ -118,17 +114,15 @@ class ContextToolkit(BaseToolkit[Tool | ContextTool[DepsT]], Generic[DepsT]):
 
         Returns:
             The output from executing the `ContextTool`.
+
+        Raises:
+            ToolNotFoundError: If the requested tool is not found.
         """
-        try:
-            tool = self.get(tool_call)
-            if isinstance(tool, ContextTool):
-                return tool.execute(ctx, tool_call)
-            else:
-                return tool.execute(tool_call)
-        except ToolNotFoundError as e:
-            return ToolOutput(
-                id=tool_call.id, result=str(e), error=e, name=tool_call.name
-            )
+        tool = self.get(tool_call)
+        if isinstance(tool, ContextTool):
+            return tool.execute(ctx, tool_call)
+        else:
+            return tool.execute(tool_call)
 
 
 class AsyncContextToolkit(
@@ -147,14 +141,12 @@ class AsyncContextToolkit(
 
         Returns:
             The output from executing the `AsyncContextTool`.
+
+        Raises:
+            ToolNotFoundError: If the requested tool is not found.
         """
-        try:
-            tool = self.get(tool_call)
-            if isinstance(tool, AsyncContextTool):
-                return await tool.execute(ctx, tool_call)
-            else:
-                return await tool.execute(tool_call)
-        except ToolNotFoundError as e:
-            return ToolOutput(
-                id=tool_call.id, result=str(e), error=e, name=tool_call.name
-            )
+        tool = self.get(tool_call)
+        if isinstance(tool, AsyncContextTool):
+            return await tool.execute(ctx, tool_call)
+        else:
+            return await tool.execute(tool_call)