pydantic-ai-slim 0.0.47__py3-none-any.whl → 0.0.49__py3-none-any.whl

pydantic_ai/_cli.py

@@ -3,19 +3,20 @@ from __future__ import annotations as _annotations
 import argparse
 import asyncio
 import sys
+from asyncio import CancelledError
 from collections.abc import Sequence
 from contextlib import ExitStack
 from datetime import datetime, timezone
 from importlib.metadata import version
 from pathlib import Path
-from typing import cast
+from typing import Any, cast
 
 from typing_inspection.introspection import get_literal_values
 
 from pydantic_ai.agent import Agent
 from pydantic_ai.exceptions import UserError
 from pydantic_ai.messages import ModelMessage, PartDeltaEvent, TextPartDelta
-from pydantic_ai.models import KnownModelName
+from pydantic_ai.models import KnownModelName, infer_model
 
 try:
     import argcomplete
@@ -47,7 +48,7 @@ class SimpleCodeBlock(CodeBlock):
     This avoids a background color which messes up copy-pasting and sets the language name as dim prefix and suffix.
     """
 
-    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:  # pragma: no cover
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         code = str(self.text).rstrip()
         yield Text(self.lexer_name, style='dim')
         yield Syntax(code, self.lexer_name, theme=self.theme, background_color='default', word_wrap=True)
@@ -57,7 +58,7 @@ class SimpleCodeBlock(CodeBlock):
 class LeftHeading(Heading):
     """Customised headings in markdown to stop centering and prepend markdown style hashes."""
 
-    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:  # pragma: no cover
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         # note we use `Style(bold=True)` not `self.style_name` here to disable underlining which is ugly IMHO
         yield Text(f'{"#" * int(self.tag[1:])} {self.text.plain}', style=Style(bold=True))
 
@@ -68,7 +69,21 @@ Markdown.elements.update(
 )
 
 
-def cli(args_list: Sequence[str] | None = None) -> int:  # noqa: C901  # pragma: no cover
+cli_agent = Agent()
+
+
+@cli_agent.system_prompt
+def cli_system_prompt() -> str:
+    now_utc = datetime.now(timezone.utc)
+    tzinfo = now_utc.astimezone().tzinfo
+    tzname = tzinfo.tzname(now_utc) if tzinfo else ''
+    return f"""\
+Help the user by responding to their request, the output should be concise and always written in markdown.
+The current date and time is {datetime.now()} {tzname}.
+The user is running {sys.platform}."""
+
+
+def cli(args_list: Sequence[str] | None = None) -> int:
     parser = argparse.ArgumentParser(
         prog='pai',
         description=f"""\
@@ -124,18 +139,10 @@ Special prompt:
             console.print(f'  {model}', highlight=False)
         return 0
 
-    now_utc = datetime.now(timezone.utc)
-    tzname = now_utc.astimezone().tzinfo.tzname(now_utc)  # type: ignore
     try:
-        agent = Agent(
-            model=args.model,
-            system_prompt=f"""\
-    Help the user by responding to their request, the output should be concise and always written in markdown.
-    The current date and time is {datetime.now()} {tzname}.
-    The user is running {sys.platform}.""",
-        )
-    except UserError:
-        console.print(f'[red]Invalid model "{args.model}"[/red]')
+        cli_agent.model = infer_model(args.model)
+    except UserError as e:
+        console.print(f'Error initializing [magenta]{args.model}[/magenta]:\n[red]{e}[/red]')
         return 1
 
     stream = not args.no_stream
@@ -148,67 +155,44 @@ Special prompt:
 
     if prompt := cast(str, args.prompt):
         try:
-            asyncio.run(ask_agent(agent, prompt, stream, console, code_theme))
+            asyncio.run(ask_agent(cli_agent, prompt, stream, console, code_theme))
         except KeyboardInterrupt:
             pass
         return 0
 
     history = Path.home() / '.pai-prompt-history.txt'
-    session = PromptSession(history=FileHistory(str(history)))  # type: ignore
+    # doing this instead of `PromptSession[Any](history=` allows mocking of PromptSession in tests
+    session: PromptSession[Any] = PromptSession(history=FileHistory(str(history)))
+    try:
+        return asyncio.run(run_chat(session, stream, cli_agent, console, code_theme))
+    except KeyboardInterrupt:  # pragma: no cover
+        return 0
+
+
+async def run_chat(session: PromptSession[Any], stream: bool, agent: Agent, console: Console, code_theme: str) -> int:
     multiline = False
     messages: list[ModelMessage] = []
 
     while True:
         try:
             auto_suggest = CustomAutoSuggest(['/markdown', '/multiline', '/exit'])
-            text = cast(str, session.prompt('pai ➤ ', auto_suggest=auto_suggest, multiline=multiline))
-        except (KeyboardInterrupt, EOFError):
+            text = await session.prompt_async('pai ➤ ', auto_suggest=auto_suggest, multiline=multiline)
+        except (KeyboardInterrupt, EOFError):  # pragma: no cover
             return 0
 
         if not text.strip():
             continue
 
-        ident_prompt = text.lower().strip(' ').replace(' ', '-').lstrip(' ')
+        ident_prompt = text.lower().strip().replace(' ', '-')
         if ident_prompt.startswith('/'):
-            if ident_prompt == '/markdown':
-                try:
-                    parts = messages[-1].parts
-                except IndexError:
-                    console.print('[dim]No markdown output available.[/dim]')
-                    continue
-                console.print('[dim]Markdown output of last question:[/dim]\n')
-                for part in parts:
-                    if part.part_kind == 'text':
-                        console.print(
-                            Syntax(
-                                part.content,
-                                lexer='markdown',
-                                theme=code_theme,
-                                word_wrap=True,
-                                background_color='default',
-                            )
-                        )
-
-            elif ident_prompt == '/multiline':
-                multiline = not multiline
-                if multiline:
-                    console.print(
-                        'Enabling multiline mode. '
-                        '[dim]Press [Meta+Enter] or [Esc] followed by [Enter] to accept input.[/dim]'
-                    )
-                else:
-                    console.print('Disabling multiline mode.')
-            elif ident_prompt == '/exit':
-                console.print('[dim]Exiting…[/dim]')
-                return 0
-            else:
-                console.print(f'[red]Unknown command[/red] [magenta]`{ident_prompt}`[/magenta]')
+            exit_value, multiline = handle_slash_command(ident_prompt, messages, multiline, console, code_theme)
+            if exit_value is not None:
+                return exit_value
         else:
             try:
-                messages = asyncio.run(ask_agent(agent, text, stream, console, code_theme, messages))
-            except KeyboardInterrupt:
+                messages = await ask_agent(agent, text, stream, console, code_theme, messages)
+            except CancelledError:  # pragma: no cover
                 console.print('[dim]Interrupted[/dim]')
-                messages = []
 
 
 async def ask_agent(
@@ -218,7 +202,7 @@ async def ask_agent(
     console: Console,
     code_theme: str,
     messages: list[ModelMessage] | None = None,
-) -> list[ModelMessage]:  # pragma: no cover
+) -> list[ModelMessage]:
     status = Status('[dim]Working on it…[/dim]', console=console)
 
     if not stream:
@@ -248,7 +232,7 @@ async def ask_agent(
 
 
 class CustomAutoSuggest(AutoSuggestFromHistory):
-    def __init__(self, special_suggestions: list[str] | None = None):  # pragma: no cover
+    def __init__(self, special_suggestions: list[str] | None = None):
         super().__init__()
         self.special_suggestions = special_suggestions or []
 
@@ -264,5 +248,44 @@ class CustomAutoSuggest(AutoSuggestFromHistory):
         return suggestion
 
 
+def handle_slash_command(
+    ident_prompt: str, messages: list[ModelMessage], multiline: bool, console: Console, code_theme: str
+) -> tuple[int | None, bool]:
+    if ident_prompt == '/markdown':
+        try:
+            parts = messages[-1].parts
+        except IndexError:
+            console.print('[dim]No markdown output available.[/dim]')
+        else:
+            console.print('[dim]Markdown output of last question:[/dim]\n')
+            for part in parts:
+                if part.part_kind == 'text':
+                    console.print(
+                        Syntax(
+                            part.content,
+                            lexer='markdown',
+                            theme=code_theme,
+                            word_wrap=True,
+                            background_color='default',
+                        )
+                    )
+
+    elif ident_prompt == '/multiline':
+        multiline = not multiline
+        if multiline:
+            console.print(
+                'Enabling multiline mode. [dim]Press [Meta+Enter] or [Esc] followed by [Enter] to accept input.[/dim]'
+            )
+        else:
+            console.print('Disabling multiline mode.')
+        return None, multiline
+    elif ident_prompt == '/exit':
+        console.print('[dim]Exiting…[/dim]')
+        return 0, multiline
+    else:
+        console.print(f'[red]Unknown command[/red] [magenta]`{ident_prompt}`[/magenta]')
+    return None, multiline
+
+
 def app():  # pragma: no cover
     sys.exit(cli())

pydantic_ai/_result.py

@@ -13,7 +13,7 @@ from typing_inspection.introspection import is_union_origin
 from . import _utils, messages as _messages
 from .exceptions import ModelRetry
 from .result import ResultDataT, ResultDataT_inv, ResultValidatorFunc
-from .tools import AgentDepsT, RunContext, ToolDefinition
+from .tools import AgentDepsT, GenerateToolJsonSchema, RunContext, ToolDefinition
 
 T = TypeVar('T')
 """An invariant TypeVar."""
@@ -159,7 +159,9 @@ class ResultTool(Generic[ResultDataT]):
             self.type_adapter = TypeAdapter(response_type)
             outer_typed_dict_key: str | None = None
             # noinspection PyArgumentList
-            parameters_json_schema = _utils.check_object_json_schema(self.type_adapter.json_schema())
+            parameters_json_schema = _utils.check_object_json_schema(
+                self.type_adapter.json_schema(schema_generator=GenerateToolJsonSchema)
+            )
         else:
             response_data_typed_dict = TypedDict(  # noqa: UP013
                 'response_data_typed_dict',
@@ -168,7 +170,9 @@ class ResultTool(Generic[ResultDataT]):
             self.type_adapter = TypeAdapter(response_data_typed_dict)
             outer_typed_dict_key = 'response'
             # noinspection PyArgumentList
-            parameters_json_schema = _utils.check_object_json_schema(self.type_adapter.json_schema())
+            parameters_json_schema = _utils.check_object_json_schema(
+                self.type_adapter.json_schema(schema_generator=GenerateToolJsonSchema)
+            )
             # including `response_data_typed_dict` as a title here doesn't add anything and could confuse the LLM
             parameters_json_schema.pop('title')
 

pydantic_ai/models/__init__.py

@@ -106,6 +106,7 @@ KnownModelName = TypeAliasType(
         'google-gla:gemini-2.0-flash',
         'google-gla:gemini-2.0-flash-lite-preview-02-05',
         'google-gla:gemini-2.0-pro-exp-02-05',
+        'google-gla:gemini-2.5-pro-exp-03-25',
         'google-vertex:gemini-1.0-pro',
         'google-vertex:gemini-1.5-flash',
         'google-vertex:gemini-1.5-flash-8b',
@@ -116,6 +117,7 @@ KnownModelName = TypeAliasType(
         'google-vertex:gemini-2.0-flash',
         'google-vertex:gemini-2.0-flash-lite-preview-02-05',
         'google-vertex:gemini-2.0-pro-exp-02-05',
+        'google-vertex:gemini-2.5-pro-exp-03-25',
         'gpt-3.5-turbo',
         'gpt-3.5-turbo-0125',
         'gpt-3.5-turbo-0301',

pydantic_ai/models/anthropic.py

@@ -1,6 +1,5 @@
 from __future__ import annotations as _annotations
 
-import base64
 import io
 from collections.abc import AsyncGenerator, AsyncIterable, AsyncIterator
 from contextlib import asynccontextmanager
@@ -9,7 +8,6 @@ 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 typing_extensions import assert_never
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
@@ -40,6 +38,7 @@ try:
     from anthropic.types import (
         Base64PDFSourceParam,
         ContentBlock,
+        DocumentBlockParam,
         ImageBlockParam,
         Message as AnthropicMessage,
         MessageParam,
@@ -354,48 +353,13 @@ class AnthropicModel(Model):
                     else:
                         raise RuntimeError('Only images and PDFs are supported for binary content')
                 elif isinstance(item, ImageUrl):
-                    try:
-                        response = await cached_async_http_client().get(item.url)
-                        response.raise_for_status()
-                        yield ImageBlockParam(
-                            source={
-                                'data': io.BytesIO(response.content),
-                                'media_type': item.media_type,
-                                'type': 'base64',
-                            },
-                            type='image',
-                        )
-                    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')
-                        if (mime_type := response.headers['Content-Type']) in (
-                            'image/jpeg',
-                            'image/png',
-                            'image/gif',
-                            'image/webp',
-                        ):
-                            yield ImageBlockParam(
-                                source={'data': base64_encoded, 'media_type': mime_type, 'type': 'base64'},
-                                type='image',
-                            )
-                        else:  # pragma: no cover
-                            raise RuntimeError(f'Unsupported image type: {mime_type}')
+                    yield ImageBlockParam(source={'type': 'url', 'url': item.url}, type='image')
                 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',
-                        )
+                        yield DocumentBlockParam(source={'url': item.url, 'type': 'url'}, type='document')
                     elif item.media_type == 'text/plain':
+                        response = await cached_async_http_client().get(item.url)
+                        response.raise_for_status()
                         yield DocumentBlockParam(
                             source=PlainTextSourceParam(data=response.text, media_type=item.media_type, type='text'),
                             type='document',

pydantic_ai/models/cohere.py

@@ -5,7 +5,6 @@ from dataclasses import dataclass, field
 from itertools import chain
 from typing import Literal, Union, cast
 
-from cohere import TextAssistantMessageContentItem
 from typing_extensions import assert_never
 
 from .. import ModelHTTPError, result
@@ -38,6 +37,7 @@ try:
         ChatMessageV2,
         ChatResponse,
         SystemChatMessageV2,
+        TextAssistantMessageContentItem,
         ToolCallV2,
         ToolCallV2Function,
         ToolChatMessageV2,

pydantic_ai/models/gemini.py

@@ -57,6 +57,7 @@ LatestGeminiModelNames = Literal[
     'gemini-2.0-flash',
     'gemini-2.0-flash-lite-preview-02-05',
     'gemini-2.0-pro-exp-02-05',
+    'gemini-2.5-pro-exp-03-25',
 ]
 """Latest Gemini models."""
 

pydantic_ai/models/openai.py

@@ -1,7 +1,8 @@
 from __future__ import annotations as _annotations
 
 import base64
-from collections.abc import AsyncIterable, AsyncIterator
+import warnings
+from collections.abc import AsyncIterable, AsyncIterator, Sequence
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
@@ -41,8 +42,8 @@ from . import (
 )
 
 try:
-    from openai import NOT_GIVEN, APIStatusError, AsyncOpenAI, AsyncStream
-    from openai.types import ChatModel, chat
+    from openai import NOT_GIVEN, APIStatusError, AsyncOpenAI, AsyncStream, NotGiven
+    from openai.types import ChatModel, chat, responses
     from openai.types.chat import (
         ChatCompletionChunk,
         ChatCompletionContentPartImageParam,
@@ -52,12 +53,24 @@ try:
     )
     from openai.types.chat.chat_completion_content_part_image_param import ImageURL
     from openai.types.chat.chat_completion_content_part_input_audio_param import InputAudio
+    from openai.types.responses import ComputerToolParam, FileSearchToolParam, WebSearchToolParam
+    from openai.types.responses.response_input_param import FunctionCallOutput, Message
+    from openai.types.shared import ReasoningEffort
+    from openai.types.shared_params import Reasoning
 except ImportError as _import_error:
     raise ImportError(
         'Please install `openai` to use the OpenAI model, '
         'you can use the `openai` optional group — `pip install "pydantic-ai-slim[openai]"`'
     ) from _import_error
 
+__all__ = (
+    'OpenAIModel',
+    'OpenAIResponsesModel',
+    'OpenAIModelSettings',
+    'OpenAIResponsesModelSettings',
+    'OpenAIModelName',
+)
+
 OpenAIModelName = Union[str, ChatModel]
 """
 Possible OpenAI model names.
@@ -79,9 +92,9 @@ class OpenAIModelSettings(ModelSettings, total=False):
     ALL FIELDS MUST BE `openai_` PREFIXED SO YOU CAN MERGE THEM WITH OTHER MODELS.
     """
 
-    openai_reasoning_effort: chat.ChatCompletionReasoningEffort
-    """
-    Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning).
+    openai_reasoning_effort: ReasoningEffort
+    """Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning).
+
     Currently supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
     result in faster responses and fewer tokens used on reasoning in a response.
     """
@@ -93,6 +106,40 @@ class OpenAIModelSettings(ModelSettings, total=False):
     """
 
 
+class OpenAIResponsesModelSettings(OpenAIModelSettings, total=False):
+    """Settings used for an OpenAI Responses model request.
+
+    ALL FIELDS MUST BE `openai_` PREFIXED SO YOU CAN MERGE THEM WITH OTHER MODELS.
+    """
+
+    openai_builtin_tools: Sequence[FileSearchToolParam | WebSearchToolParam | ComputerToolParam]
+    """The provided OpenAI built-in tools to use.
+
+    See [OpenAI's built-in tools](https://platform.openai.com/docs/guides/tools?api-mode=responses) for more details.
+    """
+
+    openai_reasoning_generate_summary: Literal['detailed', 'concise']
+    """A summary of the reasoning performed by the model.
+
+    This can be useful for debugging and understanding the model's reasoning process.
+    One of `concise` or `detailed`.
+
+    Check the [OpenAI Computer use documentation](https://platform.openai.com/docs/guides/tools-computer-use#1-send-a-request-to-the-model)
+    for more details.
+    """
+
+    openai_truncation: Literal['disabled', 'auto']
+    """The truncation strategy to use for the model response.
+
+    It can be either:
+    - `disabled` (default): If a model response will exceed the context window size for a model, the
+        request will fail with a 400 error.
+    - `auto`: If the context of this response and previous ones exceeds the model's context window size,
+        the model will truncate the response to fit the context window by dropping input items in the
+        middle of the conversation.
+    """
+
+
 @dataclass(init=False)
 class OpenAIModel(Model):
     """A model that uses the OpenAI API.
@@ -178,8 +225,7 @@ class OpenAIModel(Model):
         stream: Literal[True],
         model_settings: OpenAIModelSettings,
         model_request_parameters: ModelRequestParameters,
-    ) -> AsyncStream[ChatCompletionChunk]:
-        pass
+    ) -> AsyncStream[ChatCompletionChunk]: ...
 
     @overload
     async def _completions_create(
@@ -188,8 +234,7 @@ class OpenAIModel(Model):
         stream: Literal[False],
         model_settings: OpenAIModelSettings,
         model_request_parameters: ModelRequestParameters,
-    ) -> chat.ChatCompletion:
-        pass
+    ) -> chat.ChatCompletion: ...
 
     async def _completions_create(
         self,
@@ -248,7 +293,7 @@ class OpenAIModel(Model):
             items.append(TextPart(choice.message.content))
         if choice.message.tool_calls is not None:
             for c in choice.message.tool_calls:
-                items.append(ToolCallPart(c.function.name, c.function.arguments, c.id))
+                items.append(ToolCallPart(c.function.name, c.function.arguments, tool_call_id=c.id))
         return ModelResponse(items, model_name=response.model, timestamp=timestamp)
 
     async def _process_streamed_response(self, response: AsyncStream[ChatCompletionChunk]) -> OpenAIStreamedResponse:
@@ -399,6 +444,318 @@ class OpenAIModel(Model):
         return chat.ChatCompletionUserMessageParam(role='user', content=content)
 
 
+@dataclass(init=False)
+class OpenAIResponsesModel(Model):
+    """A model that uses the OpenAI Responses API.
+
+    The [OpenAI Responses API](https://platform.openai.com/docs/api-reference/responses) is the
+    new API for OpenAI models.
+
+    The Responses API has built-in tools, that you can use instead of building your own:
+
+    - [Web search](https://platform.openai.com/docs/guides/tools-web-search)
+    - [File search](https://platform.openai.com/docs/guides/tools-file-search)
+    - [Computer use](https://platform.openai.com/docs/guides/tools-computer-use)
+
+    Use the `openai_builtin_tools` setting to add these tools to your model.
+
+    If you are interested in the differences between the Responses API and the Chat Completions API,
+    see the [OpenAI API docs](https://platform.openai.com/docs/guides/responses-vs-chat-completions).
+    """
+
+    client: AsyncOpenAI = field(repr=False)
+    system_prompt_role: OpenAISystemPromptRole | None = field(default=None)
+
+    _model_name: OpenAIModelName = field(repr=False)
+    _system: str = field(default='openai', repr=False)
+
+    def __init__(
+        self,
+        model_name: OpenAIModelName,
+        *,
+        provider: Literal['openai', 'deepseek', 'azure'] | Provider[AsyncOpenAI] = 'openai',
+    ):
+        """Initialize an OpenAI Responses model.
+
+        Args:
+            model_name: The name of the OpenAI model to use.
+            provider: The provider to use. Defaults to `'openai'`.
+        """
+        self._model_name = model_name
+        if isinstance(provider, str):
+            provider = infer_provider(provider)
+        self.client = provider.client
+
+    @property
+    def model_name(self) -> OpenAIModelName:
+        """The model name."""
+        return self._model_name
+
+    @property
+    def system(self) -> str:
+        """The system / model provider."""
+        return self._system
+
+    async def request(
+        self,
+        messages: list[ModelRequest | ModelResponse],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> tuple[ModelResponse, usage.Usage]:
+        check_allow_model_requests()
+        response = await self._responses_create(
+            messages, False, cast(OpenAIResponsesModelSettings, model_settings or {}), model_request_parameters
+        )
+        return self._process_response(response), _map_usage(response)
+
+    @asynccontextmanager
+    async def request_stream(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> AsyncIterator[StreamedResponse]:
+        check_allow_model_requests()
+        response = await self._responses_create(
+            messages, True, cast(OpenAIResponsesModelSettings, model_settings or {}), model_request_parameters
+        )
+        async with response:
+            yield await self._process_streamed_response(response)
+
+    def _process_response(self, response: responses.Response) -> ModelResponse:
+        """Process a non-streamed response, and prepare a message to return."""
+        timestamp = datetime.fromtimestamp(response.created_at, tz=timezone.utc)
+        items: list[ModelResponsePart] = []
+        items.append(TextPart(response.output_text))
+        for item in response.output:
+            if item.type == 'function_call':
+                items.append(ToolCallPart(item.name, item.arguments, tool_call_id=item.call_id))
+        return ModelResponse(items, model_name=response.model, timestamp=timestamp)
+
+    async def _process_streamed_response(
+        self, response: AsyncStream[responses.ResponseStreamEvent]
+    ) -> OpenAIResponsesStreamedResponse:
+        """Process a streamed response, and prepare a streaming response to return."""
+        peekable_response = _utils.PeekableAsyncStream(response)
+        first_chunk = await peekable_response.peek()
+        if isinstance(first_chunk, _utils.Unset):  # pragma: no cover
+            raise UnexpectedModelBehavior('Streamed response ended without content or tool calls')
+
+        assert isinstance(first_chunk, responses.ResponseCreatedEvent)
+        return OpenAIResponsesStreamedResponse(
+            _model_name=self._model_name,
+            _response=peekable_response,
+            _timestamp=datetime.fromtimestamp(first_chunk.response.created_at, tz=timezone.utc),
+        )
+
+    @overload
+    async def _responses_create(
+        self,
+        messages: list[ModelRequest | ModelResponse],
+        stream: Literal[False],
+        model_settings: OpenAIResponsesModelSettings,
+        model_request_parameters: ModelRequestParameters,
+    ) -> responses.Response: ...
+
+    @overload
+    async def _responses_create(
+        self,
+        messages: list[ModelRequest | ModelResponse],
+        stream: Literal[True],
+        model_settings: OpenAIResponsesModelSettings,
+        model_request_parameters: ModelRequestParameters,
+    ) -> AsyncStream[responses.ResponseStreamEvent]: ...
+
+    async def _responses_create(
+        self,
+        messages: list[ModelRequest | ModelResponse],
+        stream: bool,
+        model_settings: OpenAIResponsesModelSettings,
+        model_request_parameters: ModelRequestParameters,
+    ) -> responses.Response | AsyncStream[responses.ResponseStreamEvent]:
+        tools = self._get_tools(model_request_parameters)
+        tools = list(model_settings.get('openai_builtin_tools', [])) + tools
+
+        # standalone function to make it easier to override
+        if not tools:
+            tool_choice: Literal['none', 'required', 'auto'] | None = None
+        elif not model_request_parameters.allow_text_result:
+            tool_choice = 'required'
+        else:
+            tool_choice = 'auto'
+
+        system_prompt, openai_messages = await self._map_message(messages)
+        reasoning = self._get_reasoning(model_settings)
+
+        try:
+            return await self.client.responses.create(
+                input=openai_messages,
+                model=self._model_name,
+                instructions=system_prompt,
+                parallel_tool_calls=model_settings.get('parallel_tool_calls', NOT_GIVEN),
+                tools=tools or NOT_GIVEN,
+                tool_choice=tool_choice or NOT_GIVEN,
+                max_output_tokens=model_settings.get('max_tokens', NOT_GIVEN),
+                stream=stream,
+                temperature=model_settings.get('temperature', NOT_GIVEN),
+                top_p=model_settings.get('top_p', NOT_GIVEN),
+                truncation=model_settings.get('openai_truncation', NOT_GIVEN),
+                timeout=model_settings.get('timeout', NOT_GIVEN),
+                reasoning=reasoning,
+                user=model_settings.get('user', NOT_GIVEN),
+            )
+        except APIStatusError as e:
+            if (status_code := e.status_code) >= 400:
+                raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=e.body) from e
+            raise
+
+    def _get_reasoning(self, model_settings: OpenAIResponsesModelSettings) -> Reasoning | NotGiven:
+        reasoning_effort = model_settings.get('openai_reasoning_effort', None)
+        reasoning_generate_summary = model_settings.get('openai_reasoning_generate_summary', None)
+
+        if reasoning_effort is None and reasoning_generate_summary is None:
+            return NOT_GIVEN
+        return Reasoning(effort=reasoning_effort, generate_summary=reasoning_generate_summary)
+
+    def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[responses.FunctionToolParam]:
+        tools = [self._map_tool_definition(r) for r in model_request_parameters.function_tools]
+        if model_request_parameters.result_tools:
+            tools += [self._map_tool_definition(r) for r in model_request_parameters.result_tools]
+        return tools
+
+    @staticmethod
+    def _map_tool_definition(f: ToolDefinition) -> responses.FunctionToolParam:
+        return {
+            'name': f.name,
+            'parameters': f.parameters_json_schema,
+            'type': 'function',
+            'description': f.description,
+            'strict': True,
+        }
+
+    async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[responses.ResponseInputItemParam]]:
+        """Just maps a `pydantic_ai.Message` to a `openai.types.responses.ResponseInputParam`."""
+        system_prompt: str = ''
+        openai_messages: list[responses.ResponseInputItemParam] = []
+        for message in messages:
+            if isinstance(message, ModelRequest):
+                for part in message.parts:
+                    if isinstance(part, SystemPromptPart):
+                        system_prompt += part.content
+                    elif isinstance(part, UserPromptPart):
+                        openai_messages.append(await self._map_user_prompt(part))
+                    elif isinstance(part, ToolReturnPart):
+                        openai_messages.append(
+                            FunctionCallOutput(
+                                type='function_call_output',
+                                call_id=_guard_tool_call_id(t=part),
+                                output=part.model_response_str(),
+                            )
+                        )
+                    elif isinstance(part, RetryPromptPart):
+                        # TODO(Marcelo): How do we test this conditional branch?
+                        if part.tool_name is None:  # pragma: no cover
+                            openai_messages.append(
+                                Message(role='user', content=[{'type': 'input_text', 'text': part.model_response()}])
+                            )
+                        else:
+                            openai_messages.append(
+                                FunctionCallOutput(
+                                    type='function_call_output',
+                                    call_id=_guard_tool_call_id(t=part),
+                                    output=part.model_response(),
+                                )
+                            )
+                    else:
+                        assert_never(part)
+            elif isinstance(message, ModelResponse):
+                for item in message.parts:
+                    if isinstance(item, TextPart):
+                        openai_messages.append(responses.EasyInputMessageParam(role='assistant', content=item.content))
+                    elif isinstance(item, ToolCallPart):
+                        openai_messages.append(self._map_tool_call(item))
+                    else:
+                        assert_never(item)
+            else:
+                assert_never(message)
+        return system_prompt, openai_messages
+
+    @staticmethod
+    def _map_tool_call(t: ToolCallPart) -> responses.ResponseFunctionToolCallParam:
+        return responses.ResponseFunctionToolCallParam(
+            arguments=t.args_as_json_str(),
+            call_id=_guard_tool_call_id(t=t),
+            name=t.tool_name,
+            type='function_call',
+        )
+
+    @staticmethod
+    async def _map_user_prompt(part: UserPromptPart) -> responses.EasyInputMessageParam:
+        content: str | list[responses.ResponseInputContentParam]
+        if isinstance(part.content, str):
+            content = part.content
+        else:
+            content = []
+            for item in part.content:
+                if isinstance(item, str):
+                    content.append(responses.ResponseInputTextParam(text=item, type='input_text'))
+                elif isinstance(item, BinaryContent):
+                    base64_encoded = base64.b64encode(item.data).decode('utf-8')
+                    if item.is_image:
+                        content.append(
+                            responses.ResponseInputImageParam(
+                                image_url=f'data:{item.media_type};base64,{base64_encoded}',
+                                type='input_image',
+                                detail='auto',
+                            )
+                        )
+                    elif item.is_document:
+                        content.append(
+                            responses.ResponseInputFileParam(
+                                type='input_file',
+                                file_data=f'data:{item.media_type};base64,{base64_encoded}',
+                                # NOTE: Type wise it's not necessary to include the filename, but it's required by the
+                                # API itself. If we add empty string, the server sends a 500 error - which OpenAI needs
+                                # to fix. In any case, we add a placeholder name.
+                                filename=f'filename.{item.format}',
+                            )
+                        )
+                    elif item.is_audio:
+                        raise NotImplementedError('Audio as binary content is not supported for OpenAI Responses API.')
+                    else:  # pragma: no cover
+                        raise RuntimeError(f'Unsupported binary content type: {item.media_type}')
+                elif isinstance(item, ImageUrl):
+                    content.append(
+                        responses.ResponseInputImageParam(image_url=item.url, type='input_image', detail='auto')
+                    )
+                elif isinstance(item, AudioUrl):  # pragma: no cover
+                    client = cached_async_http_client()
+                    response = await client.get(item.url)
+                    response.raise_for_status()
+                    base64_encoded = base64.b64encode(response.content).decode('utf-8')
+                    content.append(
+                        responses.ResponseInputFileParam(
+                            type='input_file',
+                            file_data=f'data:{item.media_type};base64,{base64_encoded}',
+                        )
+                    )
+                elif isinstance(item, DocumentUrl):  # pragma: no cover
+                    client = cached_async_http_client()
+                    response = await client.get(item.url)
+                    response.raise_for_status()
+                    base64_encoded = base64.b64encode(response.content).decode('utf-8')
+                    content.append(
+                        responses.ResponseInputFileParam(
+                            type='input_file',
+                            file_data=f'data:{item.media_type};base64,{base64_encoded}',
+                            filename=f'filename.{item.format}',
+                        )
+                    )
+                else:
+                    assert_never(item)
+        return responses.EasyInputMessageParam(role='user', content=content)
+
+
 @dataclass
 class OpenAIStreamedResponse(StreamedResponse):
     """Implementation of `StreamedResponse` for OpenAI models."""
@@ -442,12 +799,103 @@ class OpenAIStreamedResponse(StreamedResponse):
         return self._timestamp
 
 
-def _map_usage(response: chat.ChatCompletion | ChatCompletionChunk) -> usage.Usage:
+@dataclass
+class OpenAIResponsesStreamedResponse(StreamedResponse):
+    """Implementation of `StreamedResponse` for OpenAI Responses API."""
+
+    _model_name: OpenAIModelName
+    _response: AsyncIterable[responses.ResponseStreamEvent]
+    _timestamp: datetime
+
+    async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:  # noqa: C901
+        async for chunk in self._response:
+            if isinstance(chunk, responses.ResponseCompletedEvent):
+                self._usage += _map_usage(chunk.response)
+
+            elif isinstance(chunk, responses.ResponseContentPartAddedEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseContentPartDoneEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseCreatedEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseFailedEvent):  # pragma: no cover
+                self._usage += _map_usage(chunk.response)
+
+            elif isinstance(chunk, responses.ResponseFunctionCallArgumentsDeltaEvent):
+                maybe_event = self._parts_manager.handle_tool_call_delta(
+                    vendor_part_id=chunk.item_id,
+                    tool_name=None,
+                    args=chunk.delta,
+                    tool_call_id=chunk.item_id,
+                )
+                if maybe_event is not None:
+                    yield maybe_event
+
+            elif isinstance(chunk, responses.ResponseFunctionCallArgumentsDoneEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseIncompleteEvent):  # pragma: no cover
+                self._usage += _map_usage(chunk.response)
+
+            elif isinstance(chunk, responses.ResponseInProgressEvent):
+                self._usage += _map_usage(chunk.response)
+
+            elif isinstance(chunk, responses.ResponseOutputItemAddedEvent):
+                if isinstance(chunk.item, responses.ResponseFunctionToolCall):
+                    yield self._parts_manager.handle_tool_call_part(
+                        vendor_part_id=chunk.item.id,
+                        tool_name=chunk.item.name,
+                        args=chunk.item.arguments,
+                        tool_call_id=chunk.item.id,
+                    )
+
+            elif isinstance(chunk, responses.ResponseOutputItemDoneEvent):
+                # NOTE: We only need this if the tool call deltas don't include the final info.
+                pass
+
+            elif isinstance(chunk, responses.ResponseTextDeltaEvent):
+                yield self._parts_manager.handle_text_delta(vendor_part_id=chunk.content_index, content=chunk.delta)
+
+            elif isinstance(chunk, responses.ResponseTextDoneEvent):
+                pass  # there's nothing we need to do here
+
+            else:  # pragma: no cover
+                warnings.warn(
+                    f'Handling of this event type is not yet implemented. Please report on our GitHub: {chunk}',
+                    UserWarning,
+                )
+
+    @property
+    def model_name(self) -> OpenAIModelName:
+        """Get the model name of the response."""
+        return self._model_name
+
+    @property
+    def timestamp(self) -> datetime:
+        """Get the timestamp of the response."""
+        return self._timestamp
+
+
+def _map_usage(response: chat.ChatCompletion | ChatCompletionChunk | responses.Response) -> usage.Usage:
     response_usage = response.usage
     if response_usage is None:
         return usage.Usage()
-    else:
+    elif isinstance(response_usage, responses.ResponseUsage):
         details: dict[str, int] = {}
+        return usage.Usage(
+            request_tokens=response_usage.input_tokens,
+            response_tokens=response_usage.output_tokens,
+            total_tokens=response_usage.total_tokens,
+            details={
+                'reasoning_tokens': response_usage.output_tokens_details.reasoning_tokens,
+                'cached_tokens': response_usage.input_tokens_details.cached_tokens,
+            },
+        )
+    else:
+        details = {}
         if response_usage.completion_tokens_details is not None:
             details.update(response_usage.completion_tokens_details.model_dump(exclude_none=True))
         if response_usage.prompt_tokens_details is not None:

pydantic_ai/tools.py

@@ -149,8 +149,8 @@ class GenerateToolJsonSchema(GenerateJsonSchema):
     def typed_dict_schema(self, schema: core_schema.TypedDictSchema) -> JsonSchemaValue:
         s = super().typed_dict_schema(schema)
         total = schema.get('total')
-        if total is not None:
-            s['additionalProperties'] = not total
+        if 'additionalProperties' not in s and (total is True or total is None):
+            s['additionalProperties'] = False
         return s
 
     def _named_required_fields_schema(self, named_required_fields: Sequence[tuple[str, bool, Any]]) -> JsonSchemaValue:

{pydantic_ai_slim-0.0.47.dist-info → pydantic_ai_slim-0.0.49.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.47
+Version: 0.0.49
 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.47
+Requires-Dist: pydantic-graph==0.0.49
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: anthropic
@@ -45,7 +45,7 @@ Requires-Dist: cohere>=5.13.11; (platform_system != 'Emscripten') and extra == '
 Provides-Extra: duckduckgo
 Requires-Dist: duckduckgo-search>=7.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.0.41; extra == 'evals'
+Requires-Dist: pydantic-evals==0.0.49; extra == 'evals'
 Provides-Extra: groq
 Requires-Dist: groq>=0.15.0; extra == 'groq'
 Provides-Extra: logfire

{pydantic_ai_slim-0.0.47.dist-info → pydantic_ai_slim-0.0.49.dist-info}/RECORD

@@ -1,11 +1,11 @@
 pydantic_ai/__init__.py,sha256=5or1fE25gmemJGCznkFHC4VMeNT7vTLU6BiGxkmSA2A,959
 pydantic_ai/__main__.py,sha256=AW8FzscUWPFtIrQBG0QExLxTQehKtt5FnFVnOT200OE,122
 pydantic_ai/_agent_graph.py,sha256=MWNNug-bGJcgOVonkkD38Yz3X4R0XfUxzFJ9_fpNnyQ,32532
-pydantic_ai/_cli.py,sha256=_uK04vLLT08suu-VNd0ynMtzpUiF-jw8YpZaEVTiUUk,10360
+pydantic_ai/_cli.py,sha256=TU6Kqlu4aDmgrwmNAnnGPG5mSpTZPjtOtyhq582BCec,10953
 pydantic_ai/_griffe.py,sha256=Sf_DisE9k2TA0VFeVIK2nf1oOct5MygW86PBCACJkFA,5244
 pydantic_ai/_parts_manager.py,sha256=HIi6eth7z2g0tOn6iQYc633xMqy4d_xZ8vwka8J8150,12016
 pydantic_ai/_pydantic.py,sha256=12hX5hON88meO1QxbWrEPXSvr6RTNgr6ubKY6KRwab4,8890
-pydantic_ai/_result.py,sha256=32wDrq4F93f0BI9gcXeWposN49YaifF77qnyd_D57f0,10213
+pydantic_ai/_result.py,sha256=9cDWMiXv3ef_qPywv02SAH_8r3SS5FVfxm5iAYDI_is,10375
 pydantic_ai/_system_prompt.py,sha256=602c2jyle2R_SesOrITBDETZqsLk4BZ8Cbo8yEhmx04,1120
 pydantic_ai/_utils.py,sha256=VXbR6FG6WQU_TTN1NMmBDbZ6e6DT7PDiUiBHFHf348U,9703
 pydantic_ai/agent.py,sha256=qBUE9uPgomSj09sHe6kQYxjXGMVsRs3nkPn5neRVlYg,69285
@@ -16,22 +16,22 @@ pydantic_ai/messages.py,sha256=IQS6vabH72yhvTQY1ciQxRqJDHpGMMR0MKiO5xcJ0SE,27112
 pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/result.py,sha256=LXKxRzy_rGMkdZ8xJ7yknPP3wGZtGNeZl-gh5opXbaQ,22542
 pydantic_ai/settings.py,sha256=q__Hordc4dypesNxpy_cBT5rFdSiEY-rQt9G6zfyFaM,3101
-pydantic_ai/tools.py,sha256=5BGwmZYx4Aer6REoGPbk4CbrPJ3Uutass1RdcOhogKk,15744
+pydantic_ai/tools.py,sha256=S7pg9cc7OjIkACXAOjE5RUz7VkKXapH4GciP7VVyFc8,15791
 pydantic_ai/usage.py,sha256=9sqoIv_RVVUhKXQScTDqUJc074gifsuSzc9_NOt7C3g,5394
 pydantic_ai/common_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/common_tools/duckduckgo.py,sha256=Iw8Dl2YQ28S483mzfa8CXs-dc-ujS8un085R2O6oOEw,2241
 pydantic_ai/common_tools/tavily.py,sha256=h8deBDrpG-8BGzydM_zXs7z1ASrhdVvUxL4-CAbncBo,2589
-pydantic_ai/models/__init__.py,sha256=kDGQmOsOyHNgp1VHdDRyfQeg-JSuDdDKbrB6OVol-Ek,18270
-pydantic_ai/models/anthropic.py,sha256=fUX_iID4s3FRzm451xOlFXTg7_eg-GR1PM0ZrR-B_8A,21732
+pydantic_ai/models/__init__.py,sha256=0f_9smleJgn3Jgmm96gsW7lbyQIJ6-5chXxClLqzfHk,18367
+pydantic_ai/models/anthropic.py,sha256=bqx-yQH4TyLoC9Jn5m7IegRsHXn0h2vv9aOkO0elfu0,19957
 pydantic_ai/models/bedrock.py,sha256=EmnBwxx_FzKMM8xAed_1aTmDwASWo26GA6Q8Z92waVc,20706
-pydantic_ai/models/cohere.py,sha256=ePOWml56gQcGgV1__pxbhMts0ZLDOfxrpiqsC4WutQM,11338
+pydantic_ai/models/cohere.py,sha256=UTRCl3sa5-ptceg7k9WqLMIhNo5oFExUPMpLLi-A46c,11328
 pydantic_ai/models/fallback.py,sha256=y0bYXM3DfzJNAsyyMzclt33lzZazL-5_hwdgc33gfuM,4876
 pydantic_ai/models/function.py,sha256=HUSgPB3mKVfYI0OSJJJJRiQN-yeewjYIbrtrPfsvlgI,11365
-pydantic_ai/models/gemini.py,sha256=hcIB3TU6jnHHAYJDKobc3VDPNhr0jhRv_73-HmI-khQ,33304
+pydantic_ai/models/gemini.py,sha256=0N5ccI5HsCLaPd2-jxareQvrAePKSALOiRmV0ufxIcc,33336
 pydantic_ai/models/groq.py,sha256=IbO2jMNC5yiYRuUJf-j4blpPvoQDromQNBKJyPjs2A4,16518
 pydantic_ai/models/instrumented.py,sha256=ErFRDiOehOYlJBp4mSNj7yEIMtMqjlGcamEAwgW_Il4,11163
 pydantic_ai/models/mistral.py,sha256=8pdG9oRW6Dx7H5P88ZgiRIZbkGkPUfEateuyvzoULOE,27439
-pydantic_ai/models/openai.py,sha256=7i8KRbuiqAdt-UUILPuVlNJh1DiHriFlhu1azO1l_XA,20163
+pydantic_ai/models/openai.py,sha256=asLsbtyQwvAtLjdJs4B87qE9ylqWJmWCIoWs2xvvjM0,40675
 pydantic_ai/models/test.py,sha256=qQ8ZIaVRdbJv-tKGu6lrdakVAhOsTlyf68TFWyGwOWE,16861
 pydantic_ai/models/wrapper.py,sha256=ff6JPTuIv9C_6Zo4kyYIO7Cn0VI1uSICz1v1aKUyeOc,1506
 pydantic_ai/providers/__init__.py,sha256=lsJn3BStrPMMAFWEkCYPyfMj3fEVfaeS2xllnvE6Gdk,2489
@@ -45,7 +45,7 @@ pydantic_ai/providers/google_vertex.py,sha256=WAwPxKTARVzs8DFs2veEUOJSur0krDOo9-
 pydantic_ai/providers/groq.py,sha256=DoY6qkfhuemuKB5JXhUkqG-3t1HQkxwSXoE_kHQIAK0,2788
 pydantic_ai/providers/mistral.py,sha256=fcR1uSwORo0jtevX7-wOjvcfT8ojMAaKY81uN5uYymM,2661
 pydantic_ai/providers/openai.py,sha256=ePF-QWwLkGkSE5w245gTTDVR3VoTIUqFoIhQ0TAoUiA,2866
-pydantic_ai_slim-0.0.47.dist-info/METADATA,sha256=Df32-4l7OYVBjxRByOvG3XjV0XWEMbozcZDaIrMzNAs,3555
-pydantic_ai_slim-0.0.47.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.0.47.dist-info/entry_points.txt,sha256=KxQSmlMS8GMTkwTsl4_q9a5nJvBjj3HWeXx688wLrKg,45
-pydantic_ai_slim-0.0.47.dist-info/RECORD,,
+pydantic_ai_slim-0.0.49.dist-info/METADATA,sha256=lj5N1y3Dff7zJqTUQJy-z-kRBa7Fh3odZRuDW_GqOFc,3555
+pydantic_ai_slim-0.0.49.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.0.49.dist-info/entry_points.txt,sha256=KxQSmlMS8GMTkwTsl4_q9a5nJvBjj3HWeXx688wLrKg,45
+pydantic_ai_slim-0.0.49.dist-info/RECORD,,