pydantic-ai-slim 0.7.4__py3-none-any.whl → 0.7.5__py3-none-any.whl

pydantic_ai/_otel_messages.py

@@ -0,0 +1,67 @@
+"""Type definitions of OpenTelemetry GenAI spec message parts.
+
+Based on https://github.com/lmolkova/semantic-conventions/blob/eccd1f806e426a32c98271c3ce77585492d26de2/docs/gen-ai/non-normative/models.ipynb
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import JsonValue
+from typing_extensions import NotRequired, TypeAlias, TypedDict
+
+
+class TextPart(TypedDict):
+    type: Literal['text']
+    content: NotRequired[str]
+
+
+class ToolCallPart(TypedDict):
+    type: Literal['tool_call']
+    id: str
+    name: str
+    arguments: NotRequired[JsonValue]
+
+
+class ToolCallResponsePart(TypedDict):
+    type: Literal['tool_call_response']
+    id: str
+    name: str
+    result: NotRequired[JsonValue]
+
+
+class MediaUrlPart(TypedDict):
+    type: Literal['image-url', 'audio-url', 'video-url', 'document-url']
+    url: NotRequired[str]
+
+
+class BinaryDataPart(TypedDict):
+    type: Literal['binary']
+    media_type: str
+    content: NotRequired[str]
+
+
+class ThinkingPart(TypedDict):
+    type: Literal['thinking']
+    content: NotRequired[str]
+
+
+MessagePart: TypeAlias = 'TextPart | ToolCallPart | ToolCallResponsePart | MediaUrlPart | BinaryDataPart | ThinkingPart'
+
+
+Role = Literal['system', 'user', 'assistant']
+
+
+class ChatMessage(TypedDict):
+    role: Role
+    parts: list[MessagePart]
+
+
+InputMessages: TypeAlias = list[ChatMessage]
+
+
+class OutputMessage(ChatMessage):
+    finish_reason: NotRequired[str]
+
+
+OutputMessages: TypeAlias = list[OutputMessage]

pydantic_ai/builtin_tools.py

@@ -29,6 +29,7 @@ class WebSearchTool(AbstractBuiltinTool):
     * Anthropic
     * OpenAI
     * Groq
+    * Google
     """
 
     search_context_size: Literal['low', 'medium', 'high'] = 'medium'

pydantic_ai/durable_exec/temporal/_model.py

@@ -55,6 +55,10 @@ class TemporalStreamedResponse(StreamedResponse):
     def model_name(self) -> str:
         return self.response.model_name or ''  # pragma: no cover
 
+    @property
+    def provider_name(self) -> str:
+        return self.response.provider_name or ''  # pragma: no cover
+
     @property
     def timestamp(self) -> datetime:
         return self.response.timestamp  # pragma: no cover

pydantic_ai/messages.py

@@ -10,10 +10,11 @@ from typing import TYPE_CHECKING, Annotated, Any, Literal, Union, cast, overload
 
 import pydantic
 import pydantic_core
+from genai_prices import calc_price, types as genai_types
 from opentelemetry._events import Event  # pyright: ignore[reportPrivateImportUsage]
 from typing_extensions import TypeAlias, deprecated
 
-from . import _utils
+from . import _otel_messages, _utils
 from ._utils import (
     generate_tool_call_id as _generate_tool_call_id,
     now_utc as _now_utc,
@@ -82,6 +83,9 @@ class SystemPromptPart:
             body={'role': 'system', **({'content': self.content} if settings.include_content else {})},
         )
 
+    def otel_message_parts(self, settings: InstrumentationSettings) -> list[_otel_messages.MessagePart]:
+        return [_otel_messages.TextPart(type='text', **{'content': self.content} if settings.include_content else {})]
+
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
@@ -504,25 +508,41 @@ class UserPromptPart:
     """Part type identifier, this is available on all parts as a discriminator."""
 
     def otel_event(self, settings: InstrumentationSettings) -> Event:
-        content: str | list[dict[str, Any] | str] | dict[str, Any]
-        if isinstance(self.content, str):
-            content = self.content if settings.include_content else {'kind': 'text'}
-        else:
-            content = []
-            for part in self.content:
-                if isinstance(part, str):
-                    content.append(part if settings.include_content else {'kind': 'text'})
-                elif isinstance(part, (ImageUrl, AudioUrl, DocumentUrl, VideoUrl)):
-                    content.append({'kind': part.kind, **({'url': part.url} if settings.include_content else {})})
-                elif isinstance(part, BinaryContent):
-                    converted_part = {'kind': part.kind, 'media_type': part.media_type}
-                    if settings.include_content and settings.include_binary_content:
-                        converted_part['binary_content'] = base64.b64encode(part.data).decode()
-                    content.append(converted_part)
-                else:
-                    content.append({'kind': part.kind})  # pragma: no cover
+        content = [{'kind': part.pop('type'), **part} for part in self.otel_message_parts(settings)]
+        for part in content:
+            if part['kind'] == 'binary' and 'content' in part:
+                part['binary_content'] = part.pop('content')
+        content = [
+            part['content'] if part == {'kind': 'text', 'content': part.get('content')} else part for part in content
+        ]
+        if content in ([{'kind': 'text'}], [self.content]):
+            content = content[0]
         return Event('gen_ai.user.message', body={'content': content, 'role': 'user'})
 
+    def otel_message_parts(self, settings: InstrumentationSettings) -> list[_otel_messages.MessagePart]:
+        parts: list[_otel_messages.MessagePart] = []
+        content: Sequence[UserContent] = [self.content] if isinstance(self.content, str) else self.content
+        for part in content:
+            if isinstance(part, str):
+                parts.append(
+                    _otel_messages.TextPart(type='text', **({'content': part} if settings.include_content else {}))
+                )
+            elif isinstance(part, (ImageUrl, AudioUrl, DocumentUrl, VideoUrl)):
+                parts.append(
+                    _otel_messages.MediaUrlPart(
+                        type=part.kind,
+                        **{'url': part.url} if settings.include_content else {},
+                    )
+                )
+            elif isinstance(part, BinaryContent):
+                converted_part = _otel_messages.BinaryDataPart(type='binary', media_type=part.media_type)
+                if settings.include_content and settings.include_binary_content:
+                    converted_part['content'] = base64.b64encode(part.data).decode()
+                parts.append(converted_part)
+            else:
+                parts.append({'type': part.kind})  # pragma: no cover
+        return parts
+
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
@@ -576,6 +596,18 @@ class BaseToolReturnPart:
             },
         )
 
+    def otel_message_parts(self, settings: InstrumentationSettings) -> list[_otel_messages.MessagePart]:
+        from .models.instrumented import InstrumentedModel
+
+        return [
+            _otel_messages.ToolCallResponsePart(
+                type='tool_call_response',
+                id=self.tool_call_id,
+                name=self.tool_name,
+                **({'result': InstrumentedModel.serialize_any(self.content)} if settings.include_content else {}),
+            )
+        ]
+
     def has_content(self) -> bool:
         """Return `True` if the tool return has content."""
         return self.content is not None  # pragma: no cover
@@ -669,6 +701,19 @@ class RetryPromptPart:
                 },
             )
 
+    def otel_message_parts(self, settings: InstrumentationSettings) -> list[_otel_messages.MessagePart]:
+        if self.tool_name is None:
+            return [_otel_messages.TextPart(type='text', content=self.model_response())]
+        else:
+            return [
+                _otel_messages.ToolCallResponsePart(
+                    type='tool_call_response',
+                    id=self.tool_call_id,
+                    name=self.tool_name,
+                    **({'result': self.model_response()} if settings.include_content else {}),
+                )
+            ]
+
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
@@ -848,6 +893,9 @@ class ModelResponse:
     kind: Literal['response'] = 'response'
     """Message type identifier, this is available on all parts as a discriminator."""
 
+    provider_name: str | None = None
+    """The name of the LLM provider that generated the response."""
+
     provider_details: dict[str, Any] | None = field(default=None)
     """Additional provider-specific details in a serializable format.
 
@@ -858,6 +906,19 @@ class ModelResponse:
     provider_request_id: str | None = None
     """request ID as specified by the model provider. This can be used to track the specific request to the model."""
 
+    def price(self) -> genai_types.PriceCalculation:
+        """Calculate the price of the usage.
+
+        Uses [`genai-prices`](https://github.com/pydantic/genai-prices).
+        """
+        assert self.model_name, 'Model name is required to calculate price'
+        return calc_price(
+            self.usage,
+            self.model_name,
+            provider_id=self.provider_name,
+            genai_request_timestamp=self.timestamp,
+        )
+
     def otel_events(self, settings: InstrumentationSettings) -> list[Event]:
         """Return OpenTelemetry events for the response."""
         result: list[Event] = []
@@ -894,6 +955,36 @@ class ModelResponse:
 
         return result
 
+    def otel_message_parts(self, settings: InstrumentationSettings) -> list[_otel_messages.MessagePart]:
+        parts: list[_otel_messages.MessagePart] = []
+        for part in self.parts:
+            if isinstance(part, TextPart):
+                parts.append(
+                    _otel_messages.TextPart(
+                        type='text',
+                        **({'content': part.content} if settings.include_content else {}),
+                    )
+                )
+            elif isinstance(part, ThinkingPart):
+                parts.append(
+                    _otel_messages.ThinkingPart(
+                        type='thinking',
+                        **({'content': part.content} if settings.include_content else {}),
+                    )
+                )
+            elif isinstance(part, ToolCallPart):
+                call_part = _otel_messages.ToolCallPart(type='tool_call', id=part.tool_call_id, name=part.tool_name)
+                if settings.include_content and part.args is not None:
+                    from .models.instrumented import InstrumentedModel
+
+                    if isinstance(part.args, str):
+                        call_part['arguments'] = part.args
+                    else:
+                        call_part['arguments'] = {k: InstrumentedModel.serialize_any(v) for k, v in part.args.items()}
+
+                parts.append(call_part)
+        return parts
+
     @property
     @deprecated('`vendor_details` is deprecated, use `provider_details` instead')
     def vendor_details(self) -> dict[str, Any] | None:

pydantic_ai/models/__init__.py

@@ -598,6 +598,7 @@ class StreamedResponse(ABC):
             model_name=self.model_name,
             timestamp=self.timestamp,
             usage=self.usage(),
+            provider_name=self.provider_name,
         )
 
     def usage(self) -> RequestUsage:
@@ -610,6 +611,12 @@ class StreamedResponse(ABC):
         """Get the model name of the response."""
         raise NotImplementedError()
 
+    @property
+    @abstractmethod
+    def provider_name(self) -> str | None:
+        """Get the provider name."""
+        raise NotImplementedError()
+
     @property
     @abstractmethod
     def timestamp(self) -> datetime:

pydantic_ai/models/anthropic.py

@@ -37,12 +37,13 @@ from ..messages import (
 )
 from ..profiles import ModelProfileSpec
 from ..providers import Provider, infer_provider
+from ..providers.anthropic import AsyncAnthropicClient
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
 from . import Model, ModelRequestParameters, StreamedResponse, check_allow_model_requests, download_item, get_user_agent
 
 try:
-    from anthropic import NOT_GIVEN, APIStatusError, AsyncAnthropic, AsyncStream
+    from anthropic import NOT_GIVEN, APIStatusError, AsyncStream
     from anthropic.types.beta import (
         BetaBase64PDFBlockParam,
         BetaBase64PDFSourceParam,
@@ -134,16 +135,16 @@ class AnthropicModel(Model):
     Apart from `__init__`, all methods are private or match those of the base class.
     """
 
-    client: AsyncAnthropic = field(repr=False)
+    client: AsyncAnthropicClient = field(repr=False)
 
     _model_name: AnthropicModelName = field(repr=False)
-    _provider: Provider[AsyncAnthropic] = field(repr=False)
+    _provider: Provider[AsyncAnthropicClient] = field(repr=False)
 
     def __init__(
         self,
         model_name: AnthropicModelName,
         *,
-        provider: Literal['anthropic'] | Provider[AsyncAnthropic] = 'anthropic',
+        provider: Literal['anthropic'] | Provider[AsyncAnthropicClient] = 'anthropic',
         profile: ModelProfileSpec | None = None,
         settings: ModelSettings | None = None,
     ):
@@ -153,7 +154,7 @@ class AnthropicModel(Model):
             model_name: The name of the Anthropic model to use. List of model names available
                 [here](https://docs.anthropic.com/en/docs/about-claude/models).
             provider: The provider to use for the Anthropic API. Can be either the string 'anthropic' or an
-                instance of `Provider[AsyncAnthropic]`. If not provided, the other parameters will be used.
+                instance of `Provider[AsyncAnthropicClient]`. If not provided, the other parameters will be used.
             profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
             settings: Default model settings for this model instance.
         """
@@ -326,7 +327,11 @@ class AnthropicModel(Model):
                 )
 
         return ModelResponse(
-            items, usage=_map_usage(response), model_name=response.model, provider_request_id=response.id
+            items,
+            usage=_map_usage(response),
+            model_name=response.model,
+            provider_request_id=response.id,
+            provider_name=self._provider.name,
         )
 
     async def _process_streamed_response(
@@ -344,6 +349,7 @@ class AnthropicModel(Model):
             _model_name=self._model_name,
             _response=peekable_response,
             _timestamp=timestamp,
+            _provider_name=self._provider.name,
         )
 
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[BetaToolParam]:
@@ -574,6 +580,7 @@ class AnthropicStreamedResponse(StreamedResponse):
     _model_name: AnthropicModelName
     _response: AsyncIterable[BetaRawMessageStreamEvent]
     _timestamp: datetime
+    _provider_name: str
 
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:  # noqa: C901
         current_block: BetaContentBlock | None = None
@@ -655,6 +662,11 @@ class AnthropicStreamedResponse(StreamedResponse):
         """Get the model name of the response."""
         return self._model_name
 
+    @property
+    def provider_name(self) -> str:
+        """Get the provider name."""
+        return self._provider_name
+
     @property
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""

pydantic_ai/models/bedrock.py

@@ -240,10 +240,7 @@ class BedrockConverseModel(Model):
 
     @staticmethod
     def _map_tool_definition(f: ToolDefinition) -> ToolTypeDef:
-        tool_spec: ToolSpecificationTypeDef = {
-            'name': f.name,
-            'inputSchema': {'json': f.parameters_json_schema},
-        }
+        tool_spec: ToolSpecificationTypeDef = {'name': f.name, 'inputSchema': {'json': f.parameters_json_schema}}
 
         if f.description:  # pragma: no branch
             tool_spec['description'] = f.description
@@ -275,6 +272,7 @@ class BedrockConverseModel(Model):
             model_request_parameters=model_request_parameters,
             _model_name=self.model_name,
             _event_stream=response,
+            _provider_name=self._provider.name,
         )
 
     async def _process_response(self, response: ConverseResponseTypeDef) -> ModelResponse:
@@ -304,7 +302,9 @@ class BedrockConverseModel(Model):
             output_tokens=response['usage']['outputTokens'],
         )
         vendor_id = response.get('ResponseMetadata', {}).get('RequestId', None)
-        return ModelResponse(items, usage=u, model_name=self.model_name, provider_request_id=vendor_id)
+        return ModelResponse(
+            items, usage=u, model_name=self.model_name, provider_request_id=vendor_id, provider_name=self._provider.name
+        )
 
     @overload
     async def _messages_create(
@@ -594,6 +594,7 @@ class BedrockStreamedResponse(StreamedResponse):
 
     _model_name: BedrockModelName
     _event_stream: EventStream[ConverseStreamOutputTypeDef]
+    _provider_name: str
     _timestamp: datetime = field(default_factory=_utils.now_utc)
 
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:  # noqa: C901
@@ -660,15 +661,20 @@ class BedrockStreamedResponse(StreamedResponse):
                     if maybe_event:  # pragma: no branch
                         yield maybe_event
 
-    @property
-    def timestamp(self) -> datetime:
-        return self._timestamp
-
     @property
     def model_name(self) -> str:
         """Get the model name of the response."""
         return self._model_name
 
+    @property
+    def provider_name(self) -> str:
+        """Get the provider name."""
+        return self._provider_name
+
+    @property
+    def timestamp(self) -> datetime:
+        return self._timestamp
+
     def _map_usage(self, metadata: ConverseStreamMetadataEventTypeDef) -> usage.RequestUsage:
         return usage.RequestUsage(
             input_tokens=metadata['usage']['inputTokens'],

pydantic_ai/models/cohere.py

@@ -205,7 +205,9 @@ class CohereModel(Model):
                         tool_call_id=c.id or _generate_tool_call_id(),
                     )
                 )
-        return ModelResponse(parts=parts, usage=_map_usage(response), model_name=self._model_name)
+        return ModelResponse(
+            parts=parts, usage=_map_usage(response), model_name=self._model_name, provider_name=self._provider.name
+        )
 
     def _map_messages(self, messages: list[ModelMessage]) -> list[ChatMessageV2]:
         """Just maps a `pydantic_ai.Message` to a `cohere.ChatMessageV2`."""

pydantic_ai/models/function.py

@@ -304,6 +304,11 @@ class FunctionStreamedResponse(StreamedResponse):
         """Get the model name of the response."""
         return self._model_name
 
+    @property
+    def provider_name(self) -> None:
+        """Get the provider name."""
+        return None
+
     @property
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""

pydantic_ai/models/gemini.py

@@ -305,6 +305,7 @@ class GeminiModel(Model):
             _model_name=self._model_name,
             _content=content,
             _stream=aiter_bytes,
+            _provider_name=self._provider.name,
         )
 
     async def _message_to_gemini_content(
@@ -425,6 +426,7 @@ class GeminiStreamedResponse(StreamedResponse):
     _model_name: GeminiModelName
     _content: bytearray
     _stream: AsyncIterator[bytes]
+    _provider_name: str
     _timestamp: datetime = field(default_factory=_utils.now_utc, init=False)
 
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
@@ -495,6 +497,11 @@ class GeminiStreamedResponse(StreamedResponse):
         """Get the model name of the response."""
         return self._model_name
 
+    @property
+    def provider_name(self) -> str:
+        """Get the provider name."""
+        return self._provider_name
+
     @property
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""
@@ -883,7 +890,7 @@ def _metadata_as_usage(response: _GeminiResponse) -> usage.RequestUsage:
 
     return usage.RequestUsage(
         input_tokens=metadata.get('prompt_token_count', 0),
-        output_tokens=metadata.get('candidates_token_count', 0),
+        output_tokens=metadata.get('candidates_token_count', 0) + thoughts_token_count,
         cache_read_tokens=cached_content_token_count,
         input_audio_tokens=input_audio_tokens,
         output_audio_tokens=output_audio_tokens,

pydantic_ai/models/google.py

@@ -395,6 +395,7 @@ class GoogleModel(Model):
         return _process_response_from_parts(
             parts,
             response.model_version or self._model_name,
+            self._provider.name,
             usage,
             vendor_id=vendor_id,
             vendor_details=vendor_details,
@@ -414,6 +415,7 @@ class GoogleModel(Model):
             _model_name=self._model_name,
             _response=peekable_response,
             _timestamp=first_chunk.create_time or _utils.now_utc(),
+            _provider_name=self._provider.name,
         )
 
     async def _map_messages(self, messages: list[ModelMessage]) -> tuple[ContentDict | None, list[ContentUnionDict]]:
@@ -523,6 +525,7 @@ class GeminiStreamedResponse(StreamedResponse):
     _model_name: GoogleModelName
     _response: AsyncIterator[GenerateContentResponse]
     _timestamp: datetime
+    _provider_name: str
 
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
         async for chunk in self._response:
@@ -531,7 +534,10 @@ class GeminiStreamedResponse(StreamedResponse):
             assert chunk.candidates is not None
             candidate = chunk.candidates[0]
             if candidate.content is None or candidate.content.parts is None:
-                if candidate.finish_reason == 'SAFETY':  # pragma: no cover
+                if candidate.finish_reason == 'STOP':  # pragma: no cover
+                    # Normal completion - skip this chunk
+                    continue
+                elif candidate.finish_reason == 'SAFETY':  # pragma: no cover
                     raise UnexpectedModelBehavior('Safety settings triggered', str(chunk))
                 else:  # pragma: no cover
                     raise UnexpectedModelBehavior('Content field missing from streaming Gemini response', str(chunk))
@@ -561,6 +567,11 @@ class GeminiStreamedResponse(StreamedResponse):
         """Get the model name of the response."""
         return self._model_name
 
+    @property
+    def provider_name(self) -> str:
+        """Get the provider name."""
+        return self._provider_name
+
     @property
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""
@@ -596,6 +607,7 @@ def _content_model_response(m: ModelResponse) -> ContentDict:
 def _process_response_from_parts(
     parts: list[Part],
     model_name: GoogleModelName,
+    provider_name: str,
     usage: usage.RequestUsage,
     vendor_id: str | None,
     vendor_details: dict[str, Any] | None = None,
@@ -633,7 +645,12 @@ def _process_response_from_parts(
                 f'Unsupported response from Gemini, expected all parts to be function calls or text, got: {part!r}'
             )
     return ModelResponse(
-        parts=items, model_name=model_name, usage=usage, provider_request_id=vendor_id, provider_details=vendor_details
+        parts=items,
+        model_name=model_name,
+        usage=usage,
+        provider_request_id=vendor_id,
+        provider_details=vendor_details,
+        provider_name=provider_name,
     )
 
 
@@ -661,7 +678,7 @@ def _metadata_as_usage(response: GenerateContentResponse) -> usage.RequestUsage:
     if cached_content_token_count := metadata.cached_content_token_count:
         details['cached_content_tokens'] = cached_content_token_count
 
-    if thoughts_token_count := metadata.thoughts_token_count:
+    if thoughts_token_count := (metadata.thoughts_token_count or 0):
         details['thoughts_tokens'] = thoughts_token_count
 
     if tool_use_prompt_token_count := metadata.tool_use_prompt_token_count:
@@ -694,7 +711,7 @@ def _metadata_as_usage(response: GenerateContentResponse) -> usage.RequestUsage:
 
     return usage.RequestUsage(
         input_tokens=metadata.prompt_token_count or 0,
-        output_tokens=metadata.candidates_token_count or 0,
+        output_tokens=(metadata.candidates_token_count or 0) + thoughts_token_count,
         cache_read_tokens=cached_content_token_count or 0,
         input_audio_tokens=input_audio_tokens,
         output_audio_tokens=output_audio_tokens,

pydantic_ai/models/groq.py

@@ -290,6 +290,7 @@ class GroqModel(Model):
             model_name=response.model,
             timestamp=timestamp,
             provider_request_id=response.id,
+            provider_name=self._provider.name,
         )
 
     async def _process_streamed_response(
@@ -309,6 +310,7 @@ class GroqModel(Model):
             _model_name=self._model_name,
             _model_profile=self.profile,
             _timestamp=number_to_datetime(first_chunk.created),
+            _provider_name=self._provider.name,
         )
 
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[chat.ChatCompletionToolParam]:
@@ -444,6 +446,7 @@ class GroqStreamedResponse(StreamedResponse):
     _model_profile: ModelProfile
     _response: AsyncIterable[chat.ChatCompletionChunk]
     _timestamp: datetime
+    _provider_name: str
 
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
         async for chunk in self._response:
@@ -482,6 +485,11 @@ class GroqStreamedResponse(StreamedResponse):
         """Get the model name of the response."""
         return self._model_name
 
+    @property
+    def provider_name(self) -> str:
+        """Get the provider name."""
+        return self._provider_name
+
     @property
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""

pydantic_ai/models/huggingface.py

@@ -272,6 +272,7 @@ class HuggingFaceModel(Model):
             model_name=response.model,
             timestamp=timestamp,
             provider_request_id=response.id,
+            provider_name=self._provider.name,
         )
 
     async def _process_streamed_response(
@@ -291,6 +292,7 @@ class HuggingFaceModel(Model):
             _model_profile=self.profile,
             _response=peekable_response,
             _timestamp=datetime.fromtimestamp(first_chunk.created, tz=timezone.utc),
+            _provider_name=self._provider.name,
         )
 
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[ChatCompletionInputTool]:
@@ -437,6 +439,7 @@ class HuggingFaceStreamedResponse(StreamedResponse):
     _model_profile: ModelProfile
     _response: AsyncIterable[ChatCompletionStreamOutput]
     _timestamp: datetime
+    _provider_name: str
 
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
         async for chunk in self._response:
@@ -474,6 +477,11 @@ class HuggingFaceStreamedResponse(StreamedResponse):
         """Get the model name of the response."""
         return self._model_name
 
+    @property
+    def provider_name(self) -> str:
+        """Get the provider name."""
+        return self._provider_name
+
     @property
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""

pydantic_ai/models/instrumented.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
+import itertools
 import json
 from collections.abc import AsyncIterator, Iterator, Mapping
 from contextlib import asynccontextmanager, contextmanager
 from dataclasses import dataclass, field
-from typing import Any, Callable, Literal
+from typing import Any, Callable, Literal, cast
 from urllib.parse import urlparse
 
 from opentelemetry._events import (
@@ -18,8 +19,14 @@ from opentelemetry.trace import Span, Tracer, TracerProvider, get_tracer_provide
 from opentelemetry.util.types import AttributeValue
 from pydantic import TypeAdapter
 
+from .. import _otel_messages
 from .._run_context import RunContext
-from ..messages import ModelMessage, ModelRequest, ModelResponse
+from ..messages import (
+    ModelMessage,
+    ModelRequest,
+    ModelResponse,
+    SystemPromptPart,
+)
 from ..settings import ModelSettings
 from . import KnownModelName, Model, ModelRequestParameters, StreamedResponse
 from .wrapper import WrapperModel
@@ -80,6 +87,8 @@ class InstrumentationSettings:
     event_logger: EventLogger = field(repr=False)
     event_mode: Literal['attributes', 'logs'] = 'attributes'
     include_binary_content: bool = True
+    include_content: bool = True
+    version: Literal[1, 2] = 1
 
     def __init__(
         self,
@@ -90,6 +99,7 @@ class InstrumentationSettings:
         event_logger_provider: EventLoggerProvider | None = None,
         include_binary_content: bool = True,
         include_content: bool = True,
+        version: Literal[1, 2] = 1,
     ):
         """Create instrumentation options.
 
@@ -109,6 +119,10 @@ class InstrumentationSettings:
             include_binary_content: Whether to include binary content in the instrumentation events.
             include_content: Whether to include prompts, completions, and tool call arguments and responses
                 in the instrumentation events.
+            version: Version of the data format.
+                Version 1 is based on the legacy event-based OpenTelemetry GenAI spec.
+                Version 2 stores messages in the attributes `gen_ai.input.messages` and `gen_ai.output.messages`.
+                Version 2 is still WIP and experimental, but will become the default in Pydantic AI v1.
         """
         from pydantic_ai import __version__
 
@@ -122,6 +136,7 @@ class InstrumentationSettings:
         self.event_mode = event_mode
         self.include_binary_content = include_binary_content
         self.include_content = include_content
+        self.version = version
 
         # As specified in the OpenTelemetry GenAI metrics spec:
         # https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-metrics/#metric-gen_aiclienttokenusage
@@ -179,6 +194,90 @@ class InstrumentationSettings:
             event.body = InstrumentedModel.serialize_any(event.body)
         return events
 
+    def messages_to_otel_messages(self, messages: list[ModelMessage]) -> list[_otel_messages.ChatMessage]:
+        result: list[_otel_messages.ChatMessage] = []
+        for message in messages:
+            if isinstance(message, ModelRequest):
+                for is_system, group in itertools.groupby(message.parts, key=lambda p: isinstance(p, SystemPromptPart)):
+                    message_parts: list[_otel_messages.MessagePart] = []
+                    for part in group:
+                        if hasattr(part, 'otel_message_parts'):
+                            message_parts.extend(part.otel_message_parts(self))
+                    result.append(
+                        _otel_messages.ChatMessage(role='system' if is_system else 'user', parts=message_parts)
+                    )
+            elif isinstance(message, ModelResponse):  # pragma: no branch
+                result.append(_otel_messages.ChatMessage(role='assistant', parts=message.otel_message_parts(self)))
+        return result
+
+    def handle_messages(self, input_messages: list[ModelMessage], response: ModelResponse, system: str, span: Span):
+        if self.version == 1:
+            events = self.messages_to_otel_events(input_messages)
+            for event in self.messages_to_otel_events([response]):
+                events.append(
+                    Event(
+                        'gen_ai.choice',
+                        body={
+                            'index': 0,
+                            'message': event.body,
+                        },
+                    )
+                )
+            for event in events:
+                event.attributes = {
+                    GEN_AI_SYSTEM_ATTRIBUTE: system,
+                    **(event.attributes or {}),
+                }
+            self._emit_events(span, events)
+        else:
+            output_messages = self.messages_to_otel_messages([response])
+            assert len(output_messages) == 1
+            output_message = cast(_otel_messages.OutputMessage, output_messages[0])
+            if response.provider_details and 'finish_reason' in response.provider_details:
+                output_message['finish_reason'] = response.provider_details['finish_reason']
+            instructions = InstrumentedModel._get_instructions(input_messages)  # pyright: ignore [reportPrivateUsage]
+            attributes = {
+                'gen_ai.input.messages': json.dumps(self.messages_to_otel_messages(input_messages)),
+                'gen_ai.output.messages': json.dumps([output_message]),
+                'logfire.json_schema': json.dumps(
+                    {
+                        'type': 'object',
+                        'properties': {
+                            'gen_ai.input.messages': {'type': 'array'},
+                            'gen_ai.output.messages': {'type': 'array'},
+                            **({'gen_ai.system_instructions': {'type': 'array'}} if instructions else {}),
+                            'model_request_parameters': {'type': 'object'},
+                        },
+                    }
+                ),
+            }
+            if instructions is not None:
+                attributes['gen_ai.system_instructions'] = json.dumps(
+                    [_otel_messages.TextPart(type='text', content=instructions)]
+                )
+            span.set_attributes(attributes)
+
+    def _emit_events(self, span: Span, events: list[Event]) -> None:
+        if self.event_mode == 'logs':
+            for event in events:
+                self.event_logger.emit(event)
+        else:
+            attr_name = 'events'
+            span.set_attributes(
+                {
+                    attr_name: json.dumps([InstrumentedModel.event_to_dict(event) for event in events]),
+                    'logfire.json_schema': json.dumps(
+                        {
+                            'type': 'object',
+                            'properties': {
+                                attr_name: {'type': 'array'},
+                                'model_request_parameters': {'type': 'object'},
+                            },
+                        }
+                    ),
+                }
+            )
+
 
 GEN_AI_SYSTEM_ATTRIBUTE = 'gen_ai.system'
 GEN_AI_REQUEST_MODEL_ATTRIBUTE = 'gen_ai.request.model'
@@ -269,7 +368,7 @@ class InstrumentedModel(WrapperModel):
                     # FallbackModel updates these span attributes.
                     attributes.update(getattr(span, 'attributes', {}))
                     request_model = attributes[GEN_AI_REQUEST_MODEL_ATTRIBUTE]
-                    system = attributes[GEN_AI_SYSTEM_ATTRIBUTE]
+                    system = cast(str, attributes[GEN_AI_SYSTEM_ATTRIBUTE])
 
                     response_model = response.model_name or request_model
 
@@ -297,18 +396,7 @@ class InstrumentedModel(WrapperModel):
                     if not span.is_recording():
                         return
 
-                    events = self.instrumentation_settings.messages_to_otel_events(messages)
-                    for event in self.instrumentation_settings.messages_to_otel_events([response]):
-                        events.append(
-                            Event(
-                                'gen_ai.choice',
-                                body={
-                                    # TODO finish_reason
-                                    'index': 0,
-                                    'message': event.body,
-                                },
-                            )
-                        )
+                    self.instrumentation_settings.handle_messages(messages, response, system, span)
                     span.set_attributes(
                         {
                             **response.usage.opentelemetry_attributes(),
@@ -316,12 +404,6 @@ class InstrumentedModel(WrapperModel):
                         }
                     )
                     span.update_name(f'{operation} {request_model}')
-                    for event in events:
-                        event.attributes = {
-                            GEN_AI_SYSTEM_ATTRIBUTE: system,
-                            **(event.attributes or {}),
-                        }
-                    self._emit_events(span, events)
 
                 yield finish
         finally:
@@ -330,27 +412,6 @@ class InstrumentedModel(WrapperModel):
                 # to prevent them from being redundantly recorded in the span itself by logfire.
                 record_metrics()
 
-    def _emit_events(self, span: Span, events: list[Event]) -> None:
-        if self.instrumentation_settings.event_mode == 'logs':
-            for event in events:
-                self.instrumentation_settings.event_logger.emit(event)
-        else:
-            attr_name = 'events'
-            span.set_attributes(
-                {
-                    attr_name: json.dumps([self.event_to_dict(event) for event in events]),
-                    'logfire.json_schema': json.dumps(
-                        {
-                            'type': 'object',
-                            'properties': {
-                                attr_name: {'type': 'array'},
-                                'model_request_parameters': {'type': 'object'},
-                            },
-                        }
-                    ),
-                }
-            )
-
     @staticmethod
     def model_attributes(model: Model):
         attributes: dict[str, AttributeValue] = {

pydantic_ai/models/mistral.py

@@ -353,6 +353,7 @@ class MistralModel(Model):
             model_name=response.model,
             timestamp=timestamp,
             provider_request_id=response.id,
+            provider_name=self._provider.name,
         )
 
     async def _process_streamed_response(
@@ -378,6 +379,7 @@ class MistralModel(Model):
             _response=peekable_response,
             _model_name=self._model_name,
             _timestamp=timestamp,
+            _provider_name=self._provider.name,
         )
 
     @staticmethod
@@ -584,6 +586,7 @@ class MistralStreamedResponse(StreamedResponse):
     _model_name: MistralModelName
     _response: AsyncIterable[MistralCompletionEvent]
     _timestamp: datetime
+    _provider_name: str
 
     _delta_content: str = field(default='', init=False)
 
@@ -631,6 +634,11 @@ class MistralStreamedResponse(StreamedResponse):
         """Get the model name of the response."""
         return self._model_name
 
+    @property
+    def provider_name(self) -> str:
+        """Get the provider name."""
+        return self._provider_name
+
     @property
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""

pydantic_ai/models/openai.py

@@ -500,6 +500,7 @@ class OpenAIModel(Model):
             timestamp=timestamp,
             provider_details=vendor_details,
             provider_request_id=response.id,
+            provider_name=self._provider.name,
         )
 
     async def _process_streamed_response(
@@ -519,6 +520,7 @@ class OpenAIModel(Model):
             _model_profile=self.profile,
             _response=peekable_response,
             _timestamp=number_to_datetime(first_chunk.created),
+            _provider_name=self._provider.name,
         )
 
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[chat.ChatCompletionToolParam]:
@@ -571,6 +573,8 @@ class OpenAIModel(Model):
                     # Note: model responses from this model should only have one text item, so the following
                     # shouldn't merge multiple texts into one unless you switch models between runs:
                     message_param['content'] = '\n\n'.join(texts)
+                else:
+                    message_param['content'] = None
                 if tool_calls:
                     message_param['tool_calls'] = tool_calls
                 openai_messages.append(message_param)
@@ -803,6 +807,7 @@ class OpenAIResponsesModel(Model):
             model_name=response.model,
             provider_request_id=response.id,
             timestamp=timestamp,
+            provider_name=self._provider.name,
         )
 
     async def _process_streamed_response(
@@ -822,6 +827,7 @@ class OpenAIResponsesModel(Model):
             _model_name=self._model_name,
             _response=peekable_response,
             _timestamp=number_to_datetime(first_chunk.response.created_at),
+            _provider_name=self._provider.name,
         )
 
     @overload
@@ -1137,6 +1143,7 @@ class OpenAIStreamedResponse(StreamedResponse):
     _model_profile: ModelProfile
     _response: AsyncIterable[ChatCompletionChunk]
     _timestamp: datetime
+    _provider_name: str
 
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
         async for chunk in self._response:
@@ -1180,6 +1187,11 @@ class OpenAIStreamedResponse(StreamedResponse):
         """Get the model name of the response."""
         return self._model_name
 
+    @property
+    def provider_name(self) -> str:
+        """Get the provider name."""
+        return self._provider_name
+
     @property
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""
@@ -1193,6 +1205,7 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
     _model_name: OpenAIModelName
     _response: AsyncIterable[responses.ResponseStreamEvent]
     _timestamp: datetime
+    _provider_name: str
 
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:  # noqa: C901
         async for chunk in self._response:
@@ -1313,6 +1326,11 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
         """Get the model name of the response."""
         return self._model_name
 
+    @property
+    def provider_name(self) -> str:
+        """Get the provider name."""
+        return self._provider_name
+
     @property
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""

pydantic_ai/models/test.py

@@ -131,6 +131,7 @@ class TestModel(Model):
             _model_name=self._model_name,
             _structured_response=model_response,
             _messages=messages,
+            _provider_name=self._system,
         )
 
     @property
@@ -263,6 +264,7 @@ class TestStreamedResponse(StreamedResponse):
     _model_name: str
     _structured_response: ModelResponse
     _messages: InitVar[Iterable[ModelMessage]]
+    _provider_name: str
     _timestamp: datetime = field(default_factory=_utils.now_utc, init=False)
 
     def __post_init__(self, _messages: Iterable[ModelMessage]):
@@ -305,6 +307,11 @@ class TestStreamedResponse(StreamedResponse):
         """Get the model name of the response."""
         return self._model_name
 
+    @property
+    def provider_name(self) -> str:
+        """Get the provider name."""
+        return self._provider_name
+
     @property
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""

pydantic_ai/providers/anthropic.py

@@ -1,9 +1,10 @@
 from __future__ import annotations as _annotations
 
 import os
-from typing import overload
+from typing import Union, overload
 
 import httpx
+from typing_extensions import TypeAlias
 
 from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
@@ -12,15 +13,18 @@ from pydantic_ai.profiles.anthropic import anthropic_model_profile
 from pydantic_ai.providers import Provider
 
 try:
-    from anthropic import AsyncAnthropic
-except ImportError as _import_error:  # pragma: no cover
+    from anthropic import AsyncAnthropic, AsyncAnthropicBedrock
+except ImportError as _import_error:
     raise ImportError(
         'Please install the `anthropic` package to use the Anthropic provider, '
         'you can use the `anthropic` optional group — `pip install "pydantic-ai-slim[anthropic]"`'
     ) from _import_error
 
 
-class AnthropicProvider(Provider[AsyncAnthropic]):
+AsyncAnthropicClient: TypeAlias = Union[AsyncAnthropic, AsyncAnthropicBedrock]
+
+
+class AnthropicProvider(Provider[AsyncAnthropicClient]):
     """Provider for Anthropic API."""
 
     @property
@@ -32,14 +36,14 @@ class AnthropicProvider(Provider[AsyncAnthropic]):
         return str(self._client.base_url)
 
     @property
-    def client(self) -> AsyncAnthropic:
+    def client(self) -> AsyncAnthropicClient:
         return self._client
 
     def model_profile(self, model_name: str) -> ModelProfile | None:
         return anthropic_model_profile(model_name)
 
     @overload
-    def __init__(self, *, anthropic_client: AsyncAnthropic | None = None) -> None: ...
+    def __init__(self, *, anthropic_client: AsyncAnthropicClient | None = None) -> None: ...
 
     @overload
     def __init__(self, *, api_key: str | None = None, http_client: httpx.AsyncClient | None = None) -> None: ...
@@ -48,7 +52,7 @@ class AnthropicProvider(Provider[AsyncAnthropic]):
         self,
         *,
         api_key: str | None = None,
-        anthropic_client: AsyncAnthropic | None = None,
+        anthropic_client: AsyncAnthropicClient | None = None,
         http_client: httpx.AsyncClient | None = None,
     ) -> None:
         """Create a new Anthropic provider.
@@ -71,7 +75,6 @@ class AnthropicProvider(Provider[AsyncAnthropic]):
                     'Set the `ANTHROPIC_API_KEY` environment variable or pass it via `AnthropicProvider(api_key=...)`'
                     'to use the Anthropic provider.'
                 )
-
             if http_client is not None:
                 self._client = AsyncAnthropic(api_key=api_key, http_client=http_client)
             else:

{pydantic_ai_slim-0.7.4.dist-info → pydantic_ai_slim-0.7.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.7.4
+Version: 0.7.5
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Project-URL: Homepage, https://github.com/pydantic/pydantic-ai/tree/main/pydantic_ai_slim
 Project-URL: Source, https://github.com/pydantic/pydantic-ai/tree/main/pydantic_ai_slim
@@ -35,7 +35,7 @@ Requires-Dist: genai-prices>=0.0.22
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.7.4
+Requires-Dist: pydantic-graph==0.7.5
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -57,9 +57,9 @@ Requires-Dist: cohere>=5.16.0; (platform_system != 'Emscripten') and extra == 'c
 Provides-Extra: duckduckgo
 Requires-Dist: ddgs>=9.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.7.4; extra == 'evals'
+Requires-Dist: pydantic-evals==0.7.5; extra == 'evals'
 Provides-Extra: google
-Requires-Dist: google-genai>=1.28.0; extra == 'google'
+Requires-Dist: google-genai>=1.31.0; extra == 'google'
 Provides-Extra: groq
 Requires-Dist: groq>=0.25.0; extra == 'groq'
 Provides-Extra: huggingface

{pydantic_ai_slim-0.7.4.dist-info → pydantic_ai_slim-0.7.5.dist-info}/RECORD

@@ -6,6 +6,7 @@ pydantic_ai/_cli.py,sha256=YNqV2Kb3KYpof0lD4wwnULM2sCxzsvBzsh-oPd6lJN8,13959
 pydantic_ai/_function_schema.py,sha256=YFHxb6bKfhgeY6rNdbuYXgndGCDanveUx2258xkSNlQ,11233
 pydantic_ai/_griffe.py,sha256=Ugft16ZHw9CN_6-lW0Svn6jESK9zHXO_x4utkGBkbBI,5253
 pydantic_ai/_mcp.py,sha256=PuvwnlLjv7YYOa9AZJCrklevBug99zGMhwJCBGG7BHQ,5626
+pydantic_ai/_otel_messages.py,sha256=C_t8Jj0tlbYPGS_Wuf5eSw_7n3SwDsFfLQjLl9hM_bk,1480
 pydantic_ai/_output.py,sha256=6Vxlw8F9nRWCkjy4qvFF8tmDi2xZn7Dq72T6s4C5kAM,37640
 pydantic_ai/_parts_manager.py,sha256=zrra5yDpAX8cFB_eK0btAp9d6NAR979V1Rmepm83l1w,17980
 pydantic_ai/_run_context.py,sha256=uSjR0a9QJ7KifqJsu7buGpK4wqexO7ldZMzWsBOboDI,1697
@@ -14,12 +15,12 @@ pydantic_ai/_thinking_part.py,sha256=x80-Vkon16GOyq3W6f2qzafTVPC5dCgF7QD3k8ZMmYU
 pydantic_ai/_tool_manager.py,sha256=WPMXgHBzyn7UgRKIuqU-oV2GpsAOW0nF2RsxPCKOp7U,9655
 pydantic_ai/_utils.py,sha256=Ge9rtu8NJvsfSFjx1MduITPr0-9b_I0emDFSpwJbYes,16372
 pydantic_ai/ag_ui.py,sha256=bd-RJYFFmcw2xkAWj-7N0ZLRMa1dam3LEhlgoNo1l9I,26475
-pydantic_ai/builtin_tools.py,sha256=ipo0q5DISc99k2xD453Yaw61v-3tCmlD2mDval9UCRU,3181
+pydantic_ai/builtin_tools.py,sha256=Fr9PF5RDdi5xQzKj7VJ8iDulbNgvF0yBdCC8E6F38Vo,3194
 pydantic_ai/direct.py,sha256=ym1Lb7oCPDU2eMmN8LXzN7Dp_IUJIPmlyKgmxxBUxsc,14905
 pydantic_ai/exceptions.py,sha256=vHRH_b6JpMi5p5EGhz2O4FSeKGJv3WMD291Y1FjHYFc,3528
 pydantic_ai/format_prompt.py,sha256=Or-Ytq55RQb1UJqy2HKIyPpZ-knWXfdDP3Z6tNc6Orw,4244
 pydantic_ai/mcp.py,sha256=n9_ECHmFE-eOZmb1bDh94oy81caefdtSGo1oH2KKWMo,31162
-pydantic_ai/messages.py,sha256=fPIicZ2J149x4cGSBbgeVahaDlnK6ChbMZ8gsZLPPfg,46099
+pydantic_ai/messages.py,sha256=G65-bCxQt3EpfD-uAFs-Pz8HXFeIqe2V-kvOeXRsaOg,50131
 pydantic_ai/output.py,sha256=54Cwd1RruXlA5hucZ1h-SxFrzKHJuLvYvLtH9iyg2GI,11988
 pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/result.py,sha256=gUVJIyoM1FewRFLj7ezuXr7M2RSaQL4AytoIpBMmDy8,19800
@@ -40,27 +41,27 @@ pydantic_ai/durable_exec/temporal/_agent.py,sha256=H1oHoZC9wOuAN79LG7Qb3DNtK2XFC
 pydantic_ai/durable_exec/temporal/_function_toolset.py,sha256=qKTs7T6YcJ2LBOvrlYBRUHd9zn86TuUaY0Qw5TPGSmE,3848
 pydantic_ai/durable_exec/temporal/_logfire.py,sha256=_dsvVIdpYJEUyoFUIDYQjCO6TjTITqvlJHwNy_Fi2cw,1866
 pydantic_ai/durable_exec/temporal/_mcp_server.py,sha256=J7CC4gRDhM4uQo3_kNKV7e4uiWC0He0AgS7bdq9Pt4o,6005
-pydantic_ai/durable_exec/temporal/_model.py,sha256=7_-f-n1JEg4YsJ8NGoB9RXpaAB-mWZZBR0wtGqa3NgE,6645
+pydantic_ai/durable_exec/temporal/_model.py,sha256=hHanoDWEi6FgSvFJ7HUJaAzE0aEFAj0VZ2sb0wQ-3EY,6765
 pydantic_ai/durable_exec/temporal/_run_context.py,sha256=5NTomzWBAlFcXeVw-4mqa76Rmrc8b3G1bB5ElVsAyCY,2310
 pydantic_ai/durable_exec/temporal/_toolset.py,sha256=XlQx7NGSKR9n-mjNWaTn-i3HW9X4z5fZUAM9DwDTBwY,2865
 pydantic_ai/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/ext/aci.py,sha256=sUllKDNO-LOMurbFgxwRHuzNlBkSa3aVBqXfEm-A_vo,2545
 pydantic_ai/ext/langchain.py,sha256=iLVEZv1kcLkdIHo3us2yfdi0kVqyJ6qTaCt9BoLWm4k,2335
-pydantic_ai/models/__init__.py,sha256=h29lgKzOx8fHV0wXHMmaaawn8xGpAuFFxQwZJx4ihvU,34637
-pydantic_ai/models/anthropic.py,sha256=WO-PGqtXZaFV9Oz9aHr-ADMc2qSr8TVep4tPmhWL_DI,30122
-pydantic_ai/models/bedrock.py,sha256=z-qs8RikRxClbhDNsbRcuZ1GsPlb-GjoV88QD6vXOtE,30723
-pydantic_ai/models/cohere.py,sha256=jZPMuFvNv9JTVCbC_p7_1Uxuc5WGn6RVFpH_pwG7iO0,13009
+pydantic_ai/models/__init__.py,sha256=tfMixYa06ByHDBo5A0NFNpMuwr8mXpiVgAp6JBBSYlU,34834
+pydantic_ai/models/anthropic.py,sha256=2Nhu_m_W9EdsbeUe4aAV-Jcdv7hPOG4OuI6DmRjSi2o,30464
+pydantic_ai/models/bedrock.py,sha256=8azpQUM4Z4haDM0kdrkUUcc88Jpu3ff6dybznyRJ20o,30940
+pydantic_ai/models/cohere.py,sha256=WosAOwDbxpeVpIX4swmaxL5XgfcfHwkoekt4UqVeNUQ,13066
 pydantic_ai/models/fallback.py,sha256=ftcYhl0oSOer0vYbLkaf7dfgI_3h0hk7hp07i1Wh9rI,5526
-pydantic_ai/models/function.py,sha256=dY1aCUwcVXot5e2jWApWMAMnKWkSeEH4vqoe6mTBBZ0,14139
-pydantic_ai/models/gemini.py,sha256=2KoN-sf5skHOkVcvbV5Zw4jGYanZX4n_K4jhyJVYK4U,39151
-pydantic_ai/models/google.py,sha256=46q5NF8hSUHAMNcGbFNqZgK_S24klWb2aAFelMYy79s,30891
-pydantic_ai/models/groq.py,sha256=kqegrHbeabp__jNwuib3k0vQTVpra7Gy3D_dwbH9vv8,20960
-pydantic_ai/models/huggingface.py,sha256=JcYDfZbkYsQ9KUlDwfraiWq7dbg8Q0FRKkx8Lv9IWjg,20182
-pydantic_ai/models/instrumented.py,sha256=wzdnuIIIgpMJ7zqhMf-S--ffg9YYEgn5WRkJE2cCwao,16307
+pydantic_ai/models/function.py,sha256=jSr55QtW1fFxoXNK3EgrmuCcaG0U6uh6q56q8hrI_To,14248
+pydantic_ai/models/gemini.py,sha256=GVSJWhB5Mlkb2uvaq_4BYYRLY59EgP-geCOgrtjbnUI,39369
+pydantic_ai/models/google.py,sha256=rF3x1FpXlmHy53PmNbRuuJJ9ozTnWGGMSo1MGJPw3m8,31408
+pydantic_ai/models/groq.py,sha256=n0V_8ZFeDK7sDk6gc_cAzsaoxjydUq46SzyvKM-gzoM,21202
+pydantic_ai/models/huggingface.py,sha256=7yxCiLHJe_M3S50W6VaRREyHbXn5DTm6558eKZUHiQE,20424
+pydantic_ai/models/instrumented.py,sha256=2RX7aSqtU01NAXt2-0TWeHIDNNmT_KCHd-8qG7bgaN8,19411
 pydantic_ai/models/mcp_sampling.py,sha256=iXIjwTP5Jszn0Iz-5MZiCk_BdUYE7IAxCnC5yIrGIu0,3436
-pydantic_ai/models/mistral.py,sha256=jNkzlEgqD1n0Fb3Yy9CFnlQ-Oi7pe7ixhXokqfrQFqg,32208
-pydantic_ai/models/openai.py,sha256=B6a2zDskBJITszwwmjncQLw4g9qAgZc5HgnlVhtGr7A,62939
-pydantic_ai/models/test.py,sha256=7J9bZOBwqQ3X0f5PT0_JakMPSB5UmIZ5ZFlX8hH45NU,19089
+pydantic_ai/models/mistral.py,sha256=5i_zl_pzo--Dll5OCT7vwCQmvvUt9cI5d19_NVHDRnM,32450
+pydantic_ai/models/openai.py,sha256=Y1OCpLL_QHOHpIs102Bp0aLB93UPbkUF_q6AMBzDi6Q,63497
+pydantic_ai/models/test.py,sha256=7D1l21iI5Kwp9Stdhdd-M8V_1PeofaffETKvB_SHV3Q,19277
 pydantic_ai/models/wrapper.py,sha256=9MeHW7mXPsEK03IKL0rtjeX6QgXyZROOOzLh72GiX2k,2148
 pydantic_ai/profiles/__init__.py,sha256=AdwFrK50_20qJBA_eMXXsV1vdGOvPxLVW82hMQvzXU0,3285
 pydantic_ai/profiles/_json_schema.py,sha256=CthOGmPSjgEZRRglfvg31zyQ9vjHDdacXoFpmba93dE,7206
@@ -77,7 +78,7 @@ pydantic_ai/profiles/moonshotai.py,sha256=e1RJnbEvazE6aJAqfmYLYGNtwNwg52XQDRDkcL
 pydantic_ai/profiles/openai.py,sha256=lSPM1tDiWVxQH45YzD_GjYsnkBzLankRFu5JRGfx81I,8112
 pydantic_ai/profiles/qwen.py,sha256=K4_nJ_oN5NS_9W0Fl-dFgC4emVRTHPXFTtiJ_nycKHo,373
 pydantic_ai/providers/__init__.py,sha256=-jb9Vl4gE7z0katqwLPaKt5UileuPp0Brq0ZueBVJys,4246
-pydantic_ai/providers/anthropic.py,sha256=D35UXxCPXv8yIbD0fj9Zg2FvNyoMoJMeDUtVM8Sn78I,3046
+pydantic_ai/providers/anthropic.py,sha256=i9Y7hAHWPTcPUsmRSxtD7QtNrEk5n3uvEtCkYWyipJ4,3200
 pydantic_ai/providers/azure.py,sha256=y77IHGiSQ9Ttx9f4SGMgdpin2Daq6eYyzUdM9ET22RQ,5819
 pydantic_ai/providers/bedrock.py,sha256=8jz77ySKv6CzCktN9YbZb1736gZM0d_btcKvXiZSSHI,5784
 pydantic_ai/providers/cohere.py,sha256=LT6QaLPJBBlFUgYgXQOfKpbM9SXLzorWFxI7jNfOX_4,2892
@@ -109,8 +110,8 @@ pydantic_ai/toolsets/prefixed.py,sha256=0KwcDkW8OM36ZUsOLVP5h-Nj2tPq78L3_E2c-1Fb
 pydantic_ai/toolsets/prepared.py,sha256=Zjfz6S8In6PBVxoKFN9sKPN984zO6t0awB7Lnq5KODw,1431
 pydantic_ai/toolsets/renamed.py,sha256=JuLHpi-hYPiSPlaTpN8WiXLiGsywYK0axi2lW2Qs75k,1637
 pydantic_ai/toolsets/wrapper.py,sha256=mMuMPdko9PJUdcsexlRXbwViSwKKJfv6JE58d8HK3ds,1646
-pydantic_ai_slim-0.7.4.dist-info/METADATA,sha256=_fszjpgjDIP3jR56uyk7fD4f2-mlZcqtupc1P2pyv0E,4661
-pydantic_ai_slim-0.7.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.7.4.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
-pydantic_ai_slim-0.7.4.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
-pydantic_ai_slim-0.7.4.dist-info/RECORD,,
+pydantic_ai_slim-0.7.5.dist-info/METADATA,sha256=UK0PS8ex-RsTV379rsLtBL9vifFciMESIoTLgjbrbec,4661
+pydantic_ai_slim-0.7.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.7.5.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
+pydantic_ai_slim-0.7.5.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_slim-0.7.5.dist-info/RECORD,,