pydantic-ai-slim 0.0.18__py3-none-any.whl → 0.0.20__py3-none-any.whl

pydantic_ai/result.py

@@ -1,7 +1,7 @@
 from __future__ import annotations as _annotations
 
 from abc import ABC, abstractmethod
-from collections.abc import AsyncIterator, Awaitable, Callable
+from collections.abc import AsyncIterable, AsyncIterator, Awaitable, Callable
 from copy import deepcopy
 from dataclasses import dataclass, field
 from datetime import datetime
@@ -11,35 +11,49 @@ import logfire_api
 from typing_extensions import TypeVar
 
 from . import _result, _utils, exceptions, messages as _messages, models
-from .tools import AgentDeps, RunContext
+from .tools import AgentDepsT, RunContext
 from .usage import Usage, UsageLimits
 
-__all__ = 'ResultData', 'ResultValidatorFunc', 'RunResult', 'StreamedRunResult'
+__all__ = 'ResultDataT', 'ResultDataT_inv', 'ResultValidatorFunc', 'RunResult', 'StreamedRunResult'
 
 
-ResultData = TypeVar('ResultData', default=str)
-"""Type variable for the result data of a run."""
+T = TypeVar('T')
+"""An invariant TypeVar."""
+ResultDataT_inv = TypeVar('ResultDataT_inv', default=str)
+"""
+An invariant type variable for the result data of a model.
+
+We need to use an invariant typevar for `ResultValidator` and `ResultValidatorFunc` because the result data type is used
+in both the input and output of a `ResultValidatorFunc`. This can theoretically lead to some issues assuming that types
+possessing ResultValidator's are covariant in the result data type, but in practice this is rarely an issue, and
+changing it would have negative consequences for the ergonomics of the library.
+
+At some point, it may make sense to change the input to ResultValidatorFunc to be `Any` or `object` as doing that would
+resolve these potential variance issues.
+"""
+ResultDataT = TypeVar('ResultDataT', default=str, covariant=True)
+"""Covariant type variable for the result data type of a run."""
 
 ResultValidatorFunc = Union[
-    Callable[[RunContext[AgentDeps], ResultData], ResultData],
-    Callable[[RunContext[AgentDeps], ResultData], Awaitable[ResultData]],
-    Callable[[ResultData], ResultData],
-    Callable[[ResultData], Awaitable[ResultData]],
+    Callable[[RunContext[AgentDepsT], ResultDataT_inv], ResultDataT_inv],
+    Callable[[RunContext[AgentDepsT], ResultDataT_inv], Awaitable[ResultDataT_inv]],
+    Callable[[ResultDataT_inv], ResultDataT_inv],
+    Callable[[ResultDataT_inv], Awaitable[ResultDataT_inv]],
 ]
 """
-A function that always takes `ResultData` and returns `ResultData` and:
+A function that always takes and returns the same type of data (which is the result type of an agent run), and:
 
 * may or may not take [`RunContext`][pydantic_ai.tools.RunContext] as a first argument
 * may or may not be async
 
-Usage `ResultValidatorFunc[AgentDeps, ResultData]`.
+Usage `ResultValidatorFunc[AgentDeps, T]`.
 """
 
 _logfire = logfire_api.Logfire(otel_scope='pydantic-ai')
 
 
 @dataclass
-class _BaseRunResult(ABC, Generic[ResultData]):
+class _BaseRunResult(ABC, Generic[ResultDataT]):
     """Base type for results.
 
     You should not import or use this type directly, instead use its subclasses `RunResult` and `StreamedRunResult`.
@@ -119,10 +133,10 @@ class _BaseRunResult(ABC, Generic[ResultData]):
 
 
 @dataclass
-class RunResult(_BaseRunResult[ResultData]):
+class RunResult(_BaseRunResult[ResultDataT]):
     """Result of a non-streamed run."""
 
-    data: ResultData
+    data: ResultDataT
     """Data from the final response in the run."""
     _result_tool_name: str | None
     _usage: Usage
@@ -165,14 +179,14 @@ class RunResult(_BaseRunResult[ResultData]):
 
 
 @dataclass
-class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultData]):
+class StreamedRunResult(_BaseRunResult[ResultDataT], Generic[AgentDepsT, ResultDataT]):
     """Result of a streamed run that returns structured data via a tool call."""
 
     _usage_limits: UsageLimits | None
-    _stream_response: models.EitherStreamedResponse
-    _result_schema: _result.ResultSchema[ResultData] | None
-    _run_ctx: RunContext[AgentDeps]
-    _result_validators: list[_result.ResultValidator[AgentDeps, ResultData]]
+    _stream_response: models.StreamedResponse
+    _result_schema: _result.ResultSchema[ResultDataT] | None
+    _run_ctx: RunContext[AgentDepsT]
+    _result_validators: list[_result.ResultValidator[AgentDepsT, ResultDataT]]
     _result_tool_name: str | None
     _on_complete: Callable[[], Awaitable[None]]
     is_complete: bool = field(default=False, init=False)
@@ -185,7 +199,7 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
     [`get_data`][pydantic_ai.result.StreamedRunResult.get_data] completes.
     """
 
-    async def stream(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[ResultData]:
+    async def stream(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[ResultDataT]:
         """Stream the response as an async iterable.
 
         The pydantic validator for structured data will be called in
@@ -200,20 +214,13 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
         Returns:
             An async iterable of the response data.
         """
-        if isinstance(self._stream_response, models.StreamTextResponse):
-            async for text in self.stream_text(debounce_by=debounce_by):
-                yield cast(ResultData, text)
-        else:
-            async for structured_message, is_last in self.stream_structured(debounce_by=debounce_by):
-                yield await self.validate_structured_result(structured_message, allow_partial=not is_last)
+        async for structured_message, is_last in self.stream_structured(debounce_by=debounce_by):
+            result = await self.validate_structured_result(structured_message, allow_partial=not is_last)
+            yield result
 
     async def stream_text(self, *, delta: bool = False, debounce_by: float | None = 0.1) -> AsyncIterator[str]:
         """Stream the text result as an async iterable.
 
-        !!! note
-            This method will fail if the response is structured,
-            e.g. if [`is_structured`][pydantic_ai.result.StreamedRunResult.is_structured] returns `True`.
-
         !!! note
             Result validators will NOT be called on the text result if `delta=True`.
 
@@ -224,54 +231,70 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
                 Debouncing is particularly important for long structured responses to reduce the overhead of
                 performing validation as each token is received.
         """
+        if self._result_schema and not self._result_schema.allow_text_result:
+            raise exceptions.UserError('stream_text() can only be used with text responses')
+
         usage_checking_stream = _get_usage_checking_stream_response(
             self._stream_response, self._usage_limits, self.usage
         )
 
+        # Define a "merged" version of the iterator that will yield items that have already been retrieved
+        # and items that we receive while streaming. We define a dedicated async iterator for this so we can
+        # pass the combined stream to the group_by_temporal function within `_stream_text_deltas` below.
+        async def _stream_text_deltas_ungrouped() -> AsyncIterator[tuple[str, int]]:
+            # if the response currently has any parts with content, yield those before streaming
+            msg = self._stream_response.get()
+            for i, part in enumerate(msg.parts):
+                if isinstance(part, _messages.TextPart) and part.content:
+                    yield part.content, i
+
+            async for event in usage_checking_stream:
+                if (
+                    isinstance(event, _messages.PartStartEvent)
+                    and isinstance(event.part, _messages.TextPart)
+                    and event.part.content
+                ):
+                    yield event.part.content, event.index
+                elif (
+                    isinstance(event, _messages.PartDeltaEvent)
+                    and isinstance(event.delta, _messages.TextPartDelta)
+                    and event.delta.content_delta
+                ):
+                    yield event.delta.content_delta, event.index
+
+        async def _stream_text_deltas() -> AsyncIterator[str]:
+            async with _utils.group_by_temporal(_stream_text_deltas_ungrouped(), debounce_by) as group_iter:
+                async for items in group_iter:
+                    yield ''.join([content for content, _ in items])
+
         with _logfire.span('response stream text') as lf_span:
-            if isinstance(self._stream_response, models.StreamStructuredResponse):
-                raise exceptions.UserError('stream_text() can only be used with text responses')
             if delta:
-                async with _utils.group_by_temporal(usage_checking_stream, debounce_by) as group_iter:
-                    async for _ in group_iter:
-                        yield ''.join(self._stream_response.get())
-                final_delta = ''.join(self._stream_response.get(final=True))
-                if final_delta:
-                    yield final_delta
+                async for text in _stream_text_deltas():
+                    yield text
             else:
                 # a quick benchmark shows it's faster to build up a string with concat when we're
                 # yielding at each step
-                chunks: list[str] = []
-                combined = ''
-                async with _utils.group_by_temporal(usage_checking_stream, debounce_by) as group_iter:
-                    async for _ in group_iter:
-                        new = False
-                        for chunk in self._stream_response.get():
-                            chunks.append(chunk)
-                            new = True
-                        if new:
-                            combined = await self._validate_text_result(''.join(chunks))
-                            yield combined
-
-                new = False
-                for chunk in self._stream_response.get(final=True):
-                    chunks.append(chunk)
-                    new = True
-                if new:
-                    combined = await self._validate_text_result(''.join(chunks))
-                    yield combined
-                lf_span.set_attribute('combined_text', combined)
-                await self._marked_completed(_messages.ModelResponse.from_text(combined))
+                deltas: list[str] = []
+                combined_validated_text = ''
+                async for text in _stream_text_deltas():
+                    deltas.append(text)
+                    combined_text = ''.join(deltas)
+                    combined_validated_text = await self._validate_text_result(combined_text)
+                    yield combined_validated_text
+
+                lf_span.set_attribute('combined_text', combined_validated_text)
+                await self._marked_completed(
+                    _messages.ModelResponse(
+                        parts=[_messages.TextPart(combined_validated_text)],
+                        model_name=self._stream_response.model_name(),
+                    )
+                )
 
     async def stream_structured(
         self, *, debounce_by: float | None = 0.1
     ) -> AsyncIterator[tuple[_messages.ModelResponse, bool]]:
         """Stream the response as an async iterable of Structured LLM Messages.
 
-        !!! note
-            This method will fail if the response is text,
-            e.g. if [`is_structured`][pydantic_ai.result.StreamedRunResult.is_structured] returns `False`.
-
         Args:
             debounce_by: by how much (if at all) to debounce/group the response chunks by. `None` means no debouncing.
                 Debouncing is particularly important for long structured responses to reduce the overhead of
@@ -285,28 +308,24 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
         )
 
         with _logfire.span('response stream structured') as lf_span:
-            if isinstance(self._stream_response, models.StreamTextResponse):
-                raise exceptions.UserError('stream_structured() can only be used with structured responses')
-            else:
-                # we should already have a message at this point, yield that first if it has any content
+            # if the message currently has any parts with content, yield before streaming
+            msg = self._stream_response.get()
+            for part in msg.parts:
+                if part.has_content():
+                    yield msg, False
+                    break
+
+            async with _utils.group_by_temporal(usage_checking_stream, debounce_by) as group_iter:
+                async for _events in group_iter:
+                    msg = self._stream_response.get()
+                    yield msg, False
                 msg = self._stream_response.get()
-                for item in msg.parts:
-                    if isinstance(item, _messages.ToolCallPart) and item.has_content():
-                        yield msg, False
-                        break
-                async with _utils.group_by_temporal(usage_checking_stream, debounce_by) as group_iter:
-                    async for _ in group_iter:
-                        msg = self._stream_response.get()
-                        for item in msg.parts:
-                            if isinstance(item, _messages.ToolCallPart) and item.has_content():
-                                yield msg, False
-                                break
-                msg = self._stream_response.get(final=True)
                 yield msg, True
+                # TODO: Should this now be `final_response` instead of `structured_response`?
                 lf_span.set_attribute('structured_response', msg)
                 await self._marked_completed(msg)
 
-    async def get_data(self) -> ResultData:
+    async def get_data(self) -> ResultDataT:
         """Stream the whole response, validate and return it."""
         usage_checking_stream = _get_usage_checking_stream_response(
             self._stream_response, self._usage_limits, self.usage
@@ -314,21 +333,9 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
 
         async for _ in usage_checking_stream:
             pass
-
-        if isinstance(self._stream_response, models.StreamTextResponse):
-            text = ''.join(self._stream_response.get(final=True))
-            text = await self._validate_text_result(text)
-            await self._marked_completed(_messages.ModelResponse.from_text(text))
-            return cast(ResultData, text)
-        else:
-            message = self._stream_response.get(final=True)
-            await self._marked_completed(message)
-            return await self.validate_structured_result(message)
-
-    @property
-    def is_structured(self) -> bool:
-        """Return whether the stream response contains structured data (as opposed to text)."""
-        return isinstance(self._stream_response, models.StreamStructuredResponse)
+        message = self._stream_response.get()
+        await self._marked_completed(message)
+        return await self.validate_structured_result(message)
 
     def usage(self) -> Usage:
         """Return the usage of the whole run.
@@ -344,27 +351,36 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
 
     async def validate_structured_result(
         self, message: _messages.ModelResponse, *, allow_partial: bool = False
-    ) -> ResultData:
+    ) -> ResultDataT:
         """Validate a structured result message."""
-        assert self._result_schema is not None, 'Expected _result_schema to not be None'
-        assert self._result_tool_name is not None, 'Expected _result_tool_name to not be None'
-        match = self._result_schema.find_named_tool(message.parts, self._result_tool_name)
-        if match is None:
-            raise exceptions.UnexpectedModelBehavior(
-                f'Invalid message, unable to find tool: {self._result_schema.tool_names()}'
-            )
-
-        call, result_tool = match
-        result_data = result_tool.validate(call, allow_partial=allow_partial, wrap_validation_errors=False)
-
-        for validator in self._result_validators:
-            result_data = await validator.validate(result_data, call, self._run_ctx)
-        return result_data
+        if self._result_schema is not None and self._result_tool_name is not None:
+            match = self._result_schema.find_named_tool(message.parts, self._result_tool_name)
+            if match is None:
+                raise exceptions.UnexpectedModelBehavior(
+                    f'Invalid response, unable to find tool: {self._result_schema.tool_names()}'
+                )
+
+            call, result_tool = match
+            result_data = result_tool.validate(call, allow_partial=allow_partial, wrap_validation_errors=False)
+
+            for validator in self._result_validators:
+                result_data = await validator.validate(result_data, call, self._run_ctx)
+            return result_data
+        else:
+            text = '\n\n'.join(x.content for x in message.parts if isinstance(x, _messages.TextPart))
+            for validator in self._result_validators:
+                text = await validator.validate(
+                    text,
+                    None,
+                    self._run_ctx,
+                )
+            # Since there is no result tool, we can assume that str is compatible with ResultDataT
+            return cast(ResultDataT, text)
 
     async def _validate_text_result(self, text: str) -> str:
         for validator in self._result_validators:
-            text = await validator.validate(  # pyright: ignore[reportAssignmentType]
-                text,  # pyright: ignore[reportArgumentType]
+            text = await validator.validate(
+                text,
                 None,
                 self._run_ctx,
             )
@@ -377,8 +393,10 @@ class StreamedRunResult(_BaseRunResult[ResultData], Generic[AgentDeps, ResultDat
 
 
 def _get_usage_checking_stream_response(
-    stream_response: AsyncIterator[ResultData], limits: UsageLimits | None, get_usage: Callable[[], Usage]
-) -> AsyncIterator[ResultData]:
+    stream_response: AsyncIterable[_messages.ModelResponseStreamEvent],
+    limits: UsageLimits | None,
+    get_usage: Callable[[], Usage],
+) -> AsyncIterable[_messages.ModelResponseStreamEvent]:
     if limits is not None and limits.has_token_limits():
 
         async def _usage_checking_iterator():

pydantic_ai/settings.py

@@ -12,7 +12,8 @@ if TYPE_CHECKING:
 class ModelSettings(TypedDict, total=False):
     """Settings to configure an LLM.
 
-    Here we include only settings which apply to multiple models / model providers.
+    Here we include only settings which apply to multiple models / model providers,
+    though not all of these settings are supported by all models.
     """
 
     max_tokens: int
@@ -24,6 +25,8 @@ class ModelSettings(TypedDict, total=False):
     * Anthropic
     * OpenAI
     * Groq
+    * Cohere
+    * Mistral
     """
 
     temperature: float
@@ -40,6 +43,8 @@ class ModelSettings(TypedDict, total=False):
     * Anthropic
     * OpenAI
     * Groq
+    * Cohere
+    * Mistral
     """
 
     top_p: float
@@ -55,6 +60,8 @@ class ModelSettings(TypedDict, total=False):
     * Anthropic
     * OpenAI
     * Groq
+    * Cohere
+    * Mistral
     """
 
     timeout: float | Timeout
@@ -66,6 +73,16 @@ class ModelSettings(TypedDict, total=False):
     * Anthropic
     * OpenAI
     * Groq
+    * Mistral
+    """
+
+    parallel_tool_calls: bool
+    """Whether to allow parallel tool calls.
+
+    Supported by:
+    * OpenAI
+    * Groq
+    * Anthropic
     """
 
 

pydantic_ai/tools.py

@@ -4,7 +4,7 @@ import dataclasses
 import inspect
 from collections.abc import Awaitable
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Callable, Generic, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, Generic, Literal, Union, cast
 
 from pydantic import ValidationError
 from pydantic_core import SchemaValidator
@@ -17,7 +17,8 @@ if TYPE_CHECKING:
     from .result import Usage
 
 __all__ = (
-    'AgentDeps',
+    'AgentDepsT',
+    'DocstringFormat',
     'RunContext',
     'SystemPromptFunc',
     'ToolFuncContext',
@@ -30,15 +31,15 @@ __all__ = (
     'ToolDefinition',
 )
 
-AgentDeps = TypeVar('AgentDeps', default=None)
+AgentDepsT = TypeVar('AgentDepsT', default=None, contravariant=True)
 """Type variable for agent dependencies."""
 
 
 @dataclasses.dataclass
-class RunContext(Generic[AgentDeps]):
+class RunContext(Generic[AgentDepsT]):
     """Information about the current call."""
 
-    deps: AgentDeps
+    deps: AgentDepsT
     """Dependencies for the agent."""
     model: models.Model
     """The model used in this run."""
@@ -57,7 +58,7 @@ class RunContext(Generic[AgentDeps]):
 
     def replace_with(
         self, retry: int | None = None, tool_name: str | None | _utils.Unset = _utils.UNSET
-    ) -> RunContext[AgentDeps]:
+    ) -> RunContext[AgentDepsT]:
         # Create a new `RunContext` a new `retry` value and `tool_name`.
         kwargs = {}
         if retry is not None:
@@ -71,8 +72,8 @@ ToolParams = ParamSpec('ToolParams', default=...)
 """Retrieval function param spec."""
 
 SystemPromptFunc = Union[
-    Callable[[RunContext[AgentDeps]], str],
-    Callable[[RunContext[AgentDeps]], Awaitable[str]],
+    Callable[[RunContext[AgentDepsT]], str],
+    Callable[[RunContext[AgentDepsT]], Awaitable[str]],
     Callable[[], str],
     Callable[[], Awaitable[str]],
 ]
@@ -81,7 +82,7 @@ SystemPromptFunc = Union[
 Usage `SystemPromptFunc[AgentDeps]`.
 """
 
-ToolFuncContext = Callable[Concatenate[RunContext[AgentDeps], ToolParams], Any]
+ToolFuncContext = Callable[Concatenate[RunContext[AgentDepsT], ToolParams], Any]
 """A tool function that takes `RunContext` as the first argument.
 
 Usage `ToolContextFunc[AgentDeps, ToolParams]`.
@@ -91,7 +92,7 @@ ToolFuncPlain = Callable[ToolParams, Any]
 
 Usage `ToolPlainFunc[ToolParams]`.
 """
-ToolFuncEither = Union[ToolFuncContext[AgentDeps, ToolParams], ToolFuncPlain[ToolParams]]
+ToolFuncEither = Union[ToolFuncContext[AgentDepsT, ToolParams], ToolFuncPlain[ToolParams]]
 """Either kind of tool function.
 
 This is just a union of [`ToolFuncContext`][pydantic_ai.tools.ToolFuncContext] and
@@ -99,14 +100,14 @@ This is just a union of [`ToolFuncContext`][pydantic_ai.tools.ToolFuncContext] a
 
 Usage `ToolFuncEither[AgentDeps, ToolParams]`.
 """
-ToolPrepareFunc: TypeAlias = 'Callable[[RunContext[AgentDeps], ToolDefinition], Awaitable[ToolDefinition | None]]'
+ToolPrepareFunc: TypeAlias = 'Callable[[RunContext[AgentDepsT], ToolDefinition], Awaitable[ToolDefinition | None]]'
 """Definition of a function that can prepare a tool definition at call time.
 
 See [tool docs](../tools.md#tool-prepare) for more information.
 
 Example — here `only_if_42` is valid as a `ToolPrepareFunc`:
 
-```python {lint="not-imports"}
+```python {noqa="I001"}
 from typing import Union
 
 from pydantic_ai import RunContext, Tool
@@ -127,19 +128,30 @@ hitchhiker = Tool(hitchhiker, prepare=only_if_42)
 Usage `ToolPrepareFunc[AgentDeps]`.
 """
 
+DocstringFormat = Literal['google', 'numpy', 'sphinx', 'auto']
+"""Supported docstring formats.
+
+* `'google'` — [Google-style](https://google.github.io/styleguide/pyguide.html#381-docstrings) docstrings.
+* `'numpy'` — [Numpy-style](https://numpydoc.readthedocs.io/en/latest/format.html) docstrings.
+* `'sphinx'` — [Sphinx-style](https://sphinx-rtd-tutorial.readthedocs.io/en/latest/docstrings.html#the-sphinx-docstring-format) docstrings.
+* `'auto'` — Automatically infer the format based on the structure of the docstring.
+"""
+
 A = TypeVar('A')
 
 
 @dataclass(init=False)
-class Tool(Generic[AgentDeps]):
+class Tool(Generic[AgentDepsT]):
     """A tool function for an agent."""
 
-    function: ToolFuncEither[AgentDeps]
+    function: ToolFuncEither[AgentDepsT]
     takes_ctx: bool
     max_retries: int | None
     name: str
     description: str
-    prepare: ToolPrepareFunc[AgentDeps] | None
+    prepare: ToolPrepareFunc[AgentDepsT] | None
+    docstring_format: DocstringFormat
+    require_parameter_descriptions: bool
     _is_async: bool = field(init=False)
     _single_arg_name: str | None = field(init=False)
     _positional_fields: list[str] = field(init=False)
@@ -150,19 +162,21 @@ class Tool(Generic[AgentDeps]):
 
     def __init__(
         self,
-        function: ToolFuncEither[AgentDeps],
+        function: ToolFuncEither[AgentDepsT],
         *,
         takes_ctx: bool | None = None,
         max_retries: int | None = None,
         name: str | None = None,
         description: str | None = None,
-        prepare: ToolPrepareFunc[AgentDeps] | None = None,
+        prepare: ToolPrepareFunc[AgentDepsT] | None = None,
+        docstring_format: DocstringFormat = 'auto',
+        require_parameter_descriptions: bool = False,
     ):
         """Create a new tool instance.
 
         Example usage:
 
-        ```python {lint="not-imports"}
+        ```python {noqa="I001"}
         from pydantic_ai import Agent, RunContext, Tool
 
         async def my_tool(ctx: RunContext[int], x: int, y: int) -> str:
@@ -173,7 +187,7 @@ class Tool(Generic[AgentDeps]):
 
         or with a custom prepare method:
 
-        ```python {lint="not-imports"}
+        ```python {noqa="I001"}
         from typing import Union
 
         from pydantic_ai import Agent, RunContext, Tool
@@ -203,17 +217,22 @@ class Tool(Generic[AgentDeps]):
             prepare: custom method to prepare the tool definition for each step, return `None` to omit this
                 tool from a given step. This is useful if you want to customise a tool at call time,
                 or omit it completely from a step. See [`ToolPrepareFunc`][pydantic_ai.tools.ToolPrepareFunc].
+            docstring_format: The format of the docstring, see [`DocstringFormat`][pydantic_ai.tools.DocstringFormat].
+                Defaults to `'auto'`, such that the format is inferred from the structure of the docstring.
+            require_parameter_descriptions: If True, raise an error if a parameter description is missing. Defaults to False.
         """
         if takes_ctx is None:
             takes_ctx = _pydantic.takes_ctx(function)
 
-        f = _pydantic.function_schema(function, takes_ctx)
+        f = _pydantic.function_schema(function, takes_ctx, docstring_format, require_parameter_descriptions)
         self.function = function
         self.takes_ctx = takes_ctx
         self.max_retries = max_retries
         self.name = name or function.__name__
         self.description = description or f['description']
         self.prepare = prepare
+        self.docstring_format = docstring_format
+        self.require_parameter_descriptions = require_parameter_descriptions
         self._is_async = inspect.iscoroutinefunction(self.function)
         self._single_arg_name = f['single_arg_name']
         self._positional_fields = f['positional_fields']
@@ -221,7 +240,7 @@ class Tool(Generic[AgentDeps]):
         self._validator = f['validator']
         self._parameters_json_schema = f['json_schema']
 
-    async def prepare_tool_def(self, ctx: RunContext[AgentDeps]) -> ToolDefinition | None:
+    async def prepare_tool_def(self, ctx: RunContext[AgentDepsT]) -> ToolDefinition | None:
         """Get the tool definition.
 
         By default, this method creates a tool definition, then either returns it, or calls `self.prepare`
@@ -241,7 +260,7 @@ class Tool(Generic[AgentDeps]):
             return tool_def
 
     async def run(
-        self, message: _messages.ToolCallPart, run_context: RunContext[AgentDeps]
+        self, message: _messages.ToolCallPart, run_context: RunContext[AgentDepsT]
     ) -> _messages.ModelRequestPart:
         """Run the tool function asynchronously."""
         try:
@@ -274,7 +293,7 @@ class Tool(Generic[AgentDeps]):
         self,
         args_dict: dict[str, Any],
         message: _messages.ToolCallPart,
-        run_context: RunContext[AgentDeps],
+        run_context: RunContext[AgentDepsT],
     ) -> tuple[list[Any], dict[str, Any]]:
         if self._single_arg_name:
             args_dict = {self._single_arg_name: args_dict}

{pydantic_ai_slim-0.0.18.dist-info → pydantic_ai_slim-0.0.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.18
+Version: 0.0.20
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -26,11 +26,15 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Requires-Dist: eval-type-backport>=0.2.0
 Requires-Dist: griffe>=1.3.2
-Requires-Dist: httpx>=0.27.2
+Requires-Dist: httpx>=0.27
 Requires-Dist: logfire-api>=1.2.0
 Requires-Dist: pydantic>=2.10
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.40.0; extra == 'anthropic'
+Provides-Extra: cohere
+Requires-Dist: cohere>=5.13.11; extra == 'cohere'
+Provides-Extra: graph
+Requires-Dist: pydantic-graph==0.0.20; extra == 'graph'
 Provides-Extra: groq
 Requires-Dist: groq>=0.12.0; extra == 'groq'
 Provides-Extra: logfire
@@ -38,7 +42,7 @@ Requires-Dist: logfire>=2.3; extra == 'logfire'
 Provides-Extra: mistral
 Requires-Dist: mistralai>=1.2.5; extra == 'mistral'
 Provides-Extra: openai
-Requires-Dist: openai>=1.54.3; extra == 'openai'
+Requires-Dist: openai>=1.59.0; extra == 'openai'
 Provides-Extra: vertexai
 Requires-Dist: google-auth>=2.36.0; extra == 'vertexai'
 Requires-Dist: requests>=2.32.3; extra == 'vertexai'