pydantic-ai-slim 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

pydantic_ai/models/anthropic.py

@@ -5,9 +5,9 @@ from collections.abc import AsyncGenerator, AsyncIterable, AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from json import JSONDecodeError, loads as json_loads
 from typing import Any, Literal, Union, cast, overload
 
+from anthropic import AsyncAnthropic
 from typing_extensions import assert_never
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
@@ -41,32 +41,34 @@ from . import (
 )
 
 try:
-    from anthropic import NOT_GIVEN, APIStatusError, AsyncAnthropic, AsyncStream
-    from anthropic.types import (
-        Base64PDFSourceParam,
-        ContentBlock,
-        DocumentBlockParam,
-        ImageBlockParam,
-        Message as AnthropicMessage,
-        MessageParam,
-        MetadataParam,
-        PlainTextSourceParam,
-        RawContentBlockDeltaEvent,
-        RawContentBlockStartEvent,
-        RawContentBlockStopEvent,
-        RawMessageDeltaEvent,
-        RawMessageStartEvent,
-        RawMessageStopEvent,
-        RawMessageStreamEvent,
-        TextBlock,
-        TextBlockParam,
-        TextDelta,
-        ToolChoiceParam,
-        ToolParam,
-        ToolResultBlockParam,
-        ToolUseBlock,
-        ToolUseBlockParam,
+    from anthropic import NOT_GIVEN, APIStatusError, AsyncStream
+    from anthropic.types.beta import (
+        BetaBase64PDFBlockParam,
+        BetaBase64PDFSourceParam,
+        BetaContentBlock,
+        BetaContentBlockParam,
+        BetaImageBlockParam,
+        BetaMessage,
+        BetaMessageParam,
+        BetaMetadataParam,
+        BetaPlainTextSourceParam,
+        BetaRawContentBlockDeltaEvent,
+        BetaRawContentBlockStartEvent,
+        BetaRawContentBlockStopEvent,
+        BetaRawMessageDeltaEvent,
+        BetaRawMessageStartEvent,
+        BetaRawMessageStopEvent,
+        BetaRawMessageStreamEvent,
+        BetaTextBlock,
+        BetaTextBlockParam,
+        BetaTextDelta,
+        BetaToolChoiceParam,
+        BetaToolParam,
+        BetaToolResultBlockParam,
+        BetaToolUseBlock,
+        BetaToolUseBlockParam,
     )
+
 except ImportError as _import_error:
     raise ImportError(
         'Please install `anthropic` to use the Anthropic model, '
@@ -96,7 +98,7 @@ class AnthropicModelSettings(ModelSettings, total=False):
     ALL FIELDS MUST BE `anthropic_` PREFIXED SO YOU CAN MERGE THEM WITH OTHER MODELS.
     """
 
-    anthropic_metadata: MetadataParam
+    anthropic_metadata: BetaMetadataParam
     """An object describing metadata about the request.
 
     Contains `user_id`, an external identifier for the user who is associated with the request."""
@@ -185,7 +187,7 @@ class AnthropicModel(Model):
         stream: Literal[True],
         model_settings: AnthropicModelSettings,
         model_request_parameters: ModelRequestParameters,
-    ) -> AsyncStream[RawMessageStreamEvent]:
+    ) -> AsyncStream[BetaRawMessageStreamEvent]:
         pass
 
     @overload
@@ -195,7 +197,7 @@ class AnthropicModel(Model):
         stream: Literal[False],
         model_settings: AnthropicModelSettings,
         model_request_parameters: ModelRequestParameters,
-    ) -> AnthropicMessage:
+    ) -> BetaMessage:
         pass
 
     async def _messages_create(
@@ -204,10 +206,10 @@ class AnthropicModel(Model):
         stream: bool,
         model_settings: AnthropicModelSettings,
         model_request_parameters: ModelRequestParameters,
-    ) -> AnthropicMessage | AsyncStream[RawMessageStreamEvent]:
+    ) -> BetaMessage | AsyncStream[BetaRawMessageStreamEvent]:
         # standalone function to make it easier to override
         tools = self._get_tools(model_request_parameters)
-        tool_choice: ToolChoiceParam | None
+        tool_choice: BetaToolChoiceParam | None
 
         if not tools:
             tool_choice = None
@@ -225,7 +227,7 @@ class AnthropicModel(Model):
         try:
             extra_headers = model_settings.get('extra_headers', {})
             extra_headers.setdefault('User-Agent', get_user_agent())
-            return await self.client.messages.create(
+            return await self.client.beta.messages.create(
                 max_tokens=model_settings.get('max_tokens', 1024),
                 system=system_prompt or NOT_GIVEN,
                 messages=anthropic_messages,
@@ -246,14 +248,14 @@ class AnthropicModel(Model):
                 raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=e.body) from e
             raise  # pragma: lax no cover
 
-    def _process_response(self, response: AnthropicMessage) -> ModelResponse:
+    def _process_response(self, response: BetaMessage) -> ModelResponse:
         """Process a non-streamed response, and prepare a message to return."""
         items: list[ModelResponsePart] = []
         for item in response.content:
-            if isinstance(item, TextBlock):
+            if isinstance(item, BetaTextBlock):
                 items.append(TextPart(content=item.text))
             else:
-                assert isinstance(item, ToolUseBlock), 'unexpected item type'
+                assert isinstance(item, BetaToolUseBlock), 'unexpected item type'
                 items.append(
                     ToolCallPart(
                         tool_name=item.name,
@@ -264,7 +266,7 @@ class AnthropicModel(Model):
 
         return ModelResponse(items, usage=_map_usage(response), model_name=response.model, vendor_id=response.id)
 
-    async def _process_streamed_response(self, response: AsyncStream[RawMessageStreamEvent]) -> StreamedResponse:
+    async def _process_streamed_response(self, response: AsyncStream[BetaRawMessageStreamEvent]) -> StreamedResponse:
         peekable_response = _utils.PeekableAsyncStream(response)
         first_chunk = await peekable_response.peek()
         if isinstance(first_chunk, _utils.Unset):
@@ -276,21 +278,19 @@ class AnthropicModel(Model):
             _model_name=self._model_name, _response=peekable_response, _timestamp=timestamp
         )
 
-    def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[ToolParam]:
+    def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[BetaToolParam]:
         tools = [self._map_tool_definition(r) for r in model_request_parameters.function_tools]
         if model_request_parameters.output_tools:
             tools += [self._map_tool_definition(r) for r in model_request_parameters.output_tools]
         return tools
 
-    async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[MessageParam]]:
+    async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[BetaMessageParam]]:
         """Just maps a `pydantic_ai.Message` to a `anthropic.types.MessageParam`."""
         system_prompt_parts: list[str] = []
-        anthropic_messages: list[MessageParam] = []
+        anthropic_messages: list[BetaMessageParam] = []
         for m in messages:
             if isinstance(m, ModelRequest):
-                user_content_params: list[
-                    ToolResultBlockParam | TextBlockParam | ImageBlockParam | DocumentBlockParam
-                ] = []
+                user_content_params: list[BetaContentBlockParam] = []
                 for request_part in m.parts:
                     if isinstance(request_part, SystemPromptPart):
                         system_prompt_parts.append(request_part.content)
@@ -298,7 +298,7 @@ class AnthropicModel(Model):
                         async for content in self._map_user_prompt(request_part):
                             user_content_params.append(content)
                     elif isinstance(request_part, ToolReturnPart):
-                        tool_result_block_param = ToolResultBlockParam(
+                        tool_result_block_param = BetaToolResultBlockParam(
                             tool_use_id=_guard_tool_call_id(t=request_part),
                             type='tool_result',
                             content=request_part.model_response_str(),
@@ -308,30 +308,30 @@ class AnthropicModel(Model):
                     elif isinstance(request_part, RetryPromptPart):  # pragma: no branch
                         if request_part.tool_name is None:
                             text = request_part.model_response()  # pragma: no cover
-                            retry_param = TextBlockParam(type='text', text=text)  # pragma: no cover
+                            retry_param = BetaTextBlockParam(type='text', text=text)  # pragma: no cover
                         else:
-                            retry_param = ToolResultBlockParam(
+                            retry_param = BetaToolResultBlockParam(
                                 tool_use_id=_guard_tool_call_id(t=request_part),
                                 type='tool_result',
                                 content=request_part.model_response(),
                                 is_error=True,
                             )
                         user_content_params.append(retry_param)
-                anthropic_messages.append(MessageParam(role='user', content=user_content_params))
+                anthropic_messages.append(BetaMessageParam(role='user', content=user_content_params))
             elif isinstance(m, ModelResponse):
-                assistant_content_params: list[TextBlockParam | ToolUseBlockParam] = []
+                assistant_content_params: list[BetaTextBlockParam | BetaToolUseBlockParam] = []
                 for response_part in m.parts:
                     if isinstance(response_part, TextPart):
-                        assistant_content_params.append(TextBlockParam(text=response_part.content, type='text'))
+                        assistant_content_params.append(BetaTextBlockParam(text=response_part.content, type='text'))
                     else:
-                        tool_use_block_param = ToolUseBlockParam(
+                        tool_use_block_param = BetaToolUseBlockParam(
                             id=_guard_tool_call_id(t=response_part),
                             type='tool_use',
                             name=response_part.tool_name,
                             input=response_part.args_as_dict(),
                         )
                         assistant_content_params.append(tool_use_block_param)
-                anthropic_messages.append(MessageParam(role='assistant', content=assistant_content_params))
+                anthropic_messages.append(BetaMessageParam(role='assistant', content=assistant_content_params))
             else:
                 assert_never(m)
         system_prompt = '\n\n'.join(system_prompt_parts)
@@ -342,22 +342,22 @@ class AnthropicModel(Model):
     @staticmethod
     async def _map_user_prompt(
         part: UserPromptPart,
-    ) -> AsyncGenerator[ImageBlockParam | TextBlockParam | DocumentBlockParam]:
+    ) -> AsyncGenerator[BetaContentBlockParam]:
         if isinstance(part.content, str):
-            yield TextBlockParam(text=part.content, type='text')
+            yield BetaTextBlockParam(text=part.content, type='text')
         else:
             for item in part.content:
                 if isinstance(item, str):
-                    yield TextBlockParam(text=item, type='text')
+                    yield BetaTextBlockParam(text=item, type='text')
                 elif isinstance(item, BinaryContent):
                     if item.is_image:
-                        yield ImageBlockParam(
+                        yield BetaImageBlockParam(
                             source={'data': io.BytesIO(item.data), 'media_type': item.media_type, 'type': 'base64'},  # type: ignore
                             type='image',
                         )
                     elif item.media_type == 'application/pdf':
-                        yield DocumentBlockParam(
-                            source=Base64PDFSourceParam(
+                        yield BetaBase64PDFBlockParam(
+                            source=BetaBase64PDFSourceParam(
                                 data=io.BytesIO(item.data),
                                 media_type='application/pdf',
                                 type='base64',
@@ -367,15 +367,17 @@ class AnthropicModel(Model):
                     else:
                         raise RuntimeError('Only images and PDFs are supported for binary content')
                 elif isinstance(item, ImageUrl):
-                    yield ImageBlockParam(source={'type': 'url', 'url': item.url}, type='image')
+                    yield BetaImageBlockParam(source={'type': 'url', 'url': item.url}, type='image')
                 elif isinstance(item, DocumentUrl):
                     if item.media_type == 'application/pdf':
-                        yield DocumentBlockParam(source={'url': item.url, 'type': 'url'}, type='document')
+                        yield BetaBase64PDFBlockParam(source={'url': item.url, 'type': 'url'}, type='document')
                     elif item.media_type == 'text/plain':
                         response = await cached_async_http_client().get(item.url)
                         response.raise_for_status()
-                        yield DocumentBlockParam(
-                            source=PlainTextSourceParam(data=response.text, media_type=item.media_type, type='text'),
+                        yield BetaBase64PDFBlockParam(
+                            source=BetaPlainTextSourceParam(
+                                data=response.text, media_type=item.media_type, type='text'
+                            ),
                             type='document',
                         )
                     else:  # pragma: no cover
@@ -384,7 +386,7 @@ class AnthropicModel(Model):
                     raise RuntimeError(f'Unsupported content type: {type(item)}')  # pragma: no cover
 
     @staticmethod
-    def _map_tool_definition(f: ToolDefinition) -> ToolParam:
+    def _map_tool_definition(f: ToolDefinition) -> BetaToolParam:
         return {
             'name': f.name,
             'description': f.description,
@@ -392,12 +394,12 @@ class AnthropicModel(Model):
         }
 
 
-def _map_usage(message: AnthropicMessage | RawMessageStreamEvent) -> usage.Usage:
-    if isinstance(message, AnthropicMessage):
+def _map_usage(message: BetaMessage | BetaRawMessageStreamEvent) -> usage.Usage:
+    if isinstance(message, BetaMessage):
         response_usage = message.usage
-    elif isinstance(message, RawMessageStartEvent):
+    elif isinstance(message, BetaRawMessageStartEvent):
         response_usage = message.message.usage
-    elif isinstance(message, RawMessageDeltaEvent):
+    elif isinstance(message, BetaRawMessageDeltaEvent):
         response_usage = message.usage
     else:
         # No usage information provided in:
@@ -435,60 +437,51 @@ class AnthropicStreamedResponse(StreamedResponse):
     """Implementation of `StreamedResponse` for Anthropic models."""
 
     _model_name: AnthropicModelName
-    _response: AsyncIterable[RawMessageStreamEvent]
+    _response: AsyncIterable[BetaRawMessageStreamEvent]
     _timestamp: datetime
 
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
-        current_block: ContentBlock | None = None
-        current_json: str = ''
+        current_block: BetaContentBlock | None = None
 
         async for event in self._response:
             self._usage += _map_usage(event)
 
-            if isinstance(event, RawContentBlockStartEvent):
+            if isinstance(event, BetaRawContentBlockStartEvent):
                 current_block = event.content_block
-                if isinstance(current_block, TextBlock) and current_block.text:
+                if isinstance(current_block, BetaTextBlock) and current_block.text:
                     yield self._parts_manager.handle_text_delta(  # pragma: lax no cover
                         vendor_part_id='content', content=current_block.text
                     )
-                elif isinstance(current_block, ToolUseBlock):  # pragma: no branch
+                elif isinstance(current_block, BetaToolUseBlock):  # pragma: no branch
                     maybe_event = self._parts_manager.handle_tool_call_delta(
                         vendor_part_id=current_block.id,
                         tool_name=current_block.name,
-                        args=cast(dict[str, Any], current_block.input),
+                        args=cast(dict[str, Any], current_block.input) or None,
                         tool_call_id=current_block.id,
                     )
                     if maybe_event is not None:  # pragma: no branch
                         yield maybe_event
 
-            elif isinstance(event, RawContentBlockDeltaEvent):
-                if isinstance(event.delta, TextDelta):
+            elif isinstance(event, BetaRawContentBlockDeltaEvent):
+                if isinstance(event.delta, BetaTextDelta):
                     yield self._parts_manager.handle_text_delta(  # pragma: no cover
                         vendor_part_id='content', content=event.delta.text
                     )
                 elif (  # pragma: no branch
-                    current_block and event.delta.type == 'input_json_delta' and isinstance(current_block, ToolUseBlock)
+                    current_block
+                    and event.delta.type == 'input_json_delta'
+                    and isinstance(current_block, BetaToolUseBlock)
                 ):
-                    # Try to parse the JSON immediately, otherwise cache the value for later. This handles
-                    # cases where the JSON is not currently valid but will be valid once we stream more tokens.
-                    try:
-                        parsed_args = json_loads(current_json + event.delta.partial_json)
-                        current_json = ''
-                    except JSONDecodeError:
-                        current_json += event.delta.partial_json
-                        continue
-
-                    # For tool calls, we need to handle partial JSON updates
                     maybe_event = self._parts_manager.handle_tool_call_delta(
                         vendor_part_id=current_block.id,
                         tool_name='',
-                        args=parsed_args,
+                        args=event.delta.partial_json,
                         tool_call_id=current_block.id,
                     )
                     if maybe_event is not None:  # pragma: no branch
                         yield maybe_event
 
-            elif isinstance(event, (RawContentBlockStopEvent, RawMessageStopEvent)):
+            elif isinstance(event, (BetaRawContentBlockStopEvent, BetaRawMessageStopEvent)):
                 current_block = None
 
     @property

pydantic_ai/models/bedrock.py

@@ -552,8 +552,8 @@ class BedrockStreamedResponse(StreamedResponse):
                         args=None,
                         tool_call_id=tool_id,
                     )
-                    if maybe_event:
-                        yield maybe_event  # pragma: no cover
+                    if maybe_event:  # pragma: no branch
+                        yield maybe_event
             if 'contentBlockDelta' in chunk:
                 index = chunk['contentBlockDelta']['contentBlockIndex']
                 delta = chunk['contentBlockDelta']['delta']

pydantic_ai/models/google.py

@@ -279,7 +279,6 @@ class GoogleModel(Model):
     def _process_response(self, response: GenerateContentResponse) -> ModelResponse:
         if not response.candidates or len(response.candidates) != 1:
             raise UnexpectedModelBehavior('Expected exactly one candidate in Gemini response')  # pragma: no cover
-        print(response.candidates[0].safety_ratings)
         if response.candidates[0].content is None or response.candidates[0].content.parts is None:
             if response.candidates[0].finish_reason == 'SAFETY':
                 raise UnexpectedModelBehavior('Safety settings triggered', str(response))
@@ -443,7 +442,7 @@ def _process_response_from_parts(parts: list[Part], model_name: GoogleModelName,
             items.append(TextPart(content=part.text))
         elif part.function_call:
             assert part.function_call.name is not None
-            tool_call_part = ToolCallPart(tool_name=part.function_call.name, args=part.function_call.args or {})
+            tool_call_part = ToolCallPart(tool_name=part.function_call.name, args=part.function_call.args)
             if part.function_call.id is not None:
                 tool_call_part.tool_call_id = part.function_call.id  # pragma: no cover
             items.append(tool_call_part)

pydantic_ai/models/mistral.py

@@ -368,7 +368,7 @@ class MistralModel(Model):
         return MistralToolCall(
             id=_utils.guard_tool_call_id(t=t),
             type='function',
-            function=MistralFunctionCall(name=t.tool_name, arguments=t.args),
+            function=MistralFunctionCall(name=t.tool_name, arguments=t.args or {}),
         )
 
     def _generate_user_output_format(self, schemas: list[dict[str, Any]]) -> MistralUserMessage:

pydantic_ai/models/openai.py

@@ -170,7 +170,7 @@ class OpenAIModel(Model):
         self,
         model_name: OpenAIModelName,
         *,
-        provider: Literal['openai', 'deepseek', 'azure'] | Provider[AsyncOpenAI] = 'openai',
+        provider: Literal['openai', 'deepseek', 'azure', 'openrouter'] | Provider[AsyncOpenAI] = 'openai',
         system_prompt_role: OpenAISystemPromptRole | None = None,
     ):
         """Initialize an OpenAI model.
@@ -277,7 +277,6 @@ class OpenAIModel(Model):
             return await self.client.chat.completions.create(
                 model=self._model_name,
                 messages=openai_messages,
-                n=1,
                 parallel_tool_calls=model_settings.get('parallel_tool_calls', NOT_GIVEN),
                 tools=tools or NOT_GIVEN,
                 tool_choice=tool_choice or NOT_GIVEN,

pydantic_ai/result.py

@@ -544,15 +544,15 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
                 yield ''.join(deltas)
 
 
-@dataclass
+@dataclass(repr=False)
 class FinalResult(Generic[OutputDataT]):
     """Marker class storing the final output of an agent run and associated metadata."""
 
     output: OutputDataT
     """The final result data."""
-    tool_name: str | None
+    tool_name: str | None = None
     """Name of the final output tool; `None` if the output came from unstructured text content."""
-    tool_call_id: str | None
+    tool_call_id: str | None = None
     """ID of the tool call that produced the final output; `None` if the output came from unstructured text content."""
 
     @property
@@ -560,6 +560,8 @@ class FinalResult(Generic[OutputDataT]):
     def data(self) -> OutputDataT:
         return self.output
 
+    __repr__ = _utils.dataclasses_no_defaults_repr
+
 
 def _get_usage_checking_stream_response(
     stream_response: AsyncIterable[_messages.ModelResponseStreamEvent],

pydantic_ai/tools.py

@@ -29,6 +29,7 @@ __all__ = (
     'ToolFuncEither',
     'ToolParams',
     'ToolPrepareFunc',
+    'ToolsPrepareFunc',
     'Tool',
     'ObjectJsonSchema',
     'ToolDefinition',
@@ -38,7 +39,7 @@ AgentDepsT = TypeVar('AgentDepsT', default=None, contravariant=True)
 """Type variable for agent dependencies."""
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(repr=False)
 class RunContext(Generic[AgentDepsT]):
     """Information about the current call."""
 
@@ -72,6 +73,8 @@ class RunContext(Generic[AgentDepsT]):
             kwargs['tool_name'] = tool_name
         return dataclasses.replace(self, **kwargs)
 
+    __repr__ = _utils.dataclasses_no_defaults_repr
+
 
 ToolParams = ParamSpec('ToolParams', default=...)
 """Retrieval function param spec."""
@@ -133,6 +136,37 @@ hitchhiker = Tool(hitchhiker, prepare=only_if_42)
 Usage `ToolPrepareFunc[AgentDepsT]`.
 """
 
+ToolsPrepareFunc: TypeAlias = (
+    'Callable[[RunContext[AgentDepsT], list[ToolDefinition]], Awaitable[list[ToolDefinition] | None]]'
+)
+"""Definition of a function that can prepare the tool definition of all tools for each step.
+This is useful if you want to customize the definition of multiple tools or you want to register
+a subset of tools for a given step.
+
+Example — here `turn_on_strict_if_openai` is valid as a `ToolsPrepareFunc`:
+
+```python {noqa="I001"}
+from dataclasses import replace
+from typing import Union
+
+from pydantic_ai import Agent, RunContext
+from pydantic_ai.tools import ToolDefinition
+
+
+async def turn_on_strict_if_openai(
+    ctx: RunContext[None], tool_defs: list[ToolDefinition]
+) -> Union[list[ToolDefinition], None]:
+    if ctx.model.system == 'openai':
+        return [replace(tool_def, strict=True) for tool_def in tool_defs]
+    return tool_defs
+
+agent = Agent('openai:gpt-4o', prepare_tools=turn_on_strict_if_openai)
+```
+
+Usage `ToolsPrepareFunc[AgentDepsT]`.
+"""
+
+
 DocstringFormat = Literal['google', 'numpy', 'sphinx', 'auto']
 """Supported docstring formats.
 
@@ -335,7 +369,7 @@ class Tool(Generic[AgentDepsT]):
             if isinstance(message.args, str):
                 args_dict = self._validator.validate_json(message.args or '{}')
             else:
-                args_dict = self._validator.validate_python(message.args)
+                args_dict = self._validator.validate_python(message.args or {})
         except ValidationError as e:
             return self._on_error(e, message)
 
@@ -407,7 +441,7 @@ With PEP-728 this should be a TypedDict with `type: Literal['object']`, and `ext
 """
 
 
-@dataclass
+@dataclass(repr=False)
 class ToolDefinition:
     """Definition of a tool passed to a model.
 
@@ -440,3 +474,5 @@ class ToolDefinition:
 
     Note: this is currently only supported by OpenAI models.
     """
+
+    __repr__ = _utils.dataclasses_no_defaults_repr

pydantic_ai/usage.py

@@ -3,12 +3,13 @@ from __future__ import annotations as _annotations
 from copy import copy
 from dataclasses import dataclass
 
+from . import _utils
 from .exceptions import UsageLimitExceeded
 
 __all__ = 'Usage', 'UsageLimits'
 
 
-@dataclass
+@dataclass(repr=False)
 class Usage:
     """LLM usage associated with a request or run.
 
@@ -68,8 +69,10 @@ class Usage:
         """Whether any values are set and non-zero."""
         return bool(self.requests or self.request_tokens or self.response_tokens or self.details)
 
+    __repr__ = _utils.dataclasses_no_defaults_repr
 
-@dataclass
+
+@dataclass(repr=False)
 class UsageLimits:
     """Limits on model usage.
 
@@ -124,3 +127,5 @@ class UsageLimits:
         total_tokens = usage.total_tokens or 0
         if self.total_tokens_limit is not None and total_tokens > self.total_tokens_limit:
             raise UsageLimitExceeded(f'Exceeded the total_tokens_limit of {self.total_tokens_limit} ({total_tokens=})')
+
+    __repr__ = _utils.dataclasses_no_defaults_repr

{pydantic_ai_slim-0.2.5.dist-info → pydantic_ai_slim-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.2.5
+Version: 0.2.7
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>, Marcelo Trylesinski <marcelotryle@gmail.com>, David Montague <david@pydantic.dev>, Alex Hall <alex@pydantic.dev>
 License-Expression: MIT
@@ -30,11 +30,11 @@ Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.2.5
+Requires-Dist: pydantic-graph==0.2.7
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
-Requires-Dist: fasta2a==0.2.5; extra == 'a2a'
+Requires-Dist: fasta2a==0.2.7; extra == 'a2a'
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.49.0; extra == 'anthropic'
 Provides-Extra: bedrock
@@ -48,7 +48,7 @@ Requires-Dist: cohere>=5.13.11; (platform_system != 'Emscripten') and extra == '
 Provides-Extra: duckduckgo
 Requires-Dist: duckduckgo-search>=7.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.2.5; extra == 'evals'
+Requires-Dist: pydantic-evals==0.2.7; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.15.0; extra == 'google'
 Provides-Extra: groq