Use OpenAI's Structured Outputs feature to prevent validation errors

.gitignore

@@ -13,3 +13,4 @@ env*/
 /pydantic_ai_examples/.chat_app_messages.sqlite
 .cache/
 .vscode/
+*.ipynb

pydantic_ai_slim/pydantic_ai/models/openai.py

@@ -42,6 +42,7 @@
     from openai.types import ChatModel, chat
     from openai.types.chat import ChatCompletionChunk
     from openai.types.chat.chat_completion_chunk import ChoiceDeltaToolCall
+    from openai.types.shared_params.response_format_json_schema import ResponseFormatJSONSchema
 except ImportError as _import_error:
     raise ImportError(
         'Please install `openai` to use the OpenAI model, '
@@ -111,14 +112,8 @@ async def agent_model(
     ) -> AgentModel:
         check_allow_model_requests()
         tools = [self._map_tool_definition(r) for r in function_tools]
-        if result_tools:
-            tools += [self._map_tool_definition(r) for r in result_tools]
-        return OpenAIAgentModel(
-            self.client,
-            self.model_name,
-            allow_text_result,
-            tools,
-        )
+        response_format = self._map_response_format(result_tools[0]) if result_tools else None
+        return OpenAIAgentModel(self.client, self.model_name, tools, response_format)
 
     def name(self) -> str:
         return f'openai:{self.model_name}'
@@ -134,15 +129,22 @@ def _map_tool_definition(f: ToolDefinition) -> chat.ChatCompletionToolParam:
             },
         }
 
+    @staticmethod
+    def _map_response_format(f: ToolDefinition) -> ResponseFormatJSONSchema:
+        return {
+            'type': 'json_schema',
+            'json_schema': {'name': f.name, 'description': f.description, 'schema': f.parameters_json_schema},
+        }
+
 
 @dataclass
 class OpenAIAgentModel(AgentModel):
     """Implementation of `AgentModel` for OpenAI models."""
 
     client: AsyncOpenAI
     model_name: OpenAIModelName
-    allow_text_result: bool
     tools: list[chat.ChatCompletionToolParam]
+    response_format: ResponseFormatJSONSchema | None
 
     async def request(
         self, messages: list[ModelMessage], model_settings: ModelSettings | None
@@ -174,20 +176,15 @@ async def _completions_create(
         self, messages: list[ModelMessage], stream: bool, model_settings: ModelSettings | None
     ) -> chat.ChatCompletion | AsyncStream[ChatCompletionChunk]:
         # standalone function to make it easier to override
-        if not self.tools:
-            tool_choice: Literal['none', 'required', 'auto'] | None = None
-        elif not self.allow_text_result:
-            tool_choice = 'required'
-        else:
-            tool_choice = 'auto'
-
+        tool_choice = 'auto' if self.tools else None
         openai_messages = list(chain(*(self._map_message(m) for m in messages)))
 
         model_settings = model_settings or {}
 
-        return await self.client.chat.completions.create(
+        response = await self.client.chat.completions.create(
             model=self.model_name,
             messages=openai_messages,
+            response_format=self.response_format or NOT_GIVEN,
             n=1,
             parallel_tool_calls=True if self.tools else NOT_GIVEN,
             tools=self.tools or NOT_GIVEN,
@@ -200,14 +197,19 @@ async def _completions_create(
             timeout=model_settings.get('timeout', NOT_GIVEN),
         )
 
-    @staticmethod
-    def _process_response(response: chat.ChatCompletion) -> ModelResponse:
+        return response
+
+    def _process_response(self, response: chat.ChatCompletion) -> ModelResponse:
         """Process a non-streamed response, and prepare a message to return."""
         timestamp = datetime.fromtimestamp(response.created, tz=timezone.utc)
         choice = response.choices[0]
         items: list[ModelResponsePart] = []
         if choice.message.content is not None:
-            items.append(TextPart(choice.message.content))
+            if self.response_format:
+                name = self.response_format['json_schema']['name']
+                items.append(ToolCallPart.from_raw_args(name, choice.message.content))
+            else:
+                items.append(TextPart(choice.message.content))
         if choice.message.tool_calls is not None:
             for c in choice.message.tool_calls:
                 items.append(ToolCallPart.from_raw_args(c.function.name, c.function.arguments, c.id))