pydantic-ai-slim 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

pydantic_ai/_pydantic.py

@@ -8,7 +8,7 @@ from __future__ import annotations as _annotations
 from inspect import Parameter, signature
 from typing import TYPE_CHECKING, Any, Callable, TypedDict, cast, get_origin
 
-from pydantic import ConfigDict, TypeAdapter
+from pydantic import ConfigDict
 from pydantic._internal import _decorators, _generate_schema, _typing_extra
 from pydantic._internal._config import ConfigWrapper
 from pydantic.fields import FieldInfo
@@ -17,13 +17,13 @@ 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'
+__all__ = ('function_schema',)
 
 
 class FunctionSchema(TypedDict):
@@ -138,14 +138,14 @@ def function_schema(function: Callable[..., Any], takes_ctx: bool) -> FunctionSc
     json_schema = GenerateJsonSchema().generate(schema)
 
     # workaround for https://github.com/pydantic/pydantic/issues/10785
-    # if we build a custom TypeDict schema (matches when `single_arg_name` is None), we manually set
+    # if we build a custom TypeDict schema (matches when `single_arg_name is None`), we manually set
     # `additionalProperties` in the JSON Schema
     if single_arg_name is None:
         json_schema['additionalProperties'] = bool(var_kwargs_schema)
-
-    # instead of passing `description` through in core_schema, we just add it here
-    if description:
-        json_schema = {'description': description} | json_schema
+    elif not description:
+        # if the tool description is not set, and we have a single parameter, take the description from that
+        # and set it on the tool
+        description = json_schema.pop('description', None)
 
     return FunctionSchema(
         description=description,
@@ -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(
@@ -212,21 +214,3 @@ def _is_call_ctx(annotation: Any) -> bool:
     return annotation is RunContext or (
         _typing_extra.is_generic_alias(annotation) and get_origin(annotation) is RunContext
     )
-
-
-if TYPE_CHECKING:
-    LazyTypeAdapter = TypeAdapter
-else:
-
-    class LazyTypeAdapter:
-        __slots__ = '_args', '_kwargs', '_type_adapter'
-
-        def __init__(self, *args, **kwargs):
-            self._args = args
-            self._kwargs = kwargs
-            self._type_adapter = None
-
-        def __getattr__(self, item):
-            if self._type_adapter is None:
-                self._type_adapter = TypeAdapter(*self._args, **self._kwargs)
-            return getattr(self._type_adapter, item)

pydantic_ai/_result.py

@@ -3,18 +3,17 @@ from __future__ import annotations as _annotations
 import inspect
 import sys
 import types
-from collections.abc import Awaitable
+from collections.abc import Awaitable, Iterable
 from dataclasses import dataclass, field
 from typing import Any, Callable, Generic, Literal, Union, cast, get_args, get_origin
 
 from pydantic import TypeAdapter, ValidationError
 from typing_extensions import Self, TypeAliasType, TypedDict
 
-from . import _utils, messages
+from . import _utils, messages as _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
@@ -28,7 +27,12 @@ class ResultValidator(Generic[AgentDeps, ResultData]):
         self._is_async = inspect.iscoroutinefunction(self.function)
 
     async def validate(
-        self, result: ResultData, deps: AgentDeps, retry: int, tool_call: messages.ToolCall | None
+        self,
+        result: ResultData,
+        deps: AgentDeps,
+        retry: int,
+        tool_call: _messages.ToolCallPart | None,
+        messages: list[_messages.ModelMessage],
     ) -> ResultData:
         """Validate a result but calling the function.
 
@@ -37,12 +41,13 @@ class ResultValidator(Generic[AgentDeps, ResultData]):
             deps: The agent dependencies.
             retry: The current retry number.
             tool_call: The original tool call message, `None` if there was no tool call.
+            messages: The messages exchanged so far in the conversation.
 
         Returns:
             Result of either the validated result data (ok) or a retry message (Err).
         """
         if self._takes_ctx:
-            args = RunContext(deps, retry, tool_call.tool_name if tool_call else None), result
+            args = RunContext(deps, retry, messages, tool_call.tool_name if tool_call else None), result
         else:
             args = (result,)
 
@@ -54,10 +59,10 @@ class ResultValidator(Generic[AgentDeps, ResultData]):
                 function = cast(Callable[[Any], ResultData], self.function)
                 result_data = await _utils.run_in_executor(function, *args)
         except ModelRetry as r:
-            m = messages.RetryPrompt(content=r.message)
+            m = _messages.RetryPromptPart(content=r.message)
             if tool_call is not None:
                 m.tool_name = tool_call.tool_name
-                m.tool_id = tool_call.tool_id
+                m.tool_call_id = tool_call.tool_call_id
             raise ToolRetryError(m) from r
         else:
             return result_data
@@ -66,7 +71,7 @@ class ResultValidator(Generic[AgentDeps, ResultData]):
 class ToolRetryError(Exception):
     """Internal exception used to signal a `ToolRetry` message should be returned to the LLM."""
 
-    def __init__(self, tool_retry: messages.RetryPrompt):
+    def __init__(self, tool_retry: _messages.RetryPromptPart):
         self.tool_retry = tool_retry
         super().__init__()
 
@@ -94,10 +99,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):
@@ -111,48 +113,61 @@ class ResultSchema(Generic[ResultData]):
 
         return cls(tools=tools, allow_text_result=allow_text_result)
 
-    def find_tool(self, message: ModelStructuredResponse) -> tuple[ToolCall, ResultTool[ResultData]] | None:
+    def find_named_tool(
+        self, parts: Iterable[_messages.ModelResponsePart], tool_name: str
+    ) -> tuple[_messages.ToolCallPart, ResultTool[ResultData]] | None:
+        """Find a tool that matches one of the calls, with a specific name."""
+        for part in parts:
+            if isinstance(part, _messages.ToolCallPart):
+                if part.tool_name == tool_name:
+                    return part, self.tools[tool_name]
+
+    def find_tool(
+        self,
+        parts: Iterable[_messages.ModelResponsePart],
+    ) -> tuple[_messages.ToolCallPart, ResultTool[ResultData]] | None:
         """Find a tool that matches one of the calls."""
-        for call in message.calls:
-            if result := self.tools.get(call.tool_name):
-                return call, result
+        for part in parts:
+            if isinstance(part, _messages.ToolCallPart):
+                if result := self.tools.get(part.tool_name):
+                    return part, result
 
     def tool_names(self) -> list[str]:
         """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,16 +177,15 @@ 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,
         )
 
     def validate(
-        self, tool_call: messages.ToolCall, allow_partial: bool = False, wrap_validation_errors: bool = True
+        self, tool_call: _messages.ToolCallPart, allow_partial: bool = False, wrap_validation_errors: bool = True
     ) -> ResultData:
         """Validate a result message.
 
@@ -185,7 +199,7 @@ class ResultTool(Generic[ResultData]):
         """
         try:
             pyd_allow_partial: Literal['off', 'trailing-strings'] = 'trailing-strings' if allow_partial else 'off'
-            if isinstance(tool_call.args, messages.ArgsJson):
+            if isinstance(tool_call.args, _messages.ArgsJson):
                 result = self.type_adapter.validate_json(
                     tool_call.args.args_json or '', experimental_allow_partial=pyd_allow_partial
                 )
@@ -195,16 +209,16 @@ class ResultTool(Generic[ResultData]):
                 )
         except ValidationError as e:
             if wrap_validation_errors:
-                m = messages.RetryPrompt(
+                m = _messages.RetryPromptPart(
                     tool_name=tool_call.tool_name,
                     content=e.errors(include_url=False),
-                    tool_id=tool_call.tool_id,
+                    tool_call_id=tool_call.tool_call_id,
                 )
                 raise ToolRetryError(m) from e
             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, [], None),)
         else:
             args = ()
 

pydantic_ai/_utils.py

@@ -8,12 +8,16 @@ 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 .messages import RetryPromptPart, ToolCallPart, ToolReturnPart
+    from .tools import ObjectJsonSchema
+
 _P = ParamSpec('_P')
 _R = TypeVar('_R')
 
@@ -39,10 +43,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
 
@@ -88,7 +88,7 @@ class Either(Generic[Left, Right]):
 
     Usage:
 
-    ```py
+    ```python
     if left_thing := either.left:
         use_left(left_thing.value)
     else:
@@ -127,6 +127,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(
@@ -141,7 +147,7 @@ async def group_by_temporal(
 
     Usage:
 
-    ```py
+    ```python
     async with group_by_temporal(yield_groups(), 0.1) as groups_iter:
         async for groups in groups_iter:
             print(groups)
@@ -218,7 +224,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')
@@ -249,3 +255,9 @@ def sync_anext(iterator: Iterator[T]) -> T:
 
 def now_utc() -> datetime:
     return datetime.now(tz=timezone.utc)
+
+
+def guard_tool_call_id(t: ToolCallPart | ToolReturnPart | RetryPromptPart, model_source: str) -> str:
+    """Type guard that checks a `tool_call_id` is not None both for static typing and runtime."""
+    assert t.tool_call_id is not None, f'{model_source} requires `tool_call_id` to be set: {t}'
+    return t.tool_call_id