pydantic-ai-slim 0.0.36__tar.gz → 0.0.38__tar.gz

{pydantic_ai_slim-0.0.36 → pydantic_ai_slim-0.0.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.36
+Version: 0.0.38
 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.36
+Requires-Dist: pydantic-graph==0.0.38
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: anthropic

{pydantic_ai_slim-0.0.36 → pydantic_ai_slim-0.0.38}/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.36 → pydantic_ai_slim-0.0.38}/pydantic_ai/agent.py

@@ -922,6 +922,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         self,
         /,
         *,
+        name: str | None = None,
         retries: int | None = None,
         prepare: ToolPrepareFunc[AgentDepsT] | None = None,
         docstring_format: DocstringFormat = 'auto',
@@ -933,6 +934,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         func: ToolFuncContext[AgentDepsT, ToolParams] | None = None,
         /,
         *,
+        name: str | None = None,
         retries: int | None = None,
         prepare: ToolPrepareFunc[AgentDepsT] | None = None,
         docstring_format: DocstringFormat = 'auto',
@@ -969,6 +971,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
 
         Args:
             func: The tool function to register.
+            name: The name of the tool, defaults to the function name.
             retries: The number of retries to allow for this tool, defaults to the agent's default retries,
                 which defaults to 1.
             prepare: custom method to prepare the tool definition for each step, return `None` to omit this
@@ -984,13 +987,17 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
                 func_: ToolFuncContext[AgentDepsT, ToolParams],
             ) -> ToolFuncContext[AgentDepsT, ToolParams]:
                 # noinspection PyTypeChecker
-                self._register_function(func_, True, retries, prepare, docstring_format, require_parameter_descriptions)
+                self._register_function(
+                    func_, True, name, retries, prepare, docstring_format, require_parameter_descriptions
+                )
                 return func_
 
             return tool_decorator
         else:
             # noinspection PyTypeChecker
-            self._register_function(func, True, retries, prepare, docstring_format, require_parameter_descriptions)
+            self._register_function(
+                func, True, name, retries, prepare, docstring_format, require_parameter_descriptions
+            )
             return func
 
     @overload
@@ -1001,6 +1008,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         self,
         /,
         *,
+        name: str | None = None,
         retries: int | None = None,
         prepare: ToolPrepareFunc[AgentDepsT] | None = None,
         docstring_format: DocstringFormat = 'auto',
@@ -1012,6 +1020,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         func: ToolFuncPlain[ToolParams] | None = None,
         /,
         *,
+        name: str | None = None,
         retries: int | None = None,
         prepare: ToolPrepareFunc[AgentDepsT] | None = None,
         docstring_format: DocstringFormat = 'auto',
@@ -1048,6 +1057,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
 
         Args:
             func: The tool function to register.
+            name: The name of the tool, defaults to the function name.
             retries: The number of retries to allow for this tool, defaults to the agent's default retries,
                 which defaults to 1.
             prepare: custom method to prepare the tool definition for each step, return `None` to omit this
@@ -1062,19 +1072,22 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
             def tool_decorator(func_: ToolFuncPlain[ToolParams]) -> ToolFuncPlain[ToolParams]:
                 # noinspection PyTypeChecker
                 self._register_function(
-                    func_, False, retries, prepare, docstring_format, require_parameter_descriptions
+                    func_, False, name, retries, prepare, docstring_format, require_parameter_descriptions
                 )
                 return func_
 
             return tool_decorator
         else:
-            self._register_function(func, False, retries, prepare, docstring_format, require_parameter_descriptions)
+            self._register_function(
+                func, False, name, retries, prepare, docstring_format, require_parameter_descriptions
+            )
             return func
 
     def _register_function(
         self,
         func: ToolFuncEither[AgentDepsT, ToolParams],
         takes_ctx: bool,
+        name: str | None,
         retries: int | None,
         prepare: ToolPrepareFunc[AgentDepsT] | None,
         docstring_format: DocstringFormat,
@@ -1085,6 +1098,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         tool = Tool[AgentDepsT](
             func,
             takes_ctx=takes_ctx,
+            name=name,
             max_retries=retries_,
             prepare=prepare,
             docstring_format=docstring_format,

{pydantic_ai_slim-0.0.36 → pydantic_ai_slim-0.0.38}/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
@@ -395,7 +496,9 @@ class ModelResponse:
 ModelMessage = Annotated[Union[ModelRequest, ModelResponse], pydantic.Discriminator('kind')]
 """Any message sent to or returned by a model."""
 
-ModelMessagesTypeAdapter = pydantic.TypeAdapter(list[ModelMessage], config=pydantic.ConfigDict(defer_build=True))
+ModelMessagesTypeAdapter = pydantic.TypeAdapter(
+    list[ModelMessage], config=pydantic.ConfigDict(defer_build=True, ser_json_bytes='base64')
+)
 """Pydantic [`TypeAdapter`][pydantic.type_adapter.TypeAdapter] for (de)serializing messages."""
 
 

{pydantic_ai_slim-0.0.36 → pydantic_ai_slim-0.0.38}/pydantic_ai/models/__init__.py

@@ -266,6 +266,11 @@ class Model(ABC):
         """The system / model provider, ex: openai."""
         raise NotImplementedError()
 
+    @property
+    def base_url(self) -> str | None:
+        """The base URL for the provider API, if available."""
+        return None
+
 
 @dataclass
 class StreamedResponse(ABC):

{pydantic_ai_slim-0.0.36 → pydantic_ai_slim-0.0.38}/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,
@@ -143,6 +147,10 @@ class AnthropicModel(Model):
         else:
             self.client = AsyncAnthropic(api_key=api_key, http_client=cached_async_http_client())
 
+    @property
+    def base_url(self) -> str:
+        return str(self.client.base_url)
+
     async def request(
         self,
         messages: list[ModelMessage],
@@ -284,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
@@ -330,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:
@@ -375,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.36 → pydantic_ai_slim-0.0.38}/pydantic_ai/models/bedrock.py

@@ -10,10 +10,15 @@ from typing import TYPE_CHECKING, Generic, Literal, Union, cast, overload
 
 import anyio
 import anyio.to_thread
+from mypy_boto3_bedrock_runtime.type_defs import ImageBlockTypeDef
 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 +31,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,6 +42,7 @@ if TYPE_CHECKING:
     from mypy_boto3_bedrock_runtime import BedrockRuntimeClient
     from mypy_boto3_bedrock_runtime.type_defs import (
         ContentBlockOutputTypeDef,
+        ContentBlockUnionTypeDef,
         ConverseResponseTypeDef,
         ConverseStreamMetadataEventTypeDef,
         ConverseStreamOutputTypeDef,
@@ -162,6 +168,10 @@ class BedrockConverseModel(Model):
             }
         }
 
+    @property
+    def base_url(self) -> str:
+        return str(self.client.meta.endpoint_url)
+
     async def request(
         self,
         messages: list[ModelMessage],
@@ -240,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 = {
@@ -281,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] = []
@@ -291,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(
@@ -344,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.36 → pydantic_ai_slim-0.0.38}/pydantic_ai/models/cohere.py

@@ -127,6 +127,11 @@ class CohereModel(Model):
         else:
             self.client = AsyncClientV2(api_key=api_key, httpx_client=http_client)
 
+    @property
+    def base_url(self) -> str:
+        client_wrapper = self.client._client_wrapper  # type: ignore
+        return str(client_wrapper.get_base_url())
+
     async def request(
         self,
         messages: list[ModelMessage],

{pydantic_ai_slim-0.0.36 → pydantic_ai_slim-0.0.38}/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)
@@ -106,6 +108,10 @@ class FallbackModel(Model):
         """The system / model provider, n/a for fallback models."""
         return None
 
+    @property
+    def base_url(self) -> str | None:
+        return self.models[0].base_url
+
 
 def _default_fallback_condition_factory(exceptions: tuple[type[Exception], ...]) -> Callable[[Exception], bool]:
     """Create a default fallback condition for the given exceptions."""

{pydantic_ai_slim-0.0.36 → pydantic_ai_slim-0.0.38}/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,
@@ -143,6 +144,7 @@ class GeminiModel(Model):
             else:
                 self._system = provider.name
                 self.client = provider.client
+            self._url = str(self.client.base_url)
         else:
             if api_key is None:
                 if env_api_key := os.getenv('GEMINI_API_KEY'):
@@ -159,7 +161,7 @@ class GeminiModel(Model):
         return self._auth
 
     @property
-    def url(self) -> str:
+    def base_url(self) -> str:
         assert self._url is not None, 'URL not initialized'
         return self._url
 
@@ -257,7 +259,7 @@ class GeminiModel(Model):
             'User-Agent': get_user_agent(),
         }
         if self._provider is None:  # pragma: no cover
-            url = self.url + ('streamGenerateContent' if streamed else 'generateContent')
+            url = self.base_url + ('streamGenerateContent' if streamed else 'generateContent')
             headers.update(await self.auth.headers())
         else:
             url = f'/{self._model_name}:{"streamGenerateContent" if streamed else "generateContent"}'
@@ -361,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.36 → pydantic_ai_slim-0.0.38}/pydantic_ai/models/groq.py

@@ -15,6 +15,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,
@@ -123,6 +124,10 @@ class GroqModel(Model):
         else:
             self.client = AsyncGroq(api_key=api_key, http_client=cached_async_http_client())
 
+    @property
+    def base_url(self) -> str:
+        return str(self.client.base_url)
+
     async def request(
         self,
         messages: list[ModelMessage],
@@ -338,8 +343,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.36 → pydantic_ai_slim-0.0.38}/pydantic_ai/models/instrumented.py

@@ -5,6 +5,7 @@ from collections.abc import AsyncIterator, Iterator, Mapping
 from contextlib import asynccontextmanager, contextmanager
 from dataclasses import dataclass, field
 from typing import Any, Callable, Literal
+from urllib.parse import urlparse
 
 from opentelemetry._events import Event, EventLogger, EventLoggerProvider, get_event_logger_provider
 from opentelemetry.trace import Span, Tracer, TracerProvider, get_tracer_provider
@@ -87,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."""
@@ -137,19 +142,13 @@ 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:
-        #  - server.address: requires a Model.base_url abstract method or similar
-        #  - server.port: to parse from the base_url
         #  - 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 model_settings:
@@ -175,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)
@@ -207,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.36 → pydantic_ai_slim-0.0.38}/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,
@@ -140,6 +141,10 @@ class MistralModel(Model):
             api_key = os.getenv('MISTRAL_API_KEY') if api_key is None else api_key
             self.client = Mistral(api_key=api_key, async_client=http_client or cached_async_http_client())
 
+    @property
+    def base_url(self) -> str:
+        return str(self.client.sdk_configuration.get_server_details()[0])
+
     async def request(
         self,
         messages: list[ModelMessage],
@@ -491,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.36 → pydantic_ai_slim-0.0.38}/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,
@@ -187,6 +188,10 @@ class OpenAIModel(Model):
         self.system_prompt_role = system_prompt_role
         self._system = system
 
+    @property
+    def base_url(self) -> str:
+        return str(self.client.base_url)
+
     async def request(
         self,
         messages: list[ModelMessage],
@@ -414,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}')
@@ -425,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.36 → pydantic_ai_slim-0.0.38}/pydantic_ai/providers/google_vertex.py

@@ -1,10 +1,10 @@
 from __future__ import annotations as _annotations
 
 import functools
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Mapping
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Literal
+from typing import Literal, overload
 
 import anyio.to_thread
 import httpx
@@ -52,19 +52,45 @@ class GoogleVertexProvider(Provider[httpx.AsyncClient]):
     def client(self) -> httpx.AsyncClient:
         return self._client
 
+    @overload
     def __init__(
         self,
+        *,
         service_account_file: Path | str | None = None,
         project_id: str | None = None,
         region: VertexAiRegion = 'us-central1',
         model_publisher: str = 'google',
         http_client: httpx.AsyncClient | None = None,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        service_account_info: Mapping[str, str] | None = None,
+        project_id: str | None = None,
+        region: VertexAiRegion = 'us-central1',
+        model_publisher: str = 'google',
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        *,
+        service_account_file: Path | str | None = None,
+        service_account_info: Mapping[str, str] | None = None,
+        project_id: str | None = None,
+        region: VertexAiRegion = 'us-central1',
+        model_publisher: str = 'google',
+        http_client: httpx.AsyncClient | None = None,
     ) -> None:
         """Create a new Vertex AI provider.
 
         Args:
             service_account_file: Path to a service account file.
-                If not provided, the default environment credentials will be used.
+                If not provided, the service_account_info or default environment credentials will be used.
+            service_account_info: The loaded service_account_file contents.
+                If not provided, the service_account_file or default environment credentials will be used.
             project_id: The project ID to use, if not provided it will be taken from the credentials.
             region: The region to make requests to.
             model_publisher: The model publisher to use, I couldn't find a good list of available publishers,
@@ -73,13 +99,17 @@ class GoogleVertexProvider(Provider[httpx.AsyncClient]):
                 Please create an issue or PR if you know how to use other publishers.
             http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
         """
+        if service_account_file and service_account_info:
+            raise ValueError('Only one of `service_account_file` or `service_account_info` can be provided.')
+
         self._client = http_client or cached_async_http_client()
         self.service_account_file = service_account_file
+        self.service_account_info = service_account_info
         self.project_id = project_id
         self.region = region
         self.model_publisher = model_publisher
 
-        self._client.auth = _VertexAIAuth(service_account_file, project_id, region)
+        self._client.auth = _VertexAIAuth(service_account_file, service_account_info, project_id, region)
         self._client.base_url = self.base_url
 
 
@@ -91,10 +121,12 @@ class _VertexAIAuth(httpx.Auth):
     def __init__(
         self,
         service_account_file: Path | str | None = None,
+        service_account_info: Mapping[str, str] | None = None,
         project_id: str | None = None,
         region: VertexAiRegion = 'us-central1',
     ) -> None:
         self.service_account_file = service_account_file
+        self.service_account_info = service_account_info
         self.project_id = project_id
         self.region = region
 
@@ -119,6 +151,11 @@ class _VertexAIAuth(httpx.Auth):
             assert creds.project_id is None or isinstance(creds.project_id, str)  # type: ignore[reportUnknownMemberType]
             creds_project_id: str | None = creds.project_id
             creds_source = 'service account file'
+        elif self.service_account_info is not None:
+            creds = await _creds_from_info(self.service_account_info)
+            assert creds.project_id is None or isinstance(creds.project_id, str)  # type: ignore[reportUnknownMemberType]
+            creds_project_id: str | None = creds.project_id
+            creds_source = 'service account info'
         else:
             creds, creds_project_id = await _async_google_auth()
             creds_source = '`google.auth.default()`'
@@ -154,6 +191,14 @@ async def _creds_from_file(service_account_file: str | Path) -> ServiceAccountCr
     return await anyio.to_thread.run_sync(service_account_credentials_from_file, str(service_account_file))
 
 
+async def _creds_from_info(service_account_info: Mapping[str, str]) -> ServiceAccountCredentials:
+    service_account_credentials_from_string = functools.partial(
+        ServiceAccountCredentials.from_service_account_info,  # type: ignore[reportUnknownMemberType]
+        scopes=['https://www.googleapis.com/auth/cloud-platform'],
+    )
+    return await anyio.to_thread.run_sync(service_account_credentials_from_string, service_account_info)
+
+
 VertexAiRegion = Literal[
     'asia-east1',
     'asia-east2',

{pydantic_ai_slim-0.0.36 → pydantic_ai_slim-0.0.38}/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.36 → pydantic_ai_slim-0.0.38}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pydantic-ai-slim"
-version = "0.0.36"
+version = "0.0.38"
 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.36",
+    "pydantic-graph==0.0.38",
     "exceptiongroup; python_version < '3.11'",
     "opentelemetry-api>=1.28.0",
     "typing-inspection>=0.4.0",