Add force_download support for Anthropic and OAIR models and clarify proper BinaryContent base64 handling

pydantic_ai_slim/pydantic_ai/messages.py

@@ -474,7 +474,11 @@ class BinaryContent:
     """Binary content, e.g. an audio or image file."""
 
     data: bytes
-    """The binary data."""
+    """Arbitrary binary data.
+
+    Store actual bytes here, not base64.
+    Use `.base64` to get the base64-encoded string.
+    """
 
     _: KW_ONLY
 
@@ -574,7 +578,12 @@ def identifier(self) -> str:
     @property
     def data_uri(self) -> str:
         """Convert the `BinaryContent` to a data URI."""
-        return f'data:{self.media_type};base64,{base64.b64encode(self.data).decode()}'
+        return f'data:{self.media_type};base64,{self.base64}'
+
+    @property
+    def base64(self) -> str:
+        """Return the binary data as a base64-encoded string."""
+        return base64.b64encode(self.data).decode()
 
     @property
     def is_audio(self) -> bool:

pydantic_ai_slim/pydantic_ai/models/anthropic.py

@@ -1034,6 +1034,33 @@ def _add_cache_control_to_last_param(
         # Add cache_control to the last param
         last_param['cache_control'] = self._build_cache_control(ttl)
 
+    @staticmethod
+    def _map_binary_content(item: BinaryContent) -> BetaContentBlockParam:
+        # Anthropic SDK accepts file-like objects (IO[bytes]) and handles base64 encoding internally
+        if item.is_image:
+            return BetaImageBlockParam(
+                source={'data': io.BytesIO(item.data), 'media_type': item.media_type, 'type': 'base64'},  # type: ignore
+                type='image',
+            )
+        elif item.media_type == 'application/pdf':
+            return BetaBase64PDFBlockParam(
+                source=BetaBase64PDFSourceParam(
+                    data=io.BytesIO(item.data),
+                    media_type='application/pdf',
+                    type='base64',
+                ),
+                type='document',
+            )
+        elif item.media_type == 'text/plain':
+            return BetaBase64PDFBlockParam(
+                source=BetaPlainTextSourceParam(
+                    data=item.data.decode('utf-8'), media_type=item.media_type, type='text'
+                ),
+                type='document',
+            )
+        else:
+            raise RuntimeError(f'Unsupported binary content media type for Anthropic: {item.media_type}')
+
     @staticmethod
     async def _map_user_prompt(
         part: UserPromptPart,
@@ -1049,24 +1076,20 @@ async def _map_user_prompt(
                 elif isinstance(item, CachePoint):
                     yield item
                 elif isinstance(item, BinaryContent):
-                    if item.is_image:
+                    yield AnthropicModel._map_binary_content(item)
+                elif isinstance(item, ImageUrl):
+                    if item.force_download:
+                        downloaded = await download_item(item, data_format='bytes')
                         yield BetaImageBlockParam(
-                            source={'data': io.BytesIO(item.data), 'media_type': item.media_type, 'type': 'base64'},  # type: ignore
+                            source={
+                                'data': io.BytesIO(downloaded['data']),
+                                'media_type': item.media_type,
+                                'type': 'base64',
+                            },  # type: ignore
                             type='image',
                         )
-                    elif item.media_type == 'application/pdf':
-                        yield BetaBase64PDFBlockParam(
-                            source=BetaBase64PDFSourceParam(
-                                data=io.BytesIO(item.data),
-                                media_type='application/pdf',
-                                type='base64',
-                            ),
-                            type='document',
-                        )
                     else:
-                        raise RuntimeError('Only images and PDFs are supported for binary content')
-                elif isinstance(item, ImageUrl):
-                    yield BetaImageBlockParam(source={'type': 'url', 'url': item.url}, type='image')
+                        yield BetaImageBlockParam(source={'type': 'url', 'url': item.url}, type='image')
                 elif isinstance(item, DocumentUrl):
                     if item.media_type == 'application/pdf':
                         yield BetaBase64PDFBlockParam(source={'url': item.url, 'type': 'url'}, type='document')

pydantic_ai_slim/pydantic_ai/models/openai.py

@@ -1891,24 +1891,23 @@ async def _map_user_prompt(part: UserPromptPart) -> responses.EasyInputMessagePa
                             detail=detail,
                         )
                     )
-                elif isinstance(item, AudioUrl):  # pragma: no cover
-                    downloaded_item = await download_item(item, data_format='base64_uri', type_format='extension')
-                    content.append(
-                        responses.ResponseInputFileParam(
-                            type='input_file',
-                            file_data=downloaded_item['data'],
-                            filename=f'filename.{downloaded_item["data_type"]}',
+                elif isinstance(item, AudioUrl | DocumentUrl):
+                    if item.force_download:
+                        downloaded_item = await download_item(item, data_format='base64_uri', type_format='extension')
+                        content.append(
+                            responses.ResponseInputFileParam(
+                                type='input_file',
+                                file_data=downloaded_item['data'],
+                                filename=f'filename.{downloaded_item["data_type"]}',
+                            )
                         )
-                    )
-                elif isinstance(item, DocumentUrl):
-                    downloaded_item = await download_item(item, data_format='base64_uri', type_format='extension')
-                    content.append(
-                        responses.ResponseInputFileParam(
-                            type='input_file',
-                            file_data=downloaded_item['data'],
-                            filename=f'filename.{downloaded_item["data_type"]}',
+                    else:
+                        content.append(
+                            responses.ResponseInputFileParam(
+                                type='input_file',
+                                file_url=item.url,
+                            )
                         )
-                    )
                 elif isinstance(item, VideoUrl):  # pragma: no cover
                     raise NotImplementedError('VideoUrl is not supported for OpenAI.')
                 elif isinstance(item, CachePoint):