pydantic-ai-slim 0.0.37__tar.gz → 0.0.39__tar.gz

{pydantic_ai_slim-0.0.37 → pydantic_ai_slim-0.0.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.37
+Version: 0.0.39
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -29,7 +29,7 @@ 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.0.37
+Requires-Dist: pydantic-graph==0.0.39
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: anthropic

{pydantic_ai_slim-0.0.37 → pydantic_ai_slim-0.0.39}/pydantic_ai/__init__.py

@@ -10,7 +10,7 @@ from .exceptions import (
     UsageLimitExceeded,
     UserError,
 )
-from .messages import AudioUrl, BinaryContent, ImageUrl
+from .messages import AudioUrl, BinaryContent, DocumentUrl, ImageUrl
 from .tools import RunContext, Tool
 
 __all__ = (
@@ -33,6 +33,7 @@ __all__ = (
     # messages
     'ImageUrl',
     'AudioUrl',
+    'DocumentUrl',
     'BinaryContent',
     # tools
     'Tool',

{pydantic_ai_slim-0.0.37 → pydantic_ai_slim-0.0.39}/pydantic_ai/messages.py

@@ -4,6 +4,7 @@ import uuid
 from collections.abc import Sequence
 from dataclasses import dataclass, field, replace
 from datetime import datetime
+from mimetypes import guess_type
 from typing import Annotated, Any, Literal, Union, cast, overload
 
 import pydantic
@@ -83,9 +84,57 @@ class ImageUrl:
         else:
             raise ValueError(f'Unknown image file extension: {self.url}')
 
+    @property
+    def format(self) -> ImageFormat:
+        """The file format of the image.
+
+        The choice of supported formats were based on the Bedrock Converse API. Other APIs don't require to use a format.
+        """
+        return _image_format(self.media_type)
+
+
+@dataclass
+class DocumentUrl:
+    """The URL of the document."""
+
+    url: str
+    """The URL of the document."""
+
+    kind: Literal['document-url'] = 'document-url'
+    """Type identifier, this is available on all parts as a discriminator."""
+
+    @property
+    def media_type(self) -> str:
+        """Return the media type of the document, based on the url."""
+        type_, _ = guess_type(self.url)
+        if type_ is None:
+            raise RuntimeError(f'Unknown document file extension: {self.url}')
+        return type_
+
+    @property
+    def format(self) -> DocumentFormat:
+        """The file format of the document.
+
+        The choice of supported formats were based on the Bedrock Converse API. Other APIs don't require to use a format.
+        """
+        return _document_format(self.media_type)
+
 
 AudioMediaType: TypeAlias = Literal['audio/wav', 'audio/mpeg']
 ImageMediaType: TypeAlias = Literal['image/jpeg', 'image/png', 'image/gif', 'image/webp']
+DocumentMediaType: TypeAlias = Literal[
+    'application/pdf',
+    'text/plain',
+    'text/csv',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'text/html',
+    'text/markdown',
+    'application/vnd.ms-excel',
+]
+AudioFormat: TypeAlias = Literal['wav', 'mp3']
+ImageFormat: TypeAlias = Literal['jpeg', 'png', 'gif', 'webp']
+DocumentFormat: TypeAlias = Literal['csv', 'doc', 'docx', 'html', 'md', 'pdf', 'txt', 'xls', 'xlsx']
 
 
 @dataclass
@@ -95,7 +144,7 @@ class BinaryContent:
     data: bytes
     """The binary data."""
 
-    media_type: AudioMediaType | ImageMediaType | str
+    media_type: AudioMediaType | ImageMediaType | DocumentMediaType | str
     """The media type of the binary data."""
 
     kind: Literal['binary'] = 'binary'
@@ -112,17 +161,69 @@ class BinaryContent:
         return self.media_type.startswith('image/')
 
     @property
-    def audio_format(self) -> Literal['mp3', 'wav']:
-        """Return the audio format given the media type."""
-        if self.media_type == 'audio/mpeg':
-            return 'mp3'
-        elif self.media_type == 'audio/wav':
-            return 'wav'
-        else:
-            raise ValueError(f'Unknown audio media type: {self.media_type}')
+    def is_document(self) -> bool:
+        """Return `True` if the media type is a document type."""
+        return self.media_type in {
+            'application/pdf',
+            'text/plain',
+            'text/csv',
+            'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            'text/html',
+            'text/markdown',
+            'application/vnd.ms-excel',
+        }
 
-
-UserContent: TypeAlias = 'str | ImageUrl | AudioUrl | BinaryContent'
+    @property
+    def format(self) -> str:
+        """The file format of the binary content."""
+        if self.is_audio:
+            if self.media_type == 'audio/mpeg':
+                return 'mp3'
+            elif self.media_type == 'audio/wav':
+                return 'wav'
+        elif self.is_image:
+            return _image_format(self.media_type)
+        elif self.is_document:
+            return _document_format(self.media_type)
+        raise ValueError(f'Unknown media type: {self.media_type}')
+
+
+UserContent: TypeAlias = 'str | ImageUrl | AudioUrl | DocumentUrl | BinaryContent'
+
+
+def _document_format(media_type: str) -> DocumentFormat:
+    if media_type == 'application/pdf':
+        return 'pdf'
+    elif media_type == 'text/plain':
+        return 'txt'
+    elif media_type == 'text/csv':
+        return 'csv'
+    elif media_type == 'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
+        return 'docx'
+    elif media_type == 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet':
+        return 'xlsx'
+    elif media_type == 'text/html':
+        return 'html'
+    elif media_type == 'text/markdown':
+        return 'md'
+    elif media_type == 'application/vnd.ms-excel':
+        return 'xls'
+    else:
+        raise ValueError(f'Unknown document media type: {media_type}')
+
+
+def _image_format(media_type: str) -> ImageFormat:
+    if media_type == 'image/jpeg':
+        return 'jpeg'
+    elif media_type == 'image/png':
+        return 'png'
+    elif media_type == 'image/gif':
+        return 'gif'
+    elif media_type == 'image/webp':
+        return 'webp'
+    else:
+        raise ValueError(f'Unknown image media type: {media_type}')
 
 
 @dataclass

{pydantic_ai_slim-0.0.37 → pydantic_ai_slim-0.0.39}/pydantic_ai/models/anthropic.py

@@ -9,6 +9,7 @@ from datetime import datetime, timezone
 from json import JSONDecodeError, loads as json_loads
 from typing import Any, Literal, Union, cast, overload
 
+from anthropic.types import DocumentBlockParam
 from httpx import AsyncClient as AsyncHTTPClient
 from typing_extensions import assert_never
 
@@ -16,6 +17,7 @@ from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
 from .._utils import guard_tool_call_id as _guard_tool_call_id
 from ..messages import (
     BinaryContent,
+    DocumentUrl,
     ImageUrl,
     ModelMessage,
     ModelRequest,
@@ -42,11 +44,13 @@ from . import (
 try:
     from anthropic import NOT_GIVEN, APIStatusError, AsyncAnthropic, AsyncStream
     from anthropic.types import (
+        Base64PDFSourceParam,
         ContentBlock,
         ImageBlockParam,
         Message as AnthropicMessage,
         MessageParam,
         MetadataParam,
+        PlainTextSourceParam,
         RawContentBlockDeltaEvent,
         RawContentBlockStartEvent,
         RawContentBlockStopEvent,
@@ -288,7 +292,9 @@ class AnthropicModel(Model):
         anthropic_messages: list[MessageParam] = []
         for m in messages:
             if isinstance(m, ModelRequest):
-                user_content_params: list[ToolResultBlockParam | TextBlockParam | ImageBlockParam] = []
+                user_content_params: list[
+                    ToolResultBlockParam | TextBlockParam | ImageBlockParam | DocumentBlockParam
+                ] = []
                 for request_part in m.parts:
                     if isinstance(request_part, SystemPromptPart):
                         system_prompt += request_part.content
@@ -334,7 +340,9 @@ class AnthropicModel(Model):
         return system_prompt, anthropic_messages
 
     @staticmethod
-    async def _map_user_prompt(part: UserPromptPart) -> AsyncGenerator[ImageBlockParam | TextBlockParam]:
+    async def _map_user_prompt(
+        part: UserPromptPart,
+    ) -> AsyncGenerator[ImageBlockParam | TextBlockParam | DocumentBlockParam]:
         if isinstance(part.content, str):
             yield TextBlockParam(text=part.content, type='text')
         else:
@@ -379,6 +387,25 @@ class AnthropicModel(Model):
                             )
                         else:  # pragma: no cover
                             raise RuntimeError(f'Unsupported image type: {mime_type}')
+                elif isinstance(item, DocumentUrl):
+                    response = await cached_async_http_client().get(item.url)
+                    response.raise_for_status()
+                    if item.media_type == 'application/pdf':
+                        yield DocumentBlockParam(
+                            source=Base64PDFSourceParam(
+                                data=io.BytesIO(response.content),
+                                media_type=item.media_type,
+                                type='base64',
+                            ),
+                            type='document',
+                        )
+                    elif item.media_type == 'text/plain':
+                        yield DocumentBlockParam(
+                            source=PlainTextSourceParam(data=response.text, media_type=item.media_type, type='text'),
+                            type='document',
+                        )
+                    else:  # pragma: no cover
+                        raise RuntimeError(f'Unsupported media type: {item.media_type}')
                 else:
                     raise RuntimeError(f'Unsupported content type: {type(item)}')
 

{pydantic_ai_slim-0.0.37 → pydantic_ai_slim-0.0.39}/pydantic_ai/models/bedrock.py

@@ -14,6 +14,10 @@ from typing_extensions import ParamSpec, assert_never
 
 from pydantic_ai import _utils, result
 from pydantic_ai.messages import (
+    AudioUrl,
+    BinaryContent,
+    DocumentUrl,
+    ImageUrl,
     ModelMessage,
     ModelRequest,
     ModelResponse,
@@ -26,7 +30,7 @@ from pydantic_ai.messages import (
     ToolReturnPart,
     UserPromptPart,
 )
-from pydantic_ai.models import Model, ModelRequestParameters, StreamedResponse
+from pydantic_ai.models import Model, ModelRequestParameters, StreamedResponse, cached_async_http_client
 from pydantic_ai.providers import Provider, infer_provider
 from pydantic_ai.settings import ModelSettings
 from pydantic_ai.tools import ToolDefinition
@@ -37,9 +41,11 @@ if TYPE_CHECKING:
     from mypy_boto3_bedrock_runtime import BedrockRuntimeClient
     from mypy_boto3_bedrock_runtime.type_defs import (
         ContentBlockOutputTypeDef,
+        ContentBlockUnionTypeDef,
         ConverseResponseTypeDef,
         ConverseStreamMetadataEventTypeDef,
         ConverseStreamOutputTypeDef,
+        ImageBlockTypeDef,
         InferenceConfigurationTypeDef,
         MessageUnionTypeDef,
         ToolChoiceTypeDef,
@@ -244,7 +250,7 @@ class BedrockConverseModel(Model):
         else:
             tool_choice = {'auto': {}}
 
-        system_prompt, bedrock_messages = self._map_message(messages)
+        system_prompt, bedrock_messages = await self._map_message(messages)
         inference_config = self._map_inference_config(model_settings)
 
         params = {
@@ -285,7 +291,7 @@ class BedrockConverseModel(Model):
 
         return inference_config
 
-    def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[MessageUnionTypeDef]]:
+    async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[MessageUnionTypeDef]]:
         """Just maps a `pydantic_ai.Message` to the Bedrock `MessageUnionTypeDef`."""
         system_prompt: str = ''
         bedrock_messages: list[MessageUnionTypeDef] = []
@@ -295,10 +301,7 @@ class BedrockConverseModel(Model):
                     if isinstance(part, SystemPromptPart):
                         system_prompt += part.content
                     elif isinstance(part, UserPromptPart):
-                        if isinstance(part.content, str):
-                            bedrock_messages.append({'role': 'user', 'content': [{'text': part.content}]})
-                        else:
-                            raise NotImplementedError('User prompt can only be a string for now.')
+                        bedrock_messages.extend(await self._map_user_prompt(part))
                     elif isinstance(part, ToolReturnPart):
                         assert part.tool_call_id is not None
                         bedrock_messages.append(
@@ -348,6 +351,47 @@ class BedrockConverseModel(Model):
                 assert_never(m)
         return system_prompt, bedrock_messages
 
+    @staticmethod
+    async def _map_user_prompt(part: UserPromptPart) -> list[MessageUnionTypeDef]:
+        content: list[ContentBlockUnionTypeDef] = []
+        if isinstance(part.content, str):
+            content.append({'text': part.content})
+        else:
+            document_count = 0
+            for item in part.content:
+                if isinstance(item, str):
+                    content.append({'text': item})
+                elif isinstance(item, BinaryContent):
+                    format = item.format
+                    if item.is_document:
+                        document_count += 1
+                        name = f'Document {document_count}'
+                        assert format in ('pdf', 'txt', 'csv', 'doc', 'docx', 'xls', 'xlsx', 'html', 'md')
+                        content.append({'document': {'name': name, 'format': format, 'source': {'bytes': item.data}}})
+                    elif item.is_image:
+                        assert format in ('jpeg', 'png', 'gif', 'webp')
+                        content.append({'image': {'format': format, 'source': {'bytes': item.data}}})
+                    else:
+                        raise NotImplementedError('Binary content is not supported yet.')
+                elif isinstance(item, (ImageUrl, DocumentUrl)):
+                    response = await cached_async_http_client().get(item.url)
+                    response.raise_for_status()
+                    if item.kind == 'image-url':
+                        format = item.media_type.split('/')[1]
+                        assert format in ('jpeg', 'png', 'gif', 'webp'), f'Unsupported image format: {format}'
+                        image: ImageBlockTypeDef = {'format': format, 'source': {'bytes': response.content}}
+                        content.append({'image': image})
+                    elif item.kind == 'document-url':
+                        document_count += 1
+                        name = f'Document {document_count}'
+                        data = response.content
+                        content.append({'document': {'name': name, 'format': item.format, 'source': {'bytes': data}}})
+                elif isinstance(item, AudioUrl):  # pragma: no cover
+                    raise NotImplementedError('Audio is not supported yet.')
+                else:
+                    assert_never(item)
+        return [{'role': 'user', 'content': content}]
+
     @staticmethod
     def _map_tool_call(t: ToolCallPart) -> ContentBlockOutputTypeDef:
         assert t.tool_call_id is not None

{pydantic_ai_slim-0.0.37 → pydantic_ai_slim-0.0.39}/pydantic_ai/models/fallback.py

@@ -61,7 +61,9 @@ class FallbackModel(Model):
 
         for model in self.models:
             try:
-                return await model.request(messages, model_settings, model_request_parameters)
+                response, usage = await model.request(messages, model_settings, model_request_parameters)
+                response.model_used = model  # type: ignore
+                return response, usage
             except Exception as exc:
                 if self._fallback_on(exc):
                     exceptions.append(exc)

{pydantic_ai_slim-0.0.37 → pydantic_ai_slim-0.0.39}/pydantic_ai/models/gemini.py

@@ -21,6 +21,7 @@ from .. import ModelHTTPError, UnexpectedModelBehavior, UserError, _utils, usage
 from ..messages import (
     AudioUrl,
     BinaryContent,
+    DocumentUrl,
     ImageUrl,
     ModelMessage,
     ModelRequest,
@@ -362,22 +363,15 @@ class GeminiModel(Model):
                     content.append(
                         _GeminiInlineDataPart(inline_data={'data': base64_encoded, 'mime_type': item.media_type})
                     )
-                elif isinstance(item, (AudioUrl, ImageUrl)):
-                    try:
-                        content.append(
-                            _GeminiFileDataPart(file_data={'file_uri': item.url, 'mime_type': item.media_type})
-                        )
-                    except ValueError:
-                        # Download the file if can't find the mime type.
-                        client = cached_async_http_client()
-                        response = await client.get(item.url, follow_redirects=True)
-                        response.raise_for_status()
-                        base64_encoded = base64.b64encode(response.content).decode('utf-8')
-                        content.append(
-                            _GeminiInlineDataPart(
-                                inline_data={'data': base64_encoded, 'mime_type': response.headers['Content-Type']}
-                            )
-                        )
+                elif isinstance(item, (AudioUrl, ImageUrl, DocumentUrl)):
+                    client = cached_async_http_client()
+                    response = await client.get(item.url, follow_redirects=True)
+                    response.raise_for_status()
+                    mime_type = response.headers['Content-Type'].split(';')[0]
+                    inline_data = _GeminiInlineDataPart(
+                        inline_data={'data': base64.b64encode(response.content).decode('utf-8'), 'mime_type': mime_type}
+                    )
+                    content.append(inline_data)
                 else:
                     assert_never(item)
         return content

{pydantic_ai_slim-0.0.37 → pydantic_ai_slim-0.0.39}/pydantic_ai/models/groq.py

@@ -9,12 +9,13 @@ from itertools import chain
 from typing import Literal, Union, cast, overload
 
 from httpx import AsyncClient as AsyncHTTPClient
-from typing_extensions import assert_never
+from typing_extensions import assert_never, deprecated
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
 from .._utils import guard_tool_call_id as _guard_tool_call_id
 from ..messages import (
     BinaryContent,
+    DocumentUrl,
     ImageUrl,
     ModelMessage,
     ModelRequest,
@@ -28,15 +29,10 @@ from ..messages import (
     ToolReturnPart,
     UserPromptPart,
 )
+from ..providers import Provider, infer_provider
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
-from . import (
-    Model,
-    ModelRequestParameters,
-    StreamedResponse,
-    cached_async_http_client,
-    check_allow_model_requests,
-)
+from . import Model, ModelRequestParameters, StreamedResponse, cached_async_http_client, check_allow_model_requests
 
 try:
     from groq import NOT_GIVEN, APIStatusError, AsyncGroq, AsyncStream
@@ -48,6 +44,7 @@ except ImportError as _import_error:
         "you can use the `groq` optional group — `pip install 'pydantic-ai-slim[groq]'`"
     ) from _import_error
 
+
 LatestGroqModelNames = Literal[
     'llama-3.3-70b-versatile',
     'llama-3.3-70b-specdec',
@@ -93,10 +90,31 @@ class GroqModel(Model):
     _model_name: GroqModelName = field(repr=False)
     _system: str | None = field(default='groq', repr=False)
 
+    @overload
+    def __init__(
+        self,
+        model_name: GroqModelName,
+        *,
+        provider: Literal['groq'] | Provider[AsyncGroq] = 'groq',
+    ) -> None: ...
+
+    @deprecated('Use the `provider` parameter instead of `api_key`, `groq_client`, and `http_client`.')
+    @overload
     def __init__(
         self,
         model_name: GroqModelName,
         *,
+        provider: None = None,
+        api_key: str | None = None,
+        groq_client: AsyncGroq | None = None,
+        http_client: AsyncHTTPClient | None = None,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        model_name: GroqModelName,
+        *,
+        provider: Literal['groq'] | Provider[AsyncGroq] | None = None,
         api_key: str | None = None,
         groq_client: AsyncGroq | None = None,
         http_client: AsyncHTTPClient | None = None,
@@ -106,6 +124,9 @@ class GroqModel(Model):
         Args:
             model_name: The name of the Groq model to use. List of model names available
                 [here](https://console.groq.com/docs/models).
+            provider: The provider to use for authentication and API access. Can be either the string
+                'groq' or an instance of `Provider[AsyncGroq]`. If not provided, a new provider will be
+                created using the other parameters.
             api_key: The API key to use for authentication, if not provided, the `GROQ_API_KEY` environment variable
                 will be used if available.
             groq_client: An existing
@@ -114,7 +135,13 @@ class GroqModel(Model):
             http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
         """
         self._model_name = model_name
-        if groq_client is not None:
+
+        if provider is not None:
+            if isinstance(provider, str):
+                self.client = infer_provider(provider).client
+            else:
+                self.client = provider.client
+        elif groq_client is not None:
             assert http_client is None, 'Cannot provide both `groq_client` and `http_client`'
             assert api_key is None, 'Cannot provide both `groq_client` and `api_key`'
             self.client = groq_client
@@ -342,8 +369,11 @@ class GroqModel(Model):
                         content.append(chat.ChatCompletionContentPartImageParam(image_url=image_url, type='image_url'))
                     else:
                         raise RuntimeError('Only images are supported for binary content in Groq.')
+                elif isinstance(item, DocumentUrl):  # pragma: no cover
+                    raise RuntimeError('DocumentUrl is not supported in Groq.')
                 else:  # pragma: no cover
                     raise RuntimeError(f'Unsupported content type: {type(item)}')
+
         return chat.ChatCompletionUserMessageParam(role='user', content=content)
 
 

{pydantic_ai_slim-0.0.37 → pydantic_ai_slim-0.0.39}/pydantic_ai/models/instrumented.py

@@ -88,6 +88,10 @@ class InstrumentationSettings:
         self.event_mode = event_mode
 
 
+GEN_AI_SYSTEM_ATTRIBUTE = 'gen_ai.system'
+GEN_AI_REQUEST_MODEL_ATTRIBUTE = 'gen_ai.request.model'
+
+
 @dataclass
 class InstrumentedModel(WrapperModel):
     """Model which is instrumented with OpenTelemetry."""
@@ -138,27 +142,14 @@ class InstrumentedModel(WrapperModel):
         model_settings: ModelSettings | None,
     ) -> Iterator[Callable[[ModelResponse, Usage], None]]:
         operation = 'chat'
-        model_name = self.model_name
-        span_name = f'{operation} {model_name}'
-        system = getattr(self.wrapped, 'system', '') or self.wrapped.__class__.__name__.removesuffix('Model').lower()
-        system = {'google-gla': 'gemini', 'google-vertex': 'vertex_ai', 'mistral': 'mistral_ai'}.get(system, system)
+        span_name = f'{operation} {self.model_name}'
         # TODO Missing attributes:
         #  - error.type: unclear if we should do something here or just always rely on span exceptions
         #  - gen_ai.request.stop_sequences/top_k: model_settings doesn't include these
         attributes: dict[str, AttributeValue] = {
             'gen_ai.operation.name': operation,
-            'gen_ai.system': system,
-            'gen_ai.request.model': model_name,
+            **self.model_attributes(self.wrapped),
         }
-        if base_url := self.wrapped.base_url:
-            try:
-                parsed = urlparse(base_url)
-                if parsed.hostname:
-                    attributes['server.address'] = parsed.hostname
-                if parsed.port:
-                    attributes['server.port'] = parsed.port
-            except Exception:  # pragma: no cover
-                pass
 
         if model_settings:
             for key in MODEL_SETTING_ATTRIBUTES:
@@ -183,21 +174,26 @@ class InstrumentedModel(WrapperModel):
                             },
                         )
                     )
-                span.set_attributes(
-                    {
-                        # TODO finish_reason (https://github.com/open-telemetry/semantic-conventions/issues/1277), id
-                        #  https://github.com/pydantic/pydantic-ai/issues/886
-                        'gen_ai.response.model': response.model_name or model_name,
-                        **usage.opentelemetry_attributes(),
+                new_attributes: dict[str, AttributeValue] = usage.opentelemetry_attributes()  # type: ignore
+                if model_used := getattr(response, 'model_used', None):
+                    # FallbackModel sets model_used on the response so that we can report the attributes
+                    # of the model that was actually used.
+                    new_attributes.update(self.model_attributes(model_used))
+                    attributes.update(new_attributes)
+                request_model = attributes[GEN_AI_REQUEST_MODEL_ATTRIBUTE]
+                new_attributes['gen_ai.response.model'] = response.model_name or request_model
+                span.set_attributes(new_attributes)
+                span.update_name(f'{operation} {request_model}')
+                for event in events:
+                    event.attributes = {
+                        GEN_AI_SYSTEM_ATTRIBUTE: attributes[GEN_AI_SYSTEM_ATTRIBUTE],
+                        **(event.attributes or {}),
                     }
-                )
-                self._emit_events(system, span, events)
+                self._emit_events(span, events)
 
             yield finish
 
-    def _emit_events(self, system: str, span: Span, events: list[Event]) -> None:
-        for event in events:
-            event.attributes = {'gen_ai.system': system, **(event.attributes or {})}
+    def _emit_events(self, span: Span, events: list[Event]) -> None:
         if self.options.event_mode == 'logs':
             for event in events:
                 self.options.event_logger.emit(event)
@@ -215,6 +211,27 @@ class InstrumentedModel(WrapperModel):
                 }
             )
 
+    @staticmethod
+    def model_attributes(model: Model):
+        system = getattr(model, 'system', '') or model.__class__.__name__.removesuffix('Model').lower()
+        system = {'google-gla': 'gemini', 'google-vertex': 'vertex_ai', 'mistral': 'mistral_ai'}.get(system, system)
+        attributes: dict[str, AttributeValue] = {
+            GEN_AI_SYSTEM_ATTRIBUTE: system,
+            GEN_AI_REQUEST_MODEL_ATTRIBUTE: model.model_name,
+        }
+        if base_url := model.base_url:
+            try:
+                parsed = urlparse(base_url)
+            except Exception:  # pragma: no cover
+                pass
+            else:
+                if parsed.hostname:
+                    attributes['server.address'] = parsed.hostname
+                if parsed.port:
+                    attributes['server.port'] = parsed.port
+
+        return attributes
+
     @staticmethod
     def event_to_dict(event: Event) -> dict[str, Any]:
         if not event.body:

{pydantic_ai_slim-0.0.37 → pydantic_ai_slim-0.0.39}/pydantic_ai/models/mistral.py

@@ -17,6 +17,7 @@ from .. import ModelHTTPError, UnexpectedModelBehavior, _utils
 from .._utils import now_utc as _now_utc
 from ..messages import (
     BinaryContent,
+    DocumentUrl,
     ImageUrl,
     ModelMessage,
     ModelRequest,
@@ -495,6 +496,8 @@ class MistralModel(Model):
                         content.append(MistralImageURLChunk(image_url=image_url, type='image_url'))
                     else:
                         raise RuntimeError('Only image binary content is supported for Mistral.')
+                elif isinstance(item, DocumentUrl):
+                    raise RuntimeError('DocumentUrl is not supported in Mistral.')
                 else:  # pragma: no cover
                     raise RuntimeError(f'Unsupported content type: {type(item)}')
         return MistralUserMessage(content=content)

{pydantic_ai_slim-0.0.37 → pydantic_ai_slim-0.0.39}/pydantic_ai/models/openai.py

@@ -18,6 +18,7 @@ from .._utils import guard_tool_call_id as _guard_tool_call_id
 from ..messages import (
     AudioUrl,
     BinaryContent,
+    DocumentUrl,
     ImageUrl,
     ModelMessage,
     ModelRequest,
@@ -418,7 +419,8 @@ class OpenAIModel(Model):
                         image_url = ImageURL(url=f'data:{item.media_type};base64,{base64_encoded}')
                         content.append(ChatCompletionContentPartImageParam(image_url=image_url, type='image_url'))
                     elif item.is_audio:
-                        audio = InputAudio(data=base64_encoded, format=item.audio_format)
+                        assert item.format in ('wav', 'mp3')
+                        audio = InputAudio(data=base64_encoded, format=item.format)
                         content.append(ChatCompletionContentPartInputAudioParam(input_audio=audio, type='input_audio'))
                     else:  # pragma: no cover
                         raise RuntimeError(f'Unsupported binary content type: {item.media_type}')
@@ -429,6 +431,25 @@ class OpenAIModel(Model):
                     base64_encoded = base64.b64encode(response.content).decode('utf-8')
                     audio = InputAudio(data=base64_encoded, format=response.headers.get('content-type'))
                     content.append(ChatCompletionContentPartInputAudioParam(input_audio=audio, type='input_audio'))
+                elif isinstance(item, DocumentUrl):  # pragma: no cover
+                    raise NotImplementedError('DocumentUrl is not supported for OpenAI')
+                    # The following implementation should have worked, but it seems we have the following error:
+                    # pydantic_ai.exceptions.ModelHTTPError: status_code: 400, model_name: gpt-4o, body:
+                    # {
+                    #   'message': "Unknown parameter: 'messages[1].content[1].file.data'.",
+                    #   'type': 'invalid_request_error',
+                    #   'param': 'messages[1].content[1].file.data',
+                    #   'code': 'unknown_parameter'
+                    # }
+                    #
+                    # client = cached_async_http_client()
+                    # response = await client.get(item.url)
+                    # response.raise_for_status()
+                    # base64_encoded = base64.b64encode(response.content).decode('utf-8')
+                    # media_type = response.headers.get('content-type').split(';')[0]
+                    # file_data = f'data:{media_type};base64,{base64_encoded}'
+                    # file = File(file={'file_data': file_data, 'file_name': item.url, 'file_id': item.url}, type='file')
+                    # content.append(file)
                 else:
                     assert_never(item)
         return chat.ChatCompletionUserMessageParam(role='user', content=content)

{pydantic_ai_slim-0.0.37 → pydantic_ai_slim-0.0.39}/pydantic_ai/providers/__init__.py

@@ -65,5 +65,9 @@ def infer_provider(provider: str) -> Provider[Any]:
         from .bedrock import BedrockProvider
 
         return BedrockProvider()
+    elif provider == 'groq':
+        from .groq import GroqProvider
+
+        return GroqProvider()
     else:  # pragma: no cover
         raise ValueError(f'Unknown provider: {provider}')

pydantic_ai_slim-0.0.39/pydantic_ai/providers/groq.py

@@ -0,0 +1,75 @@
+from __future__ import annotations as _annotations
+
+import os
+from typing import overload
+
+from httpx import AsyncClient as AsyncHTTPClient
+
+from pydantic_ai.models import cached_async_http_client
+
+try:
+    from groq import AsyncGroq
+except ImportError as _import_error:  # pragma: no cover
+    raise ImportError(
+        'Please install `groq` to use the Groq provider, '
+        "you can use the `groq` optional group — `pip install 'pydantic-ai-slim[groq]'`"
+    ) from _import_error
+
+
+from . import Provider
+
+
+class GroqProvider(Provider[AsyncGroq]):
+    """Provider for Groq API."""
+
+    @property
+    def name(self) -> str:
+        return 'groq'
+
+    @property
+    def base_url(self) -> str:
+        return os.environ.get('GROQ_BASE_URL', 'https://api.groq.com')
+
+    @property
+    def client(self) -> AsyncGroq:
+        return self._client
+
+    @overload
+    def __init__(self, *, groq_client: AsyncGroq | None = None) -> None: ...
+
+    @overload
+    def __init__(self, *, api_key: str | None = None, http_client: AsyncHTTPClient | None = None) -> None: ...
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        groq_client: AsyncGroq | None = None,
+        http_client: AsyncHTTPClient | None = None,
+    ) -> None:
+        """Create a new Groq provider.
+
+        Args:
+            api_key: The API key to use for authentication, if not provided, the `GROQ_API_KEY` environment variable
+                will be used if available.
+            groq_client: An existing
+                [`AsyncGroq`](https://github.com/groq/groq-python?tab=readme-ov-file#async-usage)
+                client to use. If provided, `api_key` and `http_client` must be `None`.
+            http_client: An existing `AsyncHTTPClient` to use for making HTTP requests.
+        """
+        api_key = api_key or os.environ.get('GROQ_API_KEY')
+
+        if api_key is None and groq_client is None:
+            raise ValueError(
+                'Set the `GROQ_API_KEY` environment variable or pass it via `GroqProvider(api_key=...)`'
+                'to use the Groq provider.'
+            )
+
+        if groq_client is not None:
+            assert http_client is None, 'Cannot provide both `groq_client` and `http_client`'
+            assert api_key is None, 'Cannot provide both `groq_client` and `api_key`'
+            self._client = groq_client
+        elif http_client is not None:
+            self._client = AsyncGroq(base_url=self.base_url, api_key=api_key, http_client=http_client)
+        else:
+            self._client = AsyncGroq(base_url=self.base_url, api_key=api_key, http_client=cached_async_http_client())

{pydantic_ai_slim-0.0.37 → pydantic_ai_slim-0.0.39}/pydantic_ai/usage.py

@@ -64,7 +64,7 @@ class Usage:
         }
         for key, value in (self.details or {}).items():
             result[f'gen_ai.usage.details.{key}'] = value
-        return {k: v for k, v in result.items() if v is not None}
+        return {k: v for k, v in result.items() if v}
 
 
 @dataclass

{pydantic_ai_slim-0.0.37 → pydantic_ai_slim-0.0.39}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pydantic-ai-slim"
-version = "0.0.37"
+version = "0.0.39"
 description = "Agent Framework / shim to use Pydantic with LLMs, slim package"
 authors = [{ name = "Samuel Colvin", email = "samuel@pydantic.dev" }]
 license = "MIT"
@@ -36,7 +36,7 @@ dependencies = [
     "griffe>=1.3.2",
     "httpx>=0.27",
     "pydantic>=2.10",
-    "pydantic-graph==0.0.37",
+    "pydantic-graph==0.0.39",
     "exceptiongroup; python_version < '3.11'",
     "opentelemetry-api>=1.28.0",
     "typing-inspection>=0.4.0",