pydantic-ai-slim 0.2.11__py3-none-any.whl → 0.2.13__py3-none-any.whl

pydantic_ai/models/google.py

@@ -1,19 +1,18 @@
 from __future__ import annotations as _annotations
 
 import base64
-import warnings
 from collections.abc import AsyncIterator, Awaitable
 from contextlib import asynccontextmanager
-from dataclasses import dataclass, field, replace
+from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Literal, Union, cast, overload
+from typing import Any, Literal, Union, cast, overload
 from uuid import uuid4
 
 from typing_extensions import assert_never
 
 from pydantic_ai.providers import Provider
 
-from .. import UnexpectedModelBehavior, UserError, _utils, usage
+from .. import UnexpectedModelBehavior, _utils, usage
 from ..messages import (
     AudioUrl,
     BinaryContent,
@@ -32,6 +31,7 @@ from ..messages import (
     UserPromptPart,
     VideoUrl,
 )
+from ..profiles import ModelProfileSpec
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
 from . import (
@@ -42,7 +42,6 @@ from . import (
     check_allow_model_requests,
     get_user_agent,
 )
-from ._json_schema import JsonSchema, WalkJsonSchema
 
 try:
     from google import genai
@@ -141,6 +140,7 @@ class GoogleModel(Model):
         model_name: GoogleModelName,
         *,
         provider: Literal['google-gla', 'google-vertex'] | Provider[genai.Client] = 'google-gla',
+        profile: ModelProfileSpec | None = None,
     ):
         """Initialize a Gemini model.
 
@@ -149,6 +149,7 @@ class GoogleModel(Model):
             provider: The provider to use for authentication and API access. Can be either the string
                 'google-gla' or 'google-vertex' or an instance of `Provider[httpx.AsyncClient]`.
                 If not provided, a new provider will be created using the other parameters.
+            profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
         """
         self._model_name = model_name
 
@@ -158,6 +159,7 @@ class GoogleModel(Model):
         self._provider = provider
         self._system = provider.name
         self.client = provider.client
+        self._profile = profile or provider.model_profile
 
     @property
     def base_url(self) -> str:
@@ -186,16 +188,6 @@ class GoogleModel(Model):
         response = await self._generate_content(messages, True, model_settings, model_request_parameters)
         yield await self._process_streamed_response(response)  # type: ignore
 
-    def customize_request_parameters(self, model_request_parameters: ModelRequestParameters) -> ModelRequestParameters:
-        def _customize_tool_def(t: ToolDefinition):
-            return replace(t, parameters_json_schema=_GeminiJsonSchema(t.parameters_json_schema).walk())
-
-        return ModelRequestParameters(
-            function_tools=[_customize_tool_def(tool) for tool in model_request_parameters.function_tools],
-            allow_text_output=model_request_parameters.allow_text_output,
-            output_tools=[_customize_tool_def(tool) for tool in model_request_parameters.output_tools],
-        )
-
     @property
     def model_name(self) -> GoogleModelName:
         """The model name."""
@@ -291,9 +283,16 @@ class GoogleModel(Model):
                     'Content field missing from Gemini response', str(response)
                 )  # pragma: no cover
         parts = response.candidates[0].content.parts or []
+        vendor_id = response.response_id or None
+        vendor_details: dict[str, Any] | None = None
+        finish_reason = response.candidates[0].finish_reason
+        if finish_reason:  # pragma: no branch
+            vendor_details = {'finish_reason': finish_reason.value}
         usage = _metadata_as_usage(response)
         usage.requests = 1
-        return _process_response_from_parts(parts, response.model_version or self._model_name, usage)
+        return _process_response_from_parts(
+            parts, response.model_version or self._model_name, usage, vendor_id=vendor_id, vendor_details=vendor_details
+        )
 
     async def _process_streamed_response(self, response: AsyncIterator[GenerateContentResponse]) -> StreamedResponse:
         """Process a streamed response, and prepare a streaming response to return."""
@@ -392,7 +391,7 @@ class GeminiStreamedResponse(StreamedResponse):
 
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
         async for chunk in self._response:
-            self._usage += _metadata_as_usage(chunk)
+            self._usage = _metadata_as_usage(chunk)
 
             assert chunk.candidates is not None
             candidate = chunk.candidates[0]
@@ -400,7 +399,7 @@ class GeminiStreamedResponse(StreamedResponse):
                 raise UnexpectedModelBehavior('Streamed response has no content field')  # pragma: no cover
             assert candidate.content.parts is not None
             for part in candidate.content.parts:
-                if part.text:
+                if part.text is not None:
                     yield self._parts_manager.handle_text_delta(vendor_part_id='content', content=part.text)
                 elif part.function_call:
                     maybe_event = self._parts_manager.handle_tool_call_delta(
@@ -439,10 +438,16 @@ def _content_model_response(m: ModelResponse) -> ContentDict:
     return ContentDict(role='model', parts=parts)
 
 
-def _process_response_from_parts(parts: list[Part], model_name: GoogleModelName, usage: usage.Usage) -> ModelResponse:
+def _process_response_from_parts(
+    parts: list[Part],
+    model_name: GoogleModelName,
+    usage: usage.Usage,
+    vendor_id: str | None,
+    vendor_details: dict[str, Any] | None = None,
+) -> ModelResponse:
     items: list[ModelResponsePart] = []
     for part in parts:
-        if part.text:
+        if part.text is not None:
             items.append(TextPart(content=part.text))
         elif part.function_call:
             assert part.function_call.name is not None
@@ -454,7 +459,9 @@ def _process_response_from_parts(parts: list[Part], model_name: GoogleModelName,
             raise UnexpectedModelBehavior(
                 f'Unsupported response from Gemini, expected all parts to be function calls or text, got: {part!r}'
             )
-    return ModelResponse(parts=items, model_name=model_name, usage=usage)
+    return ModelResponse(
+        parts=items, model_name=model_name, usage=usage, vendor_id=vendor_id, vendor_details=vendor_details
+    )
 
 
 def _function_declaration_from_tool(tool: ToolDefinition) -> FunctionDeclarationDict:
@@ -475,99 +482,27 @@ def _metadata_as_usage(response: GenerateContentResponse) -> usage.Usage:
     metadata = response.usage_metadata
     if metadata is None:
         return usage.Usage()  # pragma: no cover
-    # TODO(Marcelo): We exclude the `prompt_tokens_details` and `candidate_token_details` fields because on
-    # `usage.Usage.incr``, it will try to sum non-integer values with integers, which will fail. We should probably
-    # handle this in the `Usage` class.
-    details = metadata.model_dump(
-        exclude={'prompt_tokens_details', 'candidates_tokens_details', 'traffic_type'},
-        exclude_defaults=True,
-    )
-    return usage.Usage(
-        request_tokens=details.pop('prompt_token_count', 0),
-        response_tokens=details.pop('candidates_token_count', 0),
-        total_tokens=details.pop('total_token_count', 0),
-        details=details,
-    )
+    metadata = metadata.model_dump(exclude_defaults=True)
 
+    details: dict[str, int] = {}
+    if cached_content_token_count := metadata.get('cached_content_token_count'):
+        details['cached_content_tokens'] = cached_content_token_count  # pragma: no cover
 
-class _GeminiJsonSchema(WalkJsonSchema):
-    """Transforms the JSON Schema from Pydantic to be suitable for Gemini.
+    if thoughts_token_count := metadata.get('thoughts_token_count'):
+        details['thoughts_tokens'] = thoughts_token_count
 
-    Gemini which [supports](https://ai.google.dev/gemini-api/docs/function-calling#function_declarations)
-    a subset of OpenAPI v3.0.3.
+    if tool_use_prompt_token_count := metadata.get('tool_use_prompt_token_count'):
+        details['tool_use_prompt_tokens'] = tool_use_prompt_token_count  # pragma: no cover
 
-    Specifically:
-    * gemini doesn't allow the `title` keyword to be set
-    * gemini doesn't allow `$defs` — we need to inline the definitions where possible
-    """
+    for key, metadata_details in metadata.items():
+        if key.endswith('_details') and metadata_details:
+            suffix = key.removesuffix('_details')
+            for detail in metadata_details:
+                details[f'{detail["modality"].lower()}_{suffix}'] = detail['token_count']
 
-    def __init__(self, schema: JsonSchema):
-        super().__init__(schema, prefer_inlined_defs=True, simplify_nullable_unions=True)
-
-    def transform(self, schema: JsonSchema) -> JsonSchema:
-        # Note: we need to remove `additionalProperties: False` since it is currently mishandled by Gemini
-        additional_properties = schema.pop(
-            'additionalProperties', None
-        )  # don't pop yet so it's included in the warning
-        if additional_properties:  # pragma: no cover
-            original_schema = {**schema, 'additionalProperties': additional_properties}
-            warnings.warn(
-                '`additionalProperties` is not supported by Gemini; it will be removed from the tool JSON schema.'
-                f' Full schema: {self.schema}\n\n'
-                f'Source of additionalProperties within the full schema: {original_schema}\n\n'
-                'If this came from a field with a type like `dict[str, MyType]`, that field will always be empty.\n\n'
-                "If Google's APIs are updated to support this properly, please create an issue on the PydanticAI GitHub"
-                ' and we will fix this behavior.',
-                UserWarning,
-            )
-
-        schema.pop('title', None)
-        schema.pop('default', None)
-        schema.pop('$schema', None)
-        if (const := schema.pop('const', None)) is not None:  # pragma: no cover
-            # Gemini doesn't support const, but it does support enum with a single value
-            schema['enum'] = [const]
-        schema.pop('discriminator', None)
-        schema.pop('examples', None)
-
-        # TODO: Should we use the trick from pydantic_ai.models.openai._OpenAIJsonSchema
-        #   where we add notes about these properties to the field description?
-        schema.pop('exclusiveMaximum', None)
-        schema.pop('exclusiveMinimum', None)
-
-        type_ = schema.get('type')
-        if 'oneOf' in schema and 'type' not in schema:  # pragma: no cover
-            # This gets hit when we have a discriminated union
-            # Gemini returns an API error in this case even though it says in its error message it shouldn't...
-            # Changing the oneOf to an anyOf prevents the API error and I think is functionally equivalent
-            schema['anyOf'] = schema.pop('oneOf')
-
-        if type_ == 'string' and (fmt := schema.pop('format', None)):
-            description = schema.get('description')
-            if description:
-                schema['description'] = f'{description} (format: {fmt})'
-            else:
-                schema['description'] = f'Format: {fmt}'
-
-        if '$ref' in schema:
-            raise UserError(  # pragma: no cover
-                f'Recursive `$ref`s in JSON Schema are not supported by Gemini: {schema["$ref"]}'
-            )
-
-        if 'prefixItems' in schema:  # pragma: lax no cover
-            # prefixItems is not currently supported in Gemini, so we convert it to items for best compatibility
-            prefix_items = schema.pop('prefixItems')
-            items = schema.get('items')
-            unique_items = [items] if items is not None else []
-            for item in prefix_items:
-                if item not in unique_items:
-                    unique_items.append(item)
-            if len(unique_items) > 1:  # pragma: no cover
-                schema['items'] = {'anyOf': unique_items}
-            elif len(unique_items) == 1:
-                schema['items'] = unique_items[0]
-            schema.setdefault('minItems', len(prefix_items))
-            if items is None:
-                schema.setdefault('maxItems', len(prefix_items))
-
-        return schema
+    return usage.Usage(
+        request_tokens=metadata.get('prompt_token_count', 0),
+        response_tokens=metadata.get('candidates_token_count', 0),
+        total_tokens=metadata.get('total_token_count', 0),
+        details=details,
+    )

pydantic_ai/models/groq.py

@@ -27,10 +27,17 @@ from ..messages import (
     ToolReturnPart,
     UserPromptPart,
 )
+from ..profiles import ModelProfileSpec
 from ..providers import Provider, infer_provider
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
-from . import Model, ModelRequestParameters, StreamedResponse, check_allow_model_requests, get_user_agent
+from . import (
+    Model,
+    ModelRequestParameters,
+    StreamedResponse,
+    check_allow_model_requests,
+    get_user_agent,
+)
 
 try:
     from groq import NOT_GIVEN, APIStatusError, AsyncGroq, AsyncStream
@@ -105,7 +112,13 @@ class GroqModel(Model):
     _model_name: GroqModelName = field(repr=False)
     _system: str = field(default='groq', repr=False)
 
-    def __init__(self, model_name: GroqModelName, *, provider: Literal['groq'] | Provider[AsyncGroq] = 'groq'):
+    def __init__(
+        self,
+        model_name: GroqModelName,
+        *,
+        provider: Literal['groq'] | Provider[AsyncGroq] = 'groq',
+        profile: ModelProfileSpec | None = None,
+    ):
         """Initialize a Groq model.
 
         Args:
@@ -114,12 +127,14 @@ class GroqModel(Model):
             provider: The provider to use for authentication and API access. Can be either the string
                 'groq' or an instance of `Provider[AsyncGroq]`. If not provided, a new provider will be
                 created using the other parameters.
+            profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
         """
         self._model_name = model_name
 
         if isinstance(provider, str):
             provider = infer_provider(provider)
         self.client = provider.client
+        self._profile = profile or provider.model_profile
 
     @property
     def base_url(self) -> str:

pydantic_ai/models/mistral.py

@@ -30,6 +30,7 @@ from ..messages import (
     UserPromptPart,
     VideoUrl,
 )
+from ..profiles import ModelProfileSpec
 from ..providers import Provider, infer_provider
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
@@ -120,6 +121,7 @@ class MistralModel(Model):
         model_name: MistralModelName,
         *,
         provider: Literal['mistral'] | Provider[Mistral] = 'mistral',
+        profile: ModelProfileSpec | None = None,
         json_mode_schema_prompt: str = """Answer in JSON Object, respect the format:\n```\n{schema}\n```\n""",
     ):
         """Initialize a Mistral model.
@@ -129,6 +131,7 @@ class MistralModel(Model):
             provider: The provider to use for authentication and API access. Can be either the string
                 'mistral' or an instance of `Provider[Mistral]`. If not provided, a new provider will be
                 created using the other parameters.
+            profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
             json_mode_schema_prompt: The prompt to show when the model expects a JSON object as input.
         """
         self._model_name = model_name
@@ -137,6 +140,7 @@ class MistralModel(Model):
         if isinstance(provider, str):
             provider = infer_provider(provider)
         self.client = provider.client
+        self._profile = profile or provider.model_profile
 
     @property
     def base_url(self) -> str:

pydantic_ai/models/openai.py

@@ -1,16 +1,16 @@
 from __future__ import annotations as _annotations
 
 import base64
-import re
 import warnings
 from collections.abc import AsyncIterable, AsyncIterator, Sequence
 from contextlib import asynccontextmanager
-from dataclasses import dataclass, field, replace
+from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from typing import Any, Literal, Union, cast, overload
 
 from typing_extensions import assert_never
 
+from pydantic_ai.profiles.openai import OpenAIModelProfile
 from pydantic_ai.providers import Provider, infer_provider
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
@@ -33,6 +33,7 @@ from ..messages import (
     UserPromptPart,
     VideoUrl,
 )
+from ..profiles import ModelProfileSpec
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
 from . import (
@@ -43,7 +44,6 @@ from . import (
     check_allow_model_requests,
     get_user_agent,
 )
-from ._json_schema import JsonSchema, WalkJsonSchema
 
 try:
     from openai import NOT_GIVEN, APIStatusError, AsyncOpenAI, AsyncStream, NotGiven
@@ -170,7 +170,9 @@ class OpenAIModel(Model):
         self,
         model_name: OpenAIModelName,
         *,
-        provider: Literal['openai', 'deepseek', 'azure', 'openrouter'] | Provider[AsyncOpenAI] = 'openai',
+        provider: Literal['openai', 'deepseek', 'azure', 'openrouter', 'grok', 'fireworks', 'together']
+        | Provider[AsyncOpenAI] = 'openai',
+        profile: ModelProfileSpec | None = None,
         system_prompt_role: OpenAISystemPromptRole | None = None,
     ):
         """Initialize an OpenAI model.
@@ -180,13 +182,17 @@ class OpenAIModel(Model):
                 [here](https://github.com/openai/openai-python/blob/v1.54.3/src/openai/types/chat_model.py#L7)
                 (Unfortunately, despite being ask to do so, OpenAI do not provide `.inv` files for their API).
             provider: The provider to use. Defaults to `'openai'`.
+            profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
             system_prompt_role: The role to use for the system prompt message. If not provided, defaults to `'system'`.
                 In the future, this may be inferred from the model name.
         """
         self._model_name = model_name
+
         if isinstance(provider, str):
             provider = infer_provider(provider)
         self.client = provider.client
+        self._profile = profile or provider.model_profile
+
         self.system_prompt_role = system_prompt_role
 
     @property
@@ -221,9 +227,6 @@ class OpenAIModel(Model):
         async with response:
             yield await self._process_streamed_response(response)
 
-    def customize_request_parameters(self, model_request_parameters: ModelRequestParameters) -> ModelRequestParameters:
-        return _customize_request_parameters(model_request_parameters)
-
     @property
     def model_name(self) -> OpenAIModelName:
         """The model name."""
@@ -331,7 +334,9 @@ 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, tool_call_id=c.id))
+                part = ToolCallPart(c.function.name, c.function.arguments, tool_call_id=c.id)
+                part.tool_call_id = _guard_tool_call_id(part)
+                items.append(part)
         return ModelResponse(
             items,
             usage=_map_usage(response),
@@ -401,8 +406,7 @@ class OpenAIModel(Model):
             function={'name': t.tool_name, 'arguments': t.args_as_json_str()},
         )
 
-    @staticmethod
-    def _map_tool_definition(f: ToolDefinition) -> chat.ChatCompletionToolParam:
+    def _map_tool_definition(self, f: ToolDefinition) -> chat.ChatCompletionToolParam:
         tool_param: chat.ChatCompletionToolParam = {
             'type': 'function',
             'function': {
@@ -411,7 +415,7 @@ class OpenAIModel(Model):
                 'parameters': f.parameters_json_schema,
             },
         }
-        if f.strict:
+        if f.strict and OpenAIModelProfile.from_profile(self.profile).openai_supports_strict_tool_definition:
             tool_param['function']['strict'] = f.strict
         return tool_param
 
@@ -533,18 +537,23 @@ class OpenAIResponsesModel(Model):
         self,
         model_name: OpenAIModelName,
         *,
-        provider: Literal['openai', 'deepseek', 'azure'] | Provider[AsyncOpenAI] = 'openai',
+        provider: Literal['openai', 'deepseek', 'azure', 'openrouter', 'grok', 'fireworks', 'together']
+        | Provider[AsyncOpenAI] = 'openai',
+        profile: ModelProfileSpec | None = None,
     ):
         """Initialize an OpenAI Responses model.
 
         Args:
             model_name: The name of the OpenAI model to use.
             provider: The provider to use. Defaults to `'openai'`.
+            profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
         """
         self._model_name = model_name
+
         if isinstance(provider, str):
             provider = infer_provider(provider)
         self.client = provider.client
+        self._profile = profile or provider.model_profile
 
     @property
     def model_name(self) -> OpenAIModelName:
@@ -582,9 +591,6 @@ class OpenAIResponsesModel(Model):
         async with response:
             yield await self._process_streamed_response(response)
 
-    def customize_request_parameters(self, model_request_parameters: ModelRequestParameters) -> ModelRequestParameters:
-        return _customize_request_parameters(model_request_parameters)
-
     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)
@@ -690,15 +696,15 @@ class OpenAIResponsesModel(Model):
             tools += [self._map_tool_definition(r) for r in model_request_parameters.output_tools]
         return tools
 
-    @staticmethod
-    def _map_tool_definition(f: ToolDefinition) -> responses.FunctionToolParam:
+    def _map_tool_definition(self, f: ToolDefinition) -> responses.FunctionToolParam:
         return {
             'name': f.name,
             'parameters': f.parameters_json_schema,
             'type': 'function',
             'description': f.description,
-            # NOTE: f.strict should already be a boolean thanks to customize_request_parameters
-            'strict': f.strict or False,
+            'strict': bool(
+                f.strict and OpenAIModelProfile.from_profile(self.profile).openai_supports_strict_tool_definition
+            ),
         }
 
     async def _map_messages(
@@ -980,142 +986,3 @@ def _map_usage(response: chat.ChatCompletion | ChatCompletionChunk | responses.R
             total_tokens=response_usage.total_tokens,
             details=details,
         )
-
-
-_STRICT_INCOMPATIBLE_KEYS = [
-    'minLength',
-    'maxLength',
-    'pattern',
-    'format',
-    'minimum',
-    'maximum',
-    'multipleOf',
-    'patternProperties',
-    'unevaluatedProperties',
-    'propertyNames',
-    'minProperties',
-    'maxProperties',
-    'unevaluatedItems',
-    'contains',
-    'minContains',
-    'maxContains',
-    'minItems',
-    'maxItems',
-    'uniqueItems',
-]
-
-_sentinel = object()
-
-
-@dataclass
-class _OpenAIJsonSchema(WalkJsonSchema):
-    """Recursively handle the schema to make it compatible with OpenAI strict mode.
-
-    See https://platform.openai.com/docs/guides/function-calling?api-mode=responses#strict-mode for more details,
-    but this basically just requires:
-    * `additionalProperties` must be set to false for each object in the parameters
-    * all fields in properties must be marked as required
-    """
-
-    def __init__(self, schema: JsonSchema, strict: bool | None):
-        super().__init__(schema)
-        self.strict = strict
-        self.is_strict_compatible = True
-        self.root_ref = schema.get('$ref')
-
-    def walk(self) -> JsonSchema:
-        # Note: OpenAI does not support anyOf at the root in strict mode
-        # However, we don't need to check for it here because we ensure in pydantic_ai._utils.check_object_json_schema
-        # that the root schema either has type 'object' or is recursive.
-        result = super().walk()
-
-        # For recursive models, we need to tweak the schema to make it compatible with strict mode.
-        # Because the following should never change the semantics of the schema we apply it unconditionally.
-        if self.root_ref is not None:
-            result.pop('$ref', None)  # We replace references to the self.root_ref with just '#' in the transform method
-            root_key = re.sub(r'^#/\$defs/', '', self.root_ref)
-            result.update(self.defs.get(root_key) or {})
-
-        return result
-
-    def transform(self, schema: JsonSchema) -> JsonSchema:  # noqa C901
-        # Remove unnecessary keys
-        schema.pop('title', None)
-        schema.pop('default', None)
-        schema.pop('$schema', None)
-        schema.pop('discriminator', None)
-
-        if schema_ref := schema.get('$ref'):
-            if schema_ref == self.root_ref:
-                schema['$ref'] = '#'
-            if len(schema) > 1:
-                # OpenAI Strict mode doesn't support siblings to "$ref", but _does_ allow siblings to "anyOf".
-                # So if there is a "description" field or any other extra info, we move the "$ref" into an "anyOf":
-                schema['anyOf'] = [{'$ref': schema.pop('$ref')}]
-
-        # Track strict-incompatible keys
-        incompatible_values: dict[str, Any] = {}
-        for key in _STRICT_INCOMPATIBLE_KEYS:
-            value = schema.get(key, _sentinel)
-            if value is not _sentinel:
-                incompatible_values[key] = value
-        description = schema.get('description')
-        if incompatible_values:
-            if self.strict is True:
-                notes: list[str] = []
-                for key, value in incompatible_values.items():
-                    schema.pop(key)
-                    notes.append(f'{key}={value}')
-                notes_string = ', '.join(notes)
-                schema['description'] = notes_string if not description else f'{description} ({notes_string})'
-            elif self.strict is None:  # pragma: no branch
-                self.is_strict_compatible = False
-
-        schema_type = schema.get('type')
-        if 'oneOf' in schema:
-            # OpenAI does not support oneOf in strict mode
-            if self.strict is True:
-                schema['anyOf'] = schema.pop('oneOf')
-            else:
-                self.is_strict_compatible = False
-
-        if schema_type == 'object':
-            if self.strict is True:
-                # additional properties are disallowed
-                schema['additionalProperties'] = False
-
-                # all properties are required
-                if 'properties' not in schema:
-                    schema['properties'] = dict[str, Any]()
-                schema['required'] = list(schema['properties'].keys())
-
-            elif self.strict is None:
-                if (
-                    schema.get('additionalProperties') is not False
-                    or 'properties' not in schema
-                    or 'required' not in schema
-                ):
-                    self.is_strict_compatible = False
-                else:
-                    required = schema['required']
-                    for k in schema['properties'].keys():
-                        if k not in required:
-                            self.is_strict_compatible = False
-        return schema
-
-
-def _customize_request_parameters(model_request_parameters: ModelRequestParameters) -> ModelRequestParameters:
-    """Customize the request parameters for OpenAI models."""
-
-    def _customize_tool_def(t: ToolDefinition):
-        schema_transformer = _OpenAIJsonSchema(t.parameters_json_schema, strict=t.strict)
-        parameters_json_schema = schema_transformer.walk()
-        if t.strict is None:
-            t = replace(t, strict=schema_transformer.is_strict_compatible)
-        return replace(t, parameters_json_schema=parameters_json_schema)
-
-    return ModelRequestParameters(
-        function_tools=[_customize_tool_def(tool) for tool in model_request_parameters.function_tools],
-        allow_text_output=model_request_parameters.allow_text_output,
-        output_tools=[_customize_tool_def(tool) for tool in model_request_parameters.output_tools],
-    )

pydantic_ai/profiles/__init__.py

@@ -0,0 +1,39 @@
+from __future__ import annotations as _annotations
+
+from dataclasses import dataclass, fields, replace
+from typing import Callable, Union
+
+from typing_extensions import Self
+
+from ._json_schema import JsonSchemaTransformer
+
+
+@dataclass
+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."""
+
+    json_schema_transformer: type[JsonSchemaTransformer] | None = None
+
+    @classmethod
+    def from_profile(cls, profile: ModelProfile | None) -> Self:
+        """Build a ModelProfile subclass instance from a ModelProfile instance."""
+        if isinstance(profile, cls):
+            return profile
+        return cls().update(profile)
+
+    def update(self, profile: ModelProfile | None) -> Self:
+        """Update this ModelProfile (subclass) instance with the non-default values from another ModelProfile instance."""
+        if not profile:
+            return self
+        field_names = set(f.name for f in fields(self))
+        non_default_attrs = {
+            f.name: getattr(profile, f.name)
+            for f in fields(profile)
+            if f.name in field_names and getattr(profile, f.name) != f.default
+        }
+        return replace(self, **non_default_attrs)
+
+
+ModelProfileSpec = Union[ModelProfile, Callable[[str], Union[ModelProfile, None]]]
+
+DEFAULT_PROFILE = ModelProfile()