pydantic-ai-slim 0.0.10__py3-none-any.whl → 0.0.12__py3-none-any.whl

pydantic_ai/_pydantic.py

@@ -17,10 +17,10 @@ from pydantic.plugin._schema_validator import create_schema_validator
 from pydantic_core import SchemaValidator, core_schema
 
 from ._griffe import doc_descriptions
-from ._utils import ObjectJsonSchema, check_object_json_schema, is_model_like
+from ._utils import check_object_json_schema, is_model_like
 
 if TYPE_CHECKING:
-    pass
+    from .tools import ObjectJsonSchema
 
 
 __all__ = 'function_schema', 'LazyTypeAdapter'
@@ -168,11 +168,13 @@ def takes_ctx(function: Callable[..., Any]) -> bool:
     """
     sig = signature(function)
     try:
-        _, first_param = next(iter(sig.parameters.items()))
+        first_param_name = next(iter(sig.parameters.keys()))
     except StopIteration:
         return False
     else:
-        return first_param.annotation is not sig.empty and _is_call_ctx(first_param.annotation)
+        type_hints = _typing_extra.get_function_type_hints(function)
+        annotation = type_hints[first_param_name]
+        return annotation is not sig.empty and _is_call_ctx(annotation)
 
 
 def _build_schema(

pydantic_ai/_result.py

@@ -14,7 +14,7 @@ from . import _utils, messages
 from .exceptions import ModelRetry
 from .messages import ModelStructuredResponse, ToolCall
 from .result import ResultData
-from .tools import AgentDeps, ResultValidatorFunc, RunContext
+from .tools import AgentDeps, ResultValidatorFunc, RunContext, ToolDefinition
 
 
 @dataclass
@@ -94,10 +94,7 @@ class ResultSchema(Generic[ResultData]):
             allow_text_result = False
 
         def _build_tool(a: Any, tool_name_: str, multiple: bool) -> ResultTool[ResultData]:
-            return cast(
-                ResultTool[ResultData],
-                ResultTool.build(a, tool_name_, description, multiple),  # pyright: ignore[reportUnknownMemberType]
-            )
+            return cast(ResultTool[ResultData], ResultTool(a, tool_name_, description, multiple))
 
         tools: dict[str, ResultTool[ResultData]] = {}
         if args := get_union_args(response_type):
@@ -121,38 +118,38 @@ class ResultSchema(Generic[ResultData]):
         """Return the names of the tools."""
         return list(self.tools.keys())
 
+    def tool_defs(self) -> list[ToolDefinition]:
+        """Get tool definitions to register with the model."""
+        return [t.tool_def for t in self.tools.values()]
+
 
 DEFAULT_DESCRIPTION = 'The final response which ends this conversation'
 
 
-@dataclass
+@dataclass(init=False)
 class ResultTool(Generic[ResultData]):
-    name: str
-    description: str
+    tool_def: ToolDefinition
     type_adapter: TypeAdapter[Any]
-    json_schema: _utils.ObjectJsonSchema
-    outer_typed_dict_key: str | None
 
-    @classmethod
-    def build(cls, response_type: type[ResultData], name: str, description: str | None, multiple: bool) -> Self | None:
+    def __init__(self, response_type: type[ResultData], name: str, description: str | None, multiple: bool):
         """Build a ResultTool dataclass from a response type."""
         assert response_type is not str, 'ResultTool does not support str as a response type'
 
         if _utils.is_model_like(response_type):
-            type_adapter = TypeAdapter(response_type)
+            self.type_adapter = TypeAdapter(response_type)
             outer_typed_dict_key: str | None = None
             # noinspection PyArgumentList
-            json_schema = _utils.check_object_json_schema(type_adapter.json_schema())
+            parameters_json_schema = _utils.check_object_json_schema(self.type_adapter.json_schema())
         else:
             response_data_typed_dict = TypedDict('response_data_typed_dict', {'response': response_type})  # noqa
-            type_adapter = TypeAdapter(response_data_typed_dict)
+            self.type_adapter = TypeAdapter(response_data_typed_dict)
             outer_typed_dict_key = 'response'
             # noinspection PyArgumentList
-            json_schema = _utils.check_object_json_schema(type_adapter.json_schema())
+            parameters_json_schema = _utils.check_object_json_schema(self.type_adapter.json_schema())
             # including `response_data_typed_dict` as a title here doesn't add anything and could confuse the LLM
-            json_schema.pop('title')
+            parameters_json_schema.pop('title')
 
-        if json_schema_description := json_schema.pop('description', None):
+        if json_schema_description := parameters_json_schema.pop('description', None):
             if description is None:
                 tool_description = json_schema_description
             else:
@@ -162,11 +159,10 @@ class ResultTool(Generic[ResultData]):
             if multiple:
                 tool_description = f'{union_arg_name(response_type)}: {tool_description}'
 
-        return cls(
+        self.tool_def = ToolDefinition(
             name=name,
             description=tool_description,
-            type_adapter=type_adapter,
-            json_schema=json_schema,
+            parameters_json_schema=parameters_json_schema,
             outer_typed_dict_key=outer_typed_dict_key,
         )
 
@@ -204,7 +200,7 @@ class ResultTool(Generic[ResultData]):
             else:
                 raise
         else:
-            if k := self.outer_typed_dict_key:
+            if k := self.tool_def.outer_typed_dict_key:
                 result = result[k]
             return result
 

pydantic_ai/_system_prompt.py

@@ -21,7 +21,7 @@ class SystemPromptRunner(Generic[AgentDeps]):
 
     async def run(self, deps: AgentDeps) -> str:
         if self._takes_ctx:
-            args = (RunContext(deps, 0, None),)
+            args = (RunContext(deps, 0),)
         else:
             args = ()
 

pydantic_ai/_utils.py

@@ -8,12 +8,15 @@ from dataclasses import dataclass, is_dataclass
 from datetime import datetime, timezone
 from functools import partial
 from types import GenericAlias
-from typing import Any, Callable, Generic, TypeVar, Union, cast, overload
+from typing import TYPE_CHECKING, Any, Callable, Generic, TypeVar, Union, cast, overload
 
 from pydantic import BaseModel
 from pydantic.json_schema import JsonSchemaValue
 from typing_extensions import ParamSpec, TypeAlias, TypeGuard, is_typeddict
 
+if TYPE_CHECKING:
+    from .tools import ObjectJsonSchema
+
 _P = ParamSpec('_P')
 _R = TypeVar('_R')
 
@@ -39,10 +42,6 @@ def is_model_like(type_: Any) -> bool:
     )
 
 
-# With PEP-728 this should be a TypedDict with `type: Literal['object']`, and `extra_items=Any`
-ObjectJsonSchema: TypeAlias = dict[str, Any]
-
-
 def check_object_json_schema(schema: JsonSchemaValue) -> ObjectJsonSchema:
     from .exceptions import UserError
 
@@ -127,6 +126,12 @@ class Either(Generic[Left, Right]):
     def whichever(self) -> Left | Right:
         return self._left.value if self._left is not None else self.right
 
+    def __repr__(self):
+        if left := self._left:
+            return f'Either(left={left.value!r})'
+        else:
+            return f'Either(right={self.right!r})'
+
 
 @asynccontextmanager
 async def group_by_temporal(
@@ -218,7 +223,7 @@ async def group_by_temporal(
 
     try:
         yield async_iter_groups()
-    finally:
+    finally:  # pragma: no cover
         # after iteration if a tasks still exists, cancel it, this will only happen if an error occurred
         if task:
             task.cancel('Cancelling due to error in iterator')