pydantic-ai-slim 0.0.55__py3-none-any.whl → 0.1.1__py3-none-any.whl

pydantic_ai/models/mistral.py

@@ -5,7 +5,6 @@ from collections.abc import AsyncIterable, AsyncIterator, Iterable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from itertools import chain
 from typing import Any, Literal, Union, cast
 
 import pydantic_core
@@ -29,11 +28,12 @@ from ..messages import (
     ToolCallPart,
     ToolReturnPart,
     UserPromptPart,
+    VideoUrl,
 )
 from ..providers import Provider, infer_provider
-from ..result import Usage
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
+from ..usage import Usage
 from . import (
     Model,
     ModelRequestParameters,
@@ -168,7 +168,7 @@ class MistralModel(Model):
             messages, cast(MistralModelSettings, model_settings or {}), model_request_parameters
         )
         async with response:
-            yield await self._process_streamed_response(model_request_parameters.result_tools, response)
+            yield await self._process_streamed_response(model_request_parameters.output_tools, response)
 
     @property
     def model_name(self) -> MistralModelName:
@@ -190,9 +190,9 @@ class MistralModel(Model):
         try:
             response = await self.client.chat.complete_async(
                 model=str(self._model_name),
-                messages=list(chain(*(self._map_message(m) for m in messages))),
+                messages=self._map_messages(messages),
                 n=1,
-                tools=self._map_function_and_result_tools_definition(model_request_parameters) or UNSET,
+                tools=self._map_function_and_output_tools_definition(model_request_parameters) or UNSET,
                 tool_choice=self._get_tool_choice(model_request_parameters),
                 stream=False,
                 max_tokens=model_settings.get('max_tokens', UNSET),
@@ -219,10 +219,10 @@ class MistralModel(Model):
     ) -> MistralEventStreamAsync[MistralCompletionEvent]:
         """Create a streaming completion request to the Mistral model."""
         response: MistralEventStreamAsync[MistralCompletionEvent] | None
-        mistral_messages = list(chain(*(self._map_message(m) for m in messages)))
+        mistral_messages = self._map_messages(messages)
 
         if (
-            model_request_parameters.result_tools
+            model_request_parameters.output_tools
             and model_request_parameters.function_tools
             or model_request_parameters.function_tools
         ):
@@ -231,7 +231,7 @@ class MistralModel(Model):
                 model=str(self._model_name),
                 messages=mistral_messages,
                 n=1,
-                tools=self._map_function_and_result_tools_definition(model_request_parameters) or UNSET,
+                tools=self._map_function_and_output_tools_definition(model_request_parameters) or UNSET,
                 tool_choice=self._get_tool_choice(model_request_parameters),
                 temperature=model_settings.get('temperature', UNSET),
                 top_p=model_settings.get('top_p', 1),
@@ -243,9 +243,9 @@ class MistralModel(Model):
                 http_headers={'User-Agent': get_user_agent()},
             )
 
-        elif model_request_parameters.result_tools:
+        elif model_request_parameters.output_tools:
             # Json Mode
-            parameters_json_schemas = [tool.parameters_json_schema for tool in model_request_parameters.result_tools]
+            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)
             mistral_messages.append(user_output_format_message)
 
@@ -276,22 +276,22 @@ class MistralModel(Model):
         - "none": Prevents tool use.
         - "required": Forces tool use.
         """
-        if not model_request_parameters.function_tools and not model_request_parameters.result_tools:
+        if not model_request_parameters.function_tools and not model_request_parameters.output_tools:
             return None
-        elif not model_request_parameters.allow_text_result:
+        elif not model_request_parameters.allow_text_output:
             return 'required'
         else:
             return 'auto'
 
-    def _map_function_and_result_tools_definition(
+    def _map_function_and_output_tools_definition(
         self, model_request_parameters: ModelRequestParameters
     ) -> list[MistralTool] | None:
-        """Map function and result tools to MistralTool format.
+        """Map function and output tools to MistralTool format.
 
-        Returns None if both function_tools and result_tools are empty.
+        Returns None if both function_tools and output_tools are empty.
         """
         all_tools: list[ToolDefinition] = (
-            model_request_parameters.function_tools + model_request_parameters.result_tools
+            model_request_parameters.function_tools + model_request_parameters.output_tools
         )
         tools = [
             MistralTool(
@@ -327,7 +327,7 @@ class MistralModel(Model):
 
     async def _process_streamed_response(
         self,
-        result_tools: list[ToolDefinition],
+        output_tools: list[ToolDefinition],
         response: MistralEventStreamAsync[MistralCompletionEvent],
     ) -> StreamedResponse:
         """Process a streamed response, and prepare a streaming response to return."""
@@ -345,7 +345,7 @@ class MistralModel(Model):
             _response=peekable_response,
             _model_name=self._model_name,
             _timestamp=timestamp,
-            _result_tools={c.name: c for c in result_tools},
+            _output_tools={c.name: c for c in output_tools},
         )
 
     @staticmethod
@@ -439,13 +439,12 @@ class MistralModel(Model):
             return int(1000 * timeout)
         raise NotImplementedError('Timeout object is not yet supported for MistralModel.')
 
-    @classmethod
-    def _map_user_message(cls, message: ModelRequest) -> Iterable[MistralMessages]:
+    def _map_user_message(self, message: ModelRequest) -> Iterable[MistralMessages]:
         for part in message.parts:
             if isinstance(part, SystemPromptPart):
                 yield MistralSystemMessage(content=part.content)
             elif isinstance(part, UserPromptPart):
-                yield cls._map_user_prompt(part)
+                yield self._map_user_prompt(part)
             elif isinstance(part, ToolReturnPart):
                 yield MistralToolMessage(
                     tool_call_id=part.tool_call_id,
@@ -462,28 +461,31 @@ class MistralModel(Model):
             else:
                 assert_never(part)
 
-    @classmethod
-    def _map_message(cls, message: ModelMessage) -> Iterable[MistralMessages]:
+    def _map_messages(self, messages: list[ModelMessage]) -> list[MistralMessages]:
         """Just maps a `pydantic_ai.Message` to a `MistralMessage`."""
-        if isinstance(message, ModelRequest):
-            yield from cls._map_user_message(message)
-        elif isinstance(message, ModelResponse):
-            content_chunks: list[MistralContentChunk] = []
-            tool_calls: list[MistralToolCall] = []
-
-            for part in message.parts:
-                if isinstance(part, TextPart):
-                    content_chunks.append(MistralTextChunk(text=part.content))
-                elif isinstance(part, ToolCallPart):
-                    tool_calls.append(cls._map_tool_call(part))
-                else:
-                    assert_never(part)
-            yield MistralAssistantMessage(content=content_chunks, tool_calls=tool_calls)
-        else:
-            assert_never(message)
+        mistral_messages: list[MistralMessages] = []
+        for message in messages:
+            if isinstance(message, ModelRequest):
+                mistral_messages.extend(self._map_user_message(message))
+            elif isinstance(message, ModelResponse):
+                content_chunks: list[MistralContentChunk] = []
+                tool_calls: list[MistralToolCall] = []
+
+                for part in message.parts:
+                    if isinstance(part, TextPart):
+                        content_chunks.append(MistralTextChunk(text=part.content))
+                    elif isinstance(part, ToolCallPart):
+                        tool_calls.append(self._map_tool_call(part))
+                    else:
+                        assert_never(part)
+                mistral_messages.append(MistralAssistantMessage(content=content_chunks, tool_calls=tool_calls))
+            else:
+                assert_never(message)
+        if instructions := self._get_instructions(messages):
+            mistral_messages.insert(0, MistralSystemMessage(content=instructions))
+        return mistral_messages
 
-    @staticmethod
-    def _map_user_prompt(part: UserPromptPart) -> MistralUserMessage:
+    def _map_user_prompt(self, part: UserPromptPart) -> MistralUserMessage:
         content: str | list[MistralContentChunk]
         if isinstance(part.content, str):
             content = part.content
@@ -503,6 +505,8 @@ class MistralModel(Model):
                         raise RuntimeError('Only image binary content is supported for Mistral.')
                 elif isinstance(item, DocumentUrl):
                     raise RuntimeError('DocumentUrl is not supported in Mistral.')
+                elif isinstance(item, VideoUrl):
+                    raise RuntimeError('VideoUrl is not supported in Mistral.')
                 else:  # pragma: no cover
                     raise RuntimeError(f'Unsupported content type: {type(item)}')
         return MistralUserMessage(content=content)
@@ -518,7 +522,7 @@ class MistralStreamedResponse(StreamedResponse):
     _model_name: MistralModelName
     _response: AsyncIterable[MistralCompletionEvent]
     _timestamp: datetime
-    _result_tools: dict[str, ToolDefinition]
+    _output_tools: dict[str, ToolDefinition]
 
     _delta_content: str = field(default='', init=False)
 
@@ -536,13 +540,13 @@ class MistralStreamedResponse(StreamedResponse):
             content = choice.delta.content
             text = _map_content(content)
             if text:
-                # Attempt to produce a result tool call from the received text
-                if self._result_tools:
+                # Attempt to produce an output tool call from the received text
+                if self._output_tools:
                     self._delta_content += text
-                    maybe_tool_call_part = self._try_get_result_tool_from_text(self._delta_content, self._result_tools)
+                    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(
-                            vendor_part_id='result',
+                            vendor_part_id='output',
                             tool_name=maybe_tool_call_part.tool_name,
                             args=maybe_tool_call_part.args_as_dict(),
                             tool_call_id=maybe_tool_call_part.tool_call_id,
@@ -568,20 +572,20 @@ class MistralStreamedResponse(StreamedResponse):
         return self._timestamp
 
     @staticmethod
-    def _try_get_result_tool_from_text(text: str, result_tools: dict[str, ToolDefinition]) -> ToolCallPart | None:
+    def _try_get_output_tool_from_text(text: str, output_tools: dict[str, ToolDefinition]) -> ToolCallPart | None:
         output_json: dict[str, Any] | None = pydantic_core.from_json(text, allow_partial='trailing-strings')
         if output_json:
-            for result_tool in result_tools.values():
-                # NOTE: Additional verification to prevent JSON validation to crash in `_result.py`
+            for output_tool in output_tools.values():
+                # NOTE: Additional verification to prevent JSON validation to crash
                 # Ensures required parameters in the JSON schema are respected, especially for stream-based return types.
                 # Example with BaseModel and required fields.
                 if not MistralStreamedResponse._validate_required_json_schema(
-                    output_json, result_tool.parameters_json_schema
+                    output_json, output_tool.parameters_json_schema
                 ):
                     continue
 
                 # The following part_id will be thrown away
-                return ToolCallPart(tool_name=result_tool.name, args=output_json)
+                return ToolCallPart(tool_name=output_tool.name, args=output_json)
 
     @staticmethod
     def _validate_required_json_schema(json_dict: dict[str, Any], json_schema: dict[str, Any]) -> bool:
@@ -649,21 +653,21 @@ def _map_usage(response: MistralChatCompletionResponse | MistralCompletionChunk)
 
 def _map_content(content: MistralOptionalNullable[MistralContent]) -> str | None:
     """Maps the delta content from a Mistral Completion Chunk to a string or None."""
-    result: str | None = None
+    output: str | None = None
 
     if isinstance(content, MistralUnset) or not content:
-        result = None
+        output = None
     elif isinstance(content, list):
         for chunk in content:
             if isinstance(chunk, MistralTextChunk):
-                result = result or '' + chunk.text
+                output = output or '' + chunk.text
             else:
                 assert False, f'Other data types like (Image, Reference) are not yet supported,  got {type(chunk)}'
     elif isinstance(content, str):
-        result = content
+        output = content
 
     # Note: Check len to handle potential mismatch between function calls and responses from the API. (`msg: not the same number of function class and responses`)
-    if result and len(result) == 0:
-        result = None
+    if output and len(output) == 0:  # pragma: no cover
+        output = None
 
-    return result
+    return output

pydantic_ai/models/openai.py

@@ -30,6 +30,7 @@ from ..messages import (
     ToolCallPart,
     ToolReturnPart,
     UserPromptPart,
+    VideoUrl,
 )
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
@@ -41,6 +42,7 @@ 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
@@ -252,15 +254,12 @@ class OpenAIModel(Model):
         # 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:
+        elif not model_request_parameters.allow_text_output:
             tool_choice = 'required'
         else:
             tool_choice = 'auto'
 
-        openai_messages: list[chat.ChatCompletionMessageParam] = []
-        for m in messages:
-            async for msg in self._map_message(m):
-                openai_messages.append(msg)
+        openai_messages = await self._map_messages(messages)
 
         try:
             return await self.client.chat.completions.create(
@@ -317,35 +316,40 @@ class OpenAIModel(Model):
 
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[chat.ChatCompletionToolParam]:
         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]
+        if model_request_parameters.output_tools:
+            tools += [self._map_tool_definition(r) for r in model_request_parameters.output_tools]
         return tools
 
-    async def _map_message(self, message: ModelMessage) -> AsyncIterable[chat.ChatCompletionMessageParam]:
+    async def _map_messages(self, messages: list[ModelMessage]) -> list[chat.ChatCompletionMessageParam]:
         """Just maps a `pydantic_ai.Message` to a `openai.types.ChatCompletionMessageParam`."""
-        if isinstance(message, ModelRequest):
-            async for item in self._map_user_message(message):
-                yield item
-        elif isinstance(message, ModelResponse):
-            texts: list[str] = []
-            tool_calls: list[chat.ChatCompletionMessageToolCallParam] = []
-            for item in message.parts:
-                if isinstance(item, TextPart):
-                    texts.append(item.content)
-                elif isinstance(item, ToolCallPart):
-                    tool_calls.append(self._map_tool_call(item))
-                else:
-                    assert_never(item)
-            message_param = chat.ChatCompletionAssistantMessageParam(role='assistant')
-            if texts:
-                # Note: model responses from this model should only have one text item, so the following
-                # shouldn't merge multiple texts into one unless you switch models between runs:
-                message_param['content'] = '\n\n'.join(texts)
-            if tool_calls:
-                message_param['tool_calls'] = tool_calls
-            yield message_param
-        else:
-            assert_never(message)
+        openai_messages: list[chat.ChatCompletionMessageParam] = []
+        for message in messages:
+            if isinstance(message, ModelRequest):
+                async for item in self._map_user_message(message):
+                    openai_messages.append(item)
+            elif isinstance(message, ModelResponse):
+                texts: list[str] = []
+                tool_calls: list[chat.ChatCompletionMessageToolCallParam] = []
+                for item in message.parts:
+                    if isinstance(item, TextPart):
+                        texts.append(item.content)
+                    elif isinstance(item, ToolCallPart):
+                        tool_calls.append(self._map_tool_call(item))
+                    else:
+                        assert_never(item)
+                message_param = chat.ChatCompletionAssistantMessageParam(role='assistant')
+                if texts:
+                    # Note: model responses from this model should only have one text item, so the following
+                    # shouldn't merge multiple texts into one unless you switch models between runs:
+                    message_param['content'] = '\n\n'.join(texts)
+                if tool_calls:
+                    message_param['tool_calls'] = tool_calls
+                openai_messages.append(message_param)
+            else:
+                assert_never(message)
+        if instructions := self._get_instructions(messages):
+            openai_messages.insert(0, chat.ChatCompletionSystemMessageParam(content=instructions, role='system'))
+        return openai_messages
 
     @staticmethod
     def _map_tool_call(t: ToolCallPart) -> chat.ChatCompletionMessageToolCallParam:
@@ -448,6 +452,8 @@ class OpenAIModel(Model):
                     # file_data = f'data:{media_type};base64,{base64_encoded}'
                     # file = File(file={'file_data': file_data, 'file_name': item.url, 'file_id': item.url}, type='file')
                     # content.append(file)
+                elif isinstance(item, VideoUrl):  # pragma: no cover
+                    raise NotImplementedError('VideoUrl is not supported for OpenAI')
                 else:
                     assert_never(item)
         return chat.ChatCompletionUserMessageParam(role='user', content=content)
@@ -591,19 +597,19 @@ class OpenAIResponsesModel(Model):
         # 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:
+        elif not model_request_parameters.allow_text_output:
             tool_choice = 'required'
         else:
             tool_choice = 'auto'
 
-        system_prompt, openai_messages = await self._map_message(messages)
+        instructions, openai_messages = await self._map_messages(messages)
         reasoning = self._get_reasoning(model_settings)
 
         try:
             return await self.client.responses.create(
                 input=openai_messages,
                 model=self._model_name,
-                instructions=system_prompt,
+                instructions=instructions,
                 parallel_tool_calls=model_settings.get('parallel_tool_calls', NOT_GIVEN),
                 tools=tools or NOT_GIVEN,
                 tool_choice=tool_choice or NOT_GIVEN,
@@ -632,8 +638,8 @@ class OpenAIResponsesModel(Model):
 
     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]
+        if model_request_parameters.output_tools:
+            tools += [self._map_tool_definition(r) for r in model_request_parameters.output_tools]
         return tools
 
     @staticmethod
@@ -647,15 +653,16 @@ class OpenAIResponsesModel(Model):
             'strict': f.strict or False,
         }
 
-    async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[responses.ResponseInputItemParam]]:
+    async def _map_messages(
+        self, messages: list[ModelMessage]
+    ) -> tuple[str | NotGiven, 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
+                        openai_messages.append(responses.EasyInputMessageParam(role='system', content=part.content))
                     elif isinstance(part, UserPromptPart):
                         openai_messages.append(await self._map_user_prompt(part))
                     elif isinstance(part, ToolReturnPart):
@@ -692,7 +699,8 @@ class OpenAIResponsesModel(Model):
                         assert_never(item)
             else:
                 assert_never(message)
-        return system_prompt, openai_messages
+        instructions = self._get_instructions(messages) or NOT_GIVEN
+        return instructions, openai_messages
 
     @staticmethod
     def _map_tool_call(t: ToolCallPart) -> responses.ResponseFunctionToolCallParam:
@@ -765,6 +773,8 @@ class OpenAIResponsesModel(Model):
                             filename=f'filename.{item.format}',
                         )
                     )
+                elif isinstance(item, VideoUrl):  # pragma: no cover
+                    raise NotImplementedError('VideoUrl is not supported for OpenAI.')
                 else:
                     assert_never(item)
         return responses.EasyInputMessageParam(role='user', content=content)
@@ -922,137 +932,79 @@ def _map_usage(response: chat.ChatCompletion | ChatCompletionChunk | responses.R
         )
 
 
-class _StrictSchemaHelper:
-    def make_schema_strict(self, schema: dict[str, Any]) -> dict[str, Any]:
-        """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
-        """
-        assert isinstance(schema, dict), 'Schema must be a dictionary, this is probably a bug'
+@dataclass
+class _OpenAIJsonSchema(WalkJsonSchema):
+    """Recursively handle the schema to make it compatible with OpenAI strict mode.
 
-        # Create a copy to avoid modifying the original schema
-        schema = schema.copy()
+    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
+    """
 
-        # Handle $defs
-        if defs := schema.get('$defs'):
-            schema['$defs'] = {k: self.make_schema_strict(v) for k, v in defs.items()}
+    def __init__(self, schema: JsonSchema, strict: bool | None):
+        super().__init__(schema)
+        self.strict = strict
+        self.is_strict_compatible = True
+
+    def transform(self, schema: JsonSchema) -> JsonSchema:
+        # Remove unnecessary keys
+        schema.pop('title', None)
+        schema.pop('default', None)
+        schema.pop('$schema', None)
+        schema.pop('discriminator', None)
+
+        # Remove incompatible keys, but note their impact in the description provided to the LLM
+        description = schema.get('description')
+        min_length = schema.pop('minLength', None)
+        max_length = schema.pop('minLength', None)
+        if description is not None:
+            notes = list[str]()
+            if min_length is not None:  # pragma: no cover
+                notes.append(f'min_length={min_length}')
+            if max_length is not None:  # pragma: no cover
+                notes.append(f'max_length={max_length}')
+            if notes:  # pragma: no cover
+                schema['description'] = f'{description} ({", ".join(notes)})'
 
-        # Process schema based on its type
         schema_type = schema.get('type')
         if schema_type == 'object':
-            # Handle object type by setting additionalProperties to false
-            # and adding all properties to required list
-            self._make_object_schema_strict(schema)
-        elif schema_type == 'array':
-            # Handle array types by processing their items
-            if 'items' in schema:
-                items: Any = schema['items']
-                schema['items'] = self.make_schema_strict(items)
-            if 'prefixItems' in schema:
-                prefix_items: list[Any] = schema['prefixItems']
-                schema['prefixItems'] = [self.make_schema_strict(item) for item in prefix_items]
-
-        elif schema_type in {'string', 'number', 'integer', 'boolean', 'null'}:
-            pass  # Primitive types need no special handling
-        elif 'oneOf' in schema:
-            schema['oneOf'] = [self.make_schema_strict(item) for item in schema['oneOf']]
-        elif 'anyOf' in schema:
-            schema['anyOf'] = [self.make_schema_strict(item) for item in schema['anyOf']]
-
+            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 _make_object_schema_strict(self, schema: dict[str, Any]) -> None:
-        schema['additionalProperties'] = False
-
-        # Handle patternProperties; note this may not be compatible with strict mode but is included for completeness
-        if 'patternProperties' in schema and isinstance(schema['patternProperties'], dict):
-            pattern_props: dict[str, Any] = schema['patternProperties']
-            schema['patternProperties'] = {str(k): self.make_schema_strict(v) for k, v in pattern_props.items()}
-
-        # Handle properties — update their schemas recursively, and make all properties required
-        if 'properties' in schema and isinstance(schema['properties'], dict):
-            properties: dict[str, Any] = schema['properties']
-            schema['properties'] = {k: self.make_schema_strict(v) for k, v in properties.items()}
-            schema['required'] = list(properties.keys())
-
-    def is_schema_strict(self, schema: dict[str, Any]) -> bool:
-        """Check if the schema is strict-mode-compatible.
-
-        A schema is compatible if:
-        * `additionalProperties` is set to false for each object in the parameters
-        * all fields in properties are marked as required
-
-        See https://platform.openai.com/docs/guides/function-calling?api-mode=responses#strict-mode for more details.
-        """
-        assert isinstance(schema, dict), 'Schema must be a dictionary, this is probably a bug'
-
-        # Note that checking the defs first is usually the fastest way to proceed, but
-        # it makes it hard/impossible to hit coverage below, hence all the pragma no covers.
-        # I still included the handling below because I'm not _confident_ those code paths can't be hit.
-        if defs := schema.get('$defs'):
-            if not all(self.is_schema_strict(v) for v in defs.values()):  # pragma: no branch
-                return False
-
-        schema_type = schema.get('type')
-        if schema_type == 'object':
-            if not self._is_object_schema_strict(schema):
-                return False
-        elif schema_type == 'array':
-            if 'items' in schema:
-                items: Any = schema['items']
-                if not self.is_schema_strict(items):  # pragma: no cover
-                    return False
-            if 'prefixItems' in schema:
-                prefix_items: list[Any] = schema['prefixItems']
-                if not all(self.is_schema_strict(item) for item in prefix_items):  # pragma: no cover
-                    return False
-        elif schema_type in {'string', 'number', 'integer', 'boolean', 'null'}:
-            pass
-        elif 'oneOf' in schema:  # pragma: no cover
-            if not all(self.is_schema_strict(item) for item in schema['oneOf']):
-                return False
-
-        elif 'anyOf' in schema:  # pragma: no cover
-            if not all(self.is_schema_strict(item) for item in schema['anyOf']):
-                return False
-
-        return True
-
-    def _is_object_schema_strict(self, schema: dict[str, Any]) -> bool:
-        """Check if the schema is an object and has additionalProperties set to false."""
-        if schema.get('additionalProperties') is not False:
-            return False
-        if 'properties' not in schema:  # pragma: no cover
-            return False
-        if 'required' not in schema:  # pragma: no cover
-            return False
-
-        for k, v in schema['properties'].items():
-            if k not in schema['required']:
-                return False
-            if not self.is_schema_strict(v):  # pragma: no cover
-                return False
-
-        return True
-
 
 def _customize_request_parameters(model_request_parameters: ModelRequestParameters) -> ModelRequestParameters:
     """Customize the request parameters for OpenAI models."""
 
     def _customize_tool_def(t: ToolDefinition):
-        if t.strict is True:
-            parameters_json_schema = _StrictSchemaHelper().make_schema_strict(t.parameters_json_schema)
-            return replace(t, parameters_json_schema=parameters_json_schema)
-        elif t.strict is None:
-            strict = _StrictSchemaHelper().is_schema_strict(t.parameters_json_schema)
-            return replace(t, strict=strict)
-        return t
+        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_result=model_request_parameters.allow_text_result,
-        result_tools=[_customize_tool_def(tool) for tool in model_request_parameters.result_tools],
+        allow_text_output=model_request_parameters.allow_text_output,
+        output_tools=[_customize_tool_def(tool) for tool in model_request_parameters.output_tools],
     )