pydantic-ai-slim 0.3.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

pydantic_ai/models/google.py

@@ -11,6 +11,7 @@ from uuid import uuid4
 from typing_extensions import assert_never
 
 from .. import UnexpectedModelBehavior, _utils, usage
+from .._output import OutputObjectDefinition
 from ..exceptions import UserError
 from ..messages import (
     BinaryContent,
@@ -216,9 +217,7 @@ class GoogleModel(Model):
     def _get_tool_config(
         self, model_request_parameters: ModelRequestParameters, tools: list[ToolDict] | None
     ) -> ToolConfigDict | None:
-        if model_request_parameters.allow_text_output:
-            return None
-        elif tools:
+        if not model_request_parameters.allow_text_output and tools:
             names: list[str] = []
             for tool in tools:
                 for function_declaration in tool.get('function_declarations') or []:
@@ -226,7 +225,7 @@ class GoogleModel(Model):
                         names.append(name)
             return _tool_config(names)
         else:
-            return _tool_config([])  # pragma: no cover
+            return None
 
     @overload
     async def _generate_content(
@@ -254,6 +253,21 @@ class GoogleModel(Model):
         model_request_parameters: ModelRequestParameters,
     ) -> GenerateContentResponse | Awaitable[AsyncIterator[GenerateContentResponse]]:
         tools = self._get_tools(model_request_parameters)
+
+        response_mime_type = None
+        response_schema = None
+        if model_request_parameters.output_mode == 'native':
+            if tools:
+                raise UserError('Gemini does not support structured output and tools at the same time.')
+
+            response_mime_type = 'application/json'
+
+            output_object = model_request_parameters.output_object
+            assert output_object is not None
+            response_schema = self._map_response_schema(output_object)
+        elif model_request_parameters.output_mode == 'prompted' and not tools:
+            response_mime_type = 'application/json'
+
         tool_config = self._get_tool_config(model_request_parameters, tools)
         system_instruction, contents = await self._map_messages(messages)
 
@@ -280,6 +294,8 @@ class GoogleModel(Model):
             labels=model_settings.get('google_labels'),
             tools=cast(ToolListUnionDict, tools),
             tool_config=tool_config,
+            response_mime_type=response_mime_type,
+            response_schema=response_schema,
         )
 
         func = self.client.aio.models.generate_content_stream if stream else self.client.aio.models.generate_content
@@ -397,6 +413,15 @@ class GoogleModel(Model):
                     assert_never(item)
         return content
 
+    def _map_response_schema(self, o: OutputObjectDefinition) -> dict[str, Any]:
+        response_schema = o.json_schema.copy()
+        if o.name:
+            response_schema['title'] = o.name
+        if o.description:
+            response_schema['description'] = o.description
+
+        return response_schema
+
 
 @dataclass
 class GeminiStreamedResponse(StreamedResponse):

pydantic_ai/models/mistral.py

@@ -253,6 +253,7 @@ class MistralModel(Model):
             )
 
         elif model_request_parameters.output_tools:
+            # TODO: Port to native "manual JSON" mode
             # Json Mode
             parameters_json_schemas = [tool.parameters_json_schema for tool in model_request_parameters.output_tools]
             user_output_format_message = self._generate_user_output_format(parameters_json_schemas)
@@ -261,7 +262,9 @@ class MistralModel(Model):
             response = await self.client.chat.stream_async(
                 model=str(self._model_name),
                 messages=mistral_messages,
-                response_format={'type': 'json_object'},
+                response_format={
+                    'type': 'json_object'
+                },  # TODO: Should be able to use json_schema now: https://docs.mistral.ai/capabilities/structured-output/custom_structured_output/, https://github.com/mistralai/client-python/blob/bc4adf335968c8a272e1ab7da8461c9943d8e701/src/mistralai/extra/utils/response_format.py#L9
                 stream=True,
                 http_headers={'User-Agent': get_user_agent()},
             )
@@ -574,6 +577,7 @@ class MistralStreamedResponse(StreamedResponse):
                 # Attempt to produce an output tool call from the received text
                 if self._output_tools:
                     self._delta_content += text
+                    # TODO: Port to native "manual JSON" mode
                     maybe_tool_call_part = self._try_get_output_tool_from_text(self._delta_content, self._output_tools)
                     if maybe_tool_call_part:
                         yield self._parts_manager.handle_tool_call_part(

pydantic_ai/models/openai.py

@@ -15,6 +15,7 @@ from pydantic_ai.profiles.openai import OpenAIModelProfile
 from pydantic_ai.providers import Provider, infer_provider
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
+from .._output import DEFAULT_OUTPUT_TOOL_NAME, OutputObjectDefinition
 from .._utils import guard_tool_call_id as _guard_tool_call_id, number_to_datetime
 from ..messages import (
     AudioUrl,
@@ -275,8 +276,6 @@ class OpenAIModel(Model):
         model_request_parameters: ModelRequestParameters,
     ) -> chat.ChatCompletion | AsyncStream[ChatCompletionChunk]:
         tools = self._get_tools(model_request_parameters)
-
-        # 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_output:
@@ -286,6 +285,16 @@ class OpenAIModel(Model):
 
         openai_messages = await self._map_messages(messages)
 
+        response_format: chat.completion_create_params.ResponseFormat | None = None
+        if model_request_parameters.output_mode == 'native':
+            output_object = model_request_parameters.output_object
+            assert output_object is not None
+            response_format = self._map_json_schema(output_object)
+        elif (
+            model_request_parameters.output_mode == 'prompted' and self.profile.supports_json_object_output
+        ):  # pragma: no branch
+            response_format = {'type': 'json_object'}
+
         sampling_settings = (
             model_settings
             if OpenAIModelProfile.from_profile(self.profile).openai_supports_sampling_settings
@@ -306,6 +315,7 @@ class OpenAIModel(Model):
                 stop=model_settings.get('stop_sequences', NOT_GIVEN),
                 max_completion_tokens=model_settings.get('max_tokens', NOT_GIVEN),
                 timeout=model_settings.get('timeout', NOT_GIVEN),
+                response_format=response_format or NOT_GIVEN,
                 seed=model_settings.get('seed', NOT_GIVEN),
                 reasoning_effort=model_settings.get('openai_reasoning_effort', NOT_GIVEN),
                 user=model_settings.get('openai_user', NOT_GIVEN),
@@ -434,6 +444,17 @@ class OpenAIModel(Model):
             function={'name': t.tool_name, 'arguments': t.args_as_json_str()},
         )
 
+    def _map_json_schema(self, o: OutputObjectDefinition) -> chat.completion_create_params.ResponseFormat:
+        response_format_param: chat.completion_create_params.ResponseFormatJSONSchema = {  # pyright: ignore[reportPrivateImportUsage]
+            'type': 'json_schema',
+            'json_schema': {'name': o.name or DEFAULT_OUTPUT_TOOL_NAME, 'schema': o.json_schema, 'strict': True},
+        }
+        if o.description:
+            response_format_param['json_schema']['description'] = o.description
+        if OpenAIModelProfile.from_profile(self.profile).openai_supports_strict_tool_definition:  # pragma: no branch
+            response_format_param['json_schema']['strict'] = o.strict
+        return response_format_param
+
     def _map_tool_definition(self, f: ToolDefinition) -> chat.ChatCompletionToolParam:
         tool_param: chat.ChatCompletionToolParam = {
             'type': 'function',
@@ -684,7 +705,6 @@ class OpenAIResponsesModel(Model):
         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_output:
@@ -695,6 +715,23 @@ class OpenAIResponsesModel(Model):
         instructions, openai_messages = await self._map_messages(messages)
         reasoning = self._get_reasoning(model_settings)
 
+        text: responses.ResponseTextConfigParam | None = None
+        if model_request_parameters.output_mode == 'native':
+            output_object = model_request_parameters.output_object
+            assert output_object is not None
+            text = {'format': self._map_json_schema(output_object)}
+        elif (
+            model_request_parameters.output_mode == 'prompted' and self.profile.supports_json_object_output
+        ):  # pragma: no branch
+            text = {'format': {'type': 'json_object'}}
+
+            # Without this trick, we'd hit this error:
+            # > Response input messages must contain the word 'json' in some form to use 'text.format' of type 'json_object'.
+            # Apparently they're only checking input messages for "JSON", not instructions.
+            assert isinstance(instructions, str)
+            openai_messages.insert(0, responses.EasyInputMessageParam(role='system', content=instructions))
+            instructions = NOT_GIVEN
+
         sampling_settings = (
             model_settings
             if OpenAIModelProfile.from_profile(self.profile).openai_supports_sampling_settings
@@ -719,6 +756,7 @@ class OpenAIResponsesModel(Model):
                 timeout=model_settings.get('timeout', NOT_GIVEN),
                 reasoning=reasoning,
                 user=model_settings.get('openai_user', NOT_GIVEN),
+                text=text or NOT_GIVEN,
                 extra_headers=extra_headers,
                 extra_body=model_settings.get('extra_body'),
             )
@@ -840,6 +878,18 @@ class OpenAIResponsesModel(Model):
             type='function_call',
         )
 
+    def _map_json_schema(self, o: OutputObjectDefinition) -> responses.ResponseFormatTextJSONSchemaConfigParam:
+        response_format_param: responses.ResponseFormatTextJSONSchemaConfigParam = {
+            'type': 'json_schema',
+            'name': o.name or DEFAULT_OUTPUT_TOOL_NAME,
+            'schema': o.json_schema,
+        }
+        if o.description:
+            response_format_param['description'] = o.description
+        if OpenAIModelProfile.from_profile(self.profile).openai_supports_strict_tool_definition:  # pragma: no branch
+            response_format_param['strict'] = o.strict
+        return response_format_param
+
     @staticmethod
     async def _map_user_prompt(part: UserPromptPart) -> responses.EasyInputMessageParam:
         content: str | list[responses.ResponseInputContentParam]
@@ -1062,18 +1112,29 @@ def _map_usage(response: chat.ChatCompletion | ChatCompletionChunk | responses.R
     if response_usage is None:
         return usage.Usage()
     elif isinstance(response_usage, responses.ResponseUsage):
-        details: dict[str, int] = {}
+        details: dict[str, int] = {
+            key: value
+            for key, value in response_usage.model_dump(
+                exclude={'input_tokens', 'output_tokens', 'total_tokens'}
+            ).items()
+            if isinstance(value, int)
+        }
+        details['reasoning_tokens'] = response_usage.output_tokens_details.reasoning_tokens
+        details['cached_tokens'] = response_usage.input_tokens_details.cached_tokens
         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,
-            },
+            details=details,
         )
     else:
-        details = {}
+        details = {
+            key: value
+            for key, value in response_usage.model_dump(
+                exclude={'prompt_tokens', 'completion_tokens', 'total_tokens'}
+            ).items()
+            if isinstance(value, int)
+        }
         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/models/test.py

@@ -128,7 +128,7 @@ class TestModel(Model):
 
     def _get_output(self, model_request_parameters: ModelRequestParameters) -> _WrappedTextOutput | _WrappedToolOutput:
         if self.custom_output_text is not None:
-            assert model_request_parameters.allow_text_output, (
+            assert model_request_parameters.output_mode != 'tool', (
                 'Plain response not allowed, but `custom_output_text` is set.'
             )
             assert self.custom_output_args is None, 'Cannot set both `custom_output_text` and `custom_output_args`.'

pydantic_ai/models/wrapper.py

@@ -3,9 +3,11 @@ from __future__ import annotations
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
+from functools import cached_property
 from typing import Any
 
 from ..messages import ModelMessage, ModelResponse
+from ..profiles import ModelProfile
 from ..settings import ModelSettings
 from . import KnownModelName, Model, ModelRequestParameters, StreamedResponse, infer_model
 
@@ -47,5 +49,9 @@ class WrapperModel(Model):
     def system(self) -> str:
         return self.wrapped.system
 
+    @cached_property
+    def profile(self) -> ModelProfile:
+        return self.wrapped.profile
+
     def __getattr__(self, item: str):
         return getattr(self.wrapped, item)  # pragma: no cover

pydantic_ai/output.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Sequence
+from dataclasses import dataclass
+from typing import Callable, Generic, Literal, Union
+
+from typing_extensions import TypeAliasType, TypeVar
+
+from .tools import RunContext
+
+__all__ = (
+    # classes
+    'ToolOutput',
+    'NativeOutput',
+    'PromptedOutput',
+    'TextOutput',
+    # types
+    'OutputDataT',
+    'OutputMode',
+    'StructuredOutputMode',
+    'OutputSpec',
+    'OutputTypeOrFunction',
+    'TextOutputFunc',
+)
+
+T = TypeVar('T')
+T_co = TypeVar('T_co', covariant=True)
+
+OutputDataT = TypeVar('OutputDataT', default=str, covariant=True)
+"""Covariant type variable for the output data type of a run."""
+
+OutputMode = Literal['text', 'tool', 'native', 'prompted', 'tool_or_text']
+"""All output modes."""
+StructuredOutputMode = Literal['tool', 'native', 'prompted']
+"""Output modes that can be used for structured output. Used by ModelProfile.default_structured_output_mode"""
+
+
+OutputTypeOrFunction = TypeAliasType(
+    'OutputTypeOrFunction', Union[type[T_co], Callable[..., Union[Awaitable[T_co], T_co]]], type_params=(T_co,)
+)
+"""Definition of an output type or function.
+
+You should not need to import or use this type directly.
+
+See [output docs](../output.md) for more information.
+"""
+
+
+TextOutputFunc = TypeAliasType(
+    'TextOutputFunc',
+    Union[
+        Callable[[RunContext, str], Union[Awaitable[T_co], T_co]],
+        Callable[[str], Union[Awaitable[T_co], T_co]],
+    ],
+    type_params=(T_co,),
+)
+"""Definition of a function that will be called to process the model's plain text output. The function must take a single string argument.
+
+You should not need to import or use this type directly.
+
+See [text output docs](../output.md#text-output) for more information.
+"""
+
+
+@dataclass(init=False)
+class ToolOutput(Generic[OutputDataT]):
+    """Marker class to use a tool for output and optionally customize the tool.
+
+    Example:
+    ```python {title="tool_output.py"}
+    from pydantic import BaseModel
+
+    from pydantic_ai import Agent, ToolOutput
+
+
+    class Fruit(BaseModel):
+        name: str
+        color: str
+
+
+    class Vehicle(BaseModel):
+        name: str
+        wheels: int
+
+
+    agent = Agent(
+        'openai:gpt-4o',
+        output_type=[
+            ToolOutput(Fruit, name='return_fruit'),
+            ToolOutput(Vehicle, name='return_vehicle'),
+        ],
+    )
+    result = agent.run_sync('What is a banana?')
+    print(repr(result.output))
+    #> Fruit(name='banana', color='yellow')
+    ```
+    """
+
+    output: OutputTypeOrFunction[OutputDataT]
+    """An output type or function."""
+    name: str | None
+    """The name of the tool that will be passed to the model. If not specified and only one output is provided, `final_result` will be used. If multiple outputs are provided, the name of the output type or function will be added to the tool name."""
+    description: str | None
+    """The description of the tool that will be passed to the model. If not specified, the docstring of the output type or function will be used."""
+    max_retries: int | None
+    """The maximum number of retries for the tool."""
+    strict: bool | None
+    """Whether to use strict mode for the tool."""
+
+    def __init__(
+        self,
+        type_: OutputTypeOrFunction[OutputDataT],
+        *,
+        name: str | None = None,
+        description: str | None = None,
+        max_retries: int | None = None,
+        strict: bool | None = None,
+    ):
+        self.output = type_
+        self.name = name
+        self.description = description
+        self.max_retries = max_retries
+        self.strict = strict
+
+
+@dataclass(init=False)
+class NativeOutput(Generic[OutputDataT]):
+    """Marker class to use the model's native structured outputs functionality for outputs and optionally customize the name and description.
+
+    Example:
+    ```python {title="native_output.py" requires="tool_output.py"}
+    from tool_output import Fruit, Vehicle
+
+    from pydantic_ai import Agent, NativeOutput
+
+
+    agent = Agent(
+        'openai:gpt-4o',
+        output_type=NativeOutput(
+            [Fruit, Vehicle],
+            name='Fruit or vehicle',
+            description='Return a fruit or vehicle.'
+        ),
+    )
+    result = agent.run_sync('What is a Ford Explorer?')
+    print(repr(result.output))
+    #> Vehicle(name='Ford Explorer', wheels=4)
+    ```
+    """
+
+    outputs: OutputTypeOrFunction[OutputDataT] | Sequence[OutputTypeOrFunction[OutputDataT]]
+    """The output types or functions."""
+    name: str | None
+    """The name of the structured output that will be passed to the model. If not specified and only one output is provided, the name of the output type or function will be used."""
+    description: str | None
+    """The description of the structured output that will be passed to the model. If not specified and only one output is provided, the docstring of the output type or function will be used."""
+
+    def __init__(
+        self,
+        outputs: OutputTypeOrFunction[OutputDataT] | Sequence[OutputTypeOrFunction[OutputDataT]],
+        *,
+        name: str | None = None,
+        description: str | None = None,
+    ):
+        self.outputs = outputs
+        self.name = name
+        self.description = description
+
+
+@dataclass(init=False)
+class PromptedOutput(Generic[OutputDataT]):
+    """Marker class to use a prompt to tell the model what to output and optionally customize the prompt.
+
+    Example:
+    ```python {title="prompted_output.py" requires="tool_output.py"}
+    from pydantic import BaseModel
+    from tool_output import Vehicle
+
+    from pydantic_ai import Agent, PromptedOutput
+
+
+    class Device(BaseModel):
+        name: str
+        kind: str
+
+
+    agent = Agent(
+        'openai:gpt-4o',
+        output_type=PromptedOutput(
+            [Vehicle, Device],
+            name='Vehicle or device',
+            description='Return a vehicle or device.'
+        ),
+    )
+    result = agent.run_sync('What is a MacBook?')
+    print(repr(result.output))
+    #> Device(name='MacBook', kind='laptop')
+
+    agent = Agent(
+        'openai:gpt-4o',
+        output_type=PromptedOutput(
+            [Vehicle, Device],
+            template='Gimme some JSON: {schema}'
+        ),
+    )
+    result = agent.run_sync('What is a Ford Explorer?')
+    print(repr(result.output))
+    #> Vehicle(name='Ford Explorer', wheels=4)
+    ```
+    """
+
+    outputs: OutputTypeOrFunction[OutputDataT] | Sequence[OutputTypeOrFunction[OutputDataT]]
+    """The output types or functions."""
+    name: str | None
+    """The name of the structured output that will be passed to the model. If not specified and only one output is provided, the name of the output type or function will be used."""
+    description: str | None
+    """The description that will be passed to the model. If not specified and only one output is provided, the docstring of the output type or function will be used."""
+    template: str | None
+    """Template for the prompt passed to the model.
+    The '{schema}' placeholder will be replaced with the output JSON schema.
+    If not specified, the default template specified on the model's profile will be used.
+    """
+
+    def __init__(
+        self,
+        outputs: OutputTypeOrFunction[OutputDataT] | Sequence[OutputTypeOrFunction[OutputDataT]],
+        *,
+        name: str | None = None,
+        description: str | None = None,
+        template: str | None = None,
+    ):
+        self.outputs = outputs
+        self.name = name
+        self.description = description
+        self.template = template
+
+
+@dataclass
+class TextOutput(Generic[OutputDataT]):
+    """Marker class to use text output for an output function taking a string argument.
+
+    Example:
+    ```python
+    from pydantic_ai import Agent, TextOutput
+
+
+    def split_into_words(text: str) -> list[str]:
+        return text.split()
+
+
+    agent = Agent(
+        'openai:gpt-4o',
+        output_type=TextOutput(split_into_words),
+    )
+    result = agent.run_sync('Who was Albert Einstein?')
+    print(result.output)
+    #> ['Albert', 'Einstein', 'was', 'a', 'German-born', 'theoretical', 'physicist.']
+    ```
+    """
+
+    output_function: TextOutputFunc[OutputDataT]
+    """The function that will be called to process the model's plain text output. The function must take a single string argument."""
+
+
+OutputSpec = TypeAliasType(
+    'OutputSpec',
+    Union[
+        OutputTypeOrFunction[T_co],
+        ToolOutput[T_co],
+        NativeOutput[T_co],
+        PromptedOutput[T_co],
+        TextOutput[T_co],
+        Sequence[Union[OutputTypeOrFunction[T_co], ToolOutput[T_co], TextOutput[T_co]]],
+    ],
+    type_params=(T_co,),
+)
+"""Specification of the agent's output data.
+
+This can be a single type, a function, a sequence of types and/or functions, or an instance of one of the output mode marker classes:
+- [`ToolOutput`][pydantic_ai.output.ToolOutput]
+- [`NativeOutput`][pydantic_ai.output.NativeOutput]
+- [`PromptedOutput`][pydantic_ai.output.PromptedOutput]
+- [`TextOutput`][pydantic_ai.output.TextOutput]
+
+You should not need to import or use this type directly.
+
+See [output docs](../output.md) for more information.
+"""

pydantic_ai/profiles/__init__.py

@@ -1,10 +1,12 @@
 from __future__ import annotations as _annotations
 
 from dataclasses import dataclass, fields, replace
+from textwrap import dedent
 from typing import Callable, Union
 
 from typing_extensions import Self
 
+from ..output import StructuredOutputMode
 from ._json_schema import JsonSchemaTransformer
 
 
@@ -12,7 +14,26 @@ from ._json_schema import JsonSchemaTransformer
 class ModelProfile:
     """Describes how requests to a specific model or family of models need to be constructed to get the best results, independent of the model and provider classes used."""
 
+    supports_tools: bool = True
+    """Whether the model supports tools."""
+    supports_json_schema_output: bool = False
+    """Whether the model supports JSON schema output."""
+    supports_json_object_output: bool = False
+    """Whether the model supports JSON object output."""
+    default_structured_output_mode: StructuredOutputMode = 'tool'
+    """The default structured output mode to use for the model."""
+    prompted_output_template: str = dedent(
+        """
+        Always respond with a JSON object that's compatible with this schema:
+
+        {schema}
+
+        Don't include any text or Markdown fencing before or after.
+        """
+    )
+    """The instructions template to use for prompted structured output. The '{schema}' placeholder will be replaced with the JSON schema for the output."""
     json_schema_transformer: type[JsonSchemaTransformer] | None = None
+    """The transformer to use to make JSON schemas for tools and structured output compatible with the model."""
 
     @classmethod
     def from_profile(cls, profile: ModelProfile | None) -> Self:

pydantic_ai/profiles/_json_schema.py

@@ -174,7 +174,7 @@ class JsonSchemaTransformer(ABC):
                 # they are both null, so just return one of them
                 return [cases[0]]
 
-        return cases  # pragma: no cover
+        return cases
 
 
 class InlineDefsJsonSchemaTransformer(JsonSchemaTransformer):

pydantic_ai/profiles/google.py

@@ -10,7 +10,11 @@ from ._json_schema import JsonSchema, JsonSchemaTransformer
 
 def google_model_profile(model_name: str) -> ModelProfile | None:
     """Get the model profile for a Google model."""
-    return ModelProfile(json_schema_transformer=GoogleJsonSchemaTransformer)
+    return ModelProfile(
+        json_schema_transformer=GoogleJsonSchemaTransformer,
+        supports_json_schema_output=True,
+        supports_json_object_output=True,
+    )
 
 
 class GoogleJsonSchemaTransformer(JsonSchemaTransformer):
@@ -47,7 +51,7 @@ class GoogleJsonSchemaTransformer(JsonSchemaTransformer):
         schema.pop('title', None)
         schema.pop('default', None)
         schema.pop('$schema', None)
-        if (const := schema.pop('const', None)) is not None:  # pragma: no cover
+        if (const := schema.pop('const', None)) is not None:
             # Gemini doesn't support const, but it does support enum with a single value
             schema['enum'] = [const]
         schema.pop('discriminator', None)

pydantic_ai/profiles/openai.py

@@ -25,8 +25,13 @@ class OpenAIModelProfile(ModelProfile):
 def openai_model_profile(model_name: str) -> ModelProfile:
     """Get the model profile for an OpenAI model."""
     is_reasoning_model = model_name.startswith('o')
+    # Structured Outputs (output mode 'native') is only supported with the gpt-4o-mini, gpt-4o-mini-2024-07-18, and gpt-4o-2024-08-06 model snapshots and later.
+    # We leave it in here for all models because the `default_structured_output_mode` is `'tool'`, so `native` is only used
+    # when the user specifically uses the `NativeOutput` marker, so an error from the API is acceptable.
     return OpenAIModelProfile(
         json_schema_transformer=OpenAIJsonSchemaTransformer,
+        supports_json_schema_output=True,
+        supports_json_object_output=True,
         openai_supports_sampling_settings=not is_reasoning_model,
     )