pydantic-ai-slim 0.2.6__py3-none-any.whl → 0.2.8__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), f'unexpected item type {type(item)}'
                 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

@@ -442,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

@@ -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

@@ -39,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."""
 
@@ -73,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."""
@@ -367,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)
 
@@ -439,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.
 
@@ -472,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.6.dist-info → pydantic_ai_slim-0.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.2.6
+Version: 0.2.8
 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.6
+Requires-Dist: pydantic-graph==0.2.8
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
-Requires-Dist: fasta2a==0.2.6; extra == 'a2a'
+Requires-Dist: fasta2a==0.2.8; 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.6; extra == 'evals'
+Requires-Dist: pydantic-evals==0.2.8; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.15.0; extra == 'google'
 Provides-Extra: groq

{pydantic_ai_slim-0.2.6.dist-info → pydantic_ai_slim-0.2.8.dist-info}/RECORD

@@ -1,42 +1,42 @@
 pydantic_ai/__init__.py,sha256=5flxyMQJVrHRMQ3MYaZf1el2ctNs0JmPClKbw2Q-Lsk,1160
 pydantic_ai/__main__.py,sha256=Q_zJU15DUA01YtlJ2mnaLCoId2YmgmreVEERGuQT-Y0,132
 pydantic_ai/_a2a.py,sha256=8nNtx6GENDt2Ej3f1ui9L-FuNQBYVELpJFfwz-y7fUw,7234
-pydantic_ai/_agent_graph.py,sha256=7MekV5ytDQ1wtTr2W28V76pYPqN0SACiaJ7umU0kWe4,35666
+pydantic_ai/_agent_graph.py,sha256=vabNuwWnJlvmLls8RkOgoda9T-kb_xf5TnzIgk-DeBI,36516
 pydantic_ai/_cli.py,sha256=Jpp4ymlYHMYsFU3nb048AK7MISENYDCgsUg9PPGWbt0,12943
 pydantic_ai/_griffe.py,sha256=Sf_DisE9k2TA0VFeVIK2nf1oOct5MygW86PBCACJkFA,5244
-pydantic_ai/_output.py,sha256=bN2gnIhtVW8-rIu6BUlXFqLbbDauipEdNHzaS5vMNv0,11357
-pydantic_ai/_parts_manager.py,sha256=mG6uh2hqeMrkxbaBNbHkQF91rLXJZre4WejE7K3kFs8,12210
-pydantic_ai/_pydantic.py,sha256=1EO1tv-ULj3l_L1qMcC7gIOKTL2e2a-xTbUD_kqKiOg,8921
+pydantic_ai/_output.py,sha256=fJ3xyaIUf7R_QmYQaTZLqNBbZdVgzFTYsS2NxyqsybI,11447
+pydantic_ai/_parts_manager.py,sha256=c0Gj29FH8K20AmxIr7MY8_SQVdb7SRIRcJYTQVmVYgc,12204
+pydantic_ai/_pydantic.py,sha256=Dz9pVp-mcxBtIUK6TnfSZIAVXdsB1JKErZsINgX8Fpk,9161
 pydantic_ai/_system_prompt.py,sha256=602c2jyle2R_SesOrITBDETZqsLk4BZ8Cbo8yEhmx04,1120
-pydantic_ai/_utils.py,sha256=Vlww1AMQMTvFfGRlFKAyvl4VrE24Lk1MH28EwVTWy8c,10122
-pydantic_ai/agent.py,sha256=6NjKs4AhT4BYyTX98zjLJjNDw1fpyXRoY7NVzyUdamE,94598
-pydantic_ai/direct.py,sha256=nGIPlp2edVEc3aixcRyT6mqGASWgTZbv3F9aXNwzIKA,8441
+pydantic_ai/_utils.py,sha256=XfZ7mZmrv5ZsU3DwjwLXwmbVNTQrgX_kIL9SIfatg90,10456
+pydantic_ai/agent.py,sha256=gz_AFp5dO2xSbf9ej-jTNLa6-LZFV_JCWeRwA4Kq0tc,93721
+pydantic_ai/direct.py,sha256=tXRcQ3fMkykaawO51VxnSwQnqcEmu1LhCy7U9gOyM-g,7768
 pydantic_ai/exceptions.py,sha256=IdFw594Ou7Vn4YFa7xdZ040_j_6nmyA3MPANbC7sys4,3175
 pydantic_ai/format_as_xml.py,sha256=IINfh1evWDphGahqHNLBArB5dQ4NIqS3S-kru35ztGg,372
 pydantic_ai/format_prompt.py,sha256=qdKep95Sjlr7u1-qag4JwPbjoURbG0GbeU_l5ODTNw4,4466
-pydantic_ai/mcp.py,sha256=UsiBsg2ZuFh0OTMc-tvvxzfyW9YiPSIe6h8_KGloxqI,11312
-pydantic_ai/messages.py,sha256=HTDWBpmEdhD1gN_mJgyugon6YuhvxHXDp-Cny9owGao,31191
+pydantic_ai/mcp.py,sha256=C8oui0iM76Q2NRgcoywon62dHKR8CcVAto25sLvfyyQ,13076
+pydantic_ai/messages.py,sha256=jJUh10-NGp58YkiTrKUUzffmd7JC2w2HXUlKWVhbGUM,32442
 pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/result.py,sha256=YgaF1c_LS2F2YcLNHTS-8KxqwnrBj7s3Z9s8WIB_oNA,27747
+pydantic_ai/result.py,sha256=un7AHAY3Rtqh1naSacZiTcrPgDGYo1vvAGlW7-95EO8,27825
 pydantic_ai/settings.py,sha256=U2XzZ9y1fIi_L6yCGTugZRxfk7_01rk5GKSgFqySHL4,3520
-pydantic_ai/tools.py,sha256=TSVPzO6GERP6izYHLj8wtNyY5vpjUY6BC96WutYXgvE,17990
-pydantic_ai/usage.py,sha256=NoK2JXSFU6dFR7sd2vX7D16l8A2-BtOdCvJkhcBVbrs,5447
+pydantic_ai/tools.py,sha256=UspUFXFa54ohFX5FNEN34cMTObqkCSN6gXOrKizm5C0,18124
+pydantic_ai/usage.py,sha256=35YPmItlzfNOwP35Rhh0qBUOlg5On5rUE7xqHQWrpaU,5596
 pydantic_ai/common_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/common_tools/duckduckgo.py,sha256=Ty9tu1rCwMfGKgz1JAaC2q_4esmL6QvpkHQUN8F0Ecc,2152
 pydantic_ai/common_tools/tavily.py,sha256=Q1xxSF5HtXAaZ10Pp-OaDOHXwJf2mco9wScGEQXD7E4,2495
 pydantic_ai/models/__init__.py,sha256=xTCjoFWQg6zZTY3yI-rakOd3RjUAf3uUGrzWn7Oxebw,22299
 pydantic_ai/models/_json_schema.py,sha256=RD0cIU9mOGIdRuhkjLtPdlwfmF8XDOP1kLevIOLudaE,6540
-pydantic_ai/models/anthropic.py,sha256=Q1gem9MieSRIbO6yxs7Fe29K7OfkXKC5IlMBwvC8epE,21360
-pydantic_ai/models/bedrock.py,sha256=JCeHy0kRXJJEtZqBppdWsMZtt6aVhtvMih4CO7RT354,26368
+pydantic_ai/models/anthropic.py,sha256=oyYJ8Eg-wllap_ckcCiKgDPW1CVNs5VmGo7v1LxO5_g,20973
+pydantic_ai/models/bedrock.py,sha256=mv-NFtnbaXS4NyGgLjExItrD6Hcu-8gHh1wVu2a-gZQ,26369
 pydantic_ai/models/cohere.py,sha256=a9dxjrH5StfvPP5CTituQsOhujO2KPHD6JOGpsx1E9o,11852
 pydantic_ai/models/fallback.py,sha256=idOYGMo3CZzpCBT8DDiuPAAgnV2jzluDUq3ESb3KteM,4981
 pydantic_ai/models/function.py,sha256=rnihsyakyieCGbEyxfqzvoBHnR_3LJn4x6DXQqdAAM4,11458
 pydantic_ai/models/gemini.py,sha256=7KDOOBFR9pbGGGokMevoW34SdOng1_Cnscs5yBgwMSg,37429
-pydantic_ai/models/google.py,sha256=AtcRih9pmmRtXPScKfMrX1I6ViK5Eteo06frVV3E0Tk,24276
+pydantic_ai/models/google.py,sha256=y576QHYUTm0pCXFZmhJC5aBLStGQhhsELcKOJr9HdSQ,24270
 pydantic_ai/models/groq.py,sha256=px2C3oW6Yvrk695E0dzDzDRUav6XiwkjyJvjro4Tb9M,17520
 pydantic_ai/models/instrumented.py,sha256=Y3SxAlP9cCX_Ch02c8qN9mrWMY9_tuyj6zMeN5Gz-W0,12356
-pydantic_ai/models/mistral.py,sha256=nRFpY_QDAyH-FLYCqA9ZURPvL5r6uzMy7BJoMYzXKxk,29344
-pydantic_ai/models/openai.py,sha256=HZHI_hu9NH9EuL053c6a9BnBZhFtXHDKBzpTLDkV9lE,49795
+pydantic_ai/models/mistral.py,sha256=h24_VwAx2iaAN8FHW9W72U6y5YyhYm1X9XK5rIQvTGI,29350
+pydantic_ai/models/openai.py,sha256=YEn9D-bhU-iOdyeB6vQoEnKaM_OK8uXCq45JyyOsLL8,49774
 pydantic_ai/models/test.py,sha256=Jlq-YQ9dhzENgmBMVerZpM4L-I2aPf7HH7ifIncyDlE,17010
 pydantic_ai/models/wrapper.py,sha256=43ntRkTF7rVBYLC-Ihdo1fkwpeveOpA_1fXe1fd3W9Y,1690
 pydantic_ai/providers/__init__.py,sha256=mBRULL9WaiGAgjKGY5aPQ7KatYoIOhkHSJJ3DkP6jvE,2695
@@ -52,8 +52,8 @@ pydantic_ai/providers/groq.py,sha256=DoY6qkfhuemuKB5JXhUkqG-3t1HQkxwSXoE_kHQIAK0
 pydantic_ai/providers/mistral.py,sha256=FAS7yKn26yWy7LTmEiBSvqe0HpTXi8_nIf824vE6RFQ,2892
 pydantic_ai/providers/openai.py,sha256=ePF-QWwLkGkSE5w245gTTDVR3VoTIUqFoIhQ0TAoUiA,2866
 pydantic_ai/providers/openrouter.py,sha256=ZwlpGjrHFqZefohdGJGL6MQiLOGKwu6kOCHziymJA_E,2215
-pydantic_ai_slim-0.2.6.dist-info/METADATA,sha256=BhyvvZNTY9znBMhA45CLU7WHNIYQyK1t1Z3RmD4U9Ds,3846
-pydantic_ai_slim-0.2.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.2.6.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
-pydantic_ai_slim-0.2.6.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
-pydantic_ai_slim-0.2.6.dist-info/RECORD,,
+pydantic_ai_slim-0.2.8.dist-info/METADATA,sha256=kUj5-FD5LHFToM7D5OuHovcdYyLCbXWHIk8m1XvOL4Y,3846
+pydantic_ai_slim-0.2.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.2.8.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
+pydantic_ai_slim-0.2.8.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_slim-0.2.8.dist-info/RECORD,,