Add generate_summary and truncation to OpenAIResponsesModelSettings (#1328)

Author: Kludex

pydantic_ai_slim/pydantic_ai/models/openai.py

@@ -8,8 +8,6 @@
 from datetime import datetime, timezone
 from typing import Literal, Union, cast, overload
 
-from openai import NotGiven
-from openai.types import Reasoning
 from typing_extensions import assert_never
 
 from pydantic_ai.providers import Provider, infer_provider
@@ -44,7 +42,7 @@
 )
 
 try:
-    from openai import NOT_GIVEN, APIStatusError, AsyncOpenAI, AsyncStream
+    from openai import NOT_GIVEN, APIStatusError, AsyncOpenAI, AsyncStream, NotGiven
     from openai.types import ChatModel, chat, responses
     from openai.types.chat import (
         ChatCompletionChunk,
@@ -95,8 +93,7 @@ class OpenAIModelSettings(ModelSettings, total=False):
     """
 
     openai_reasoning_effort: ReasoningEffort
-    """
-    Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning).
+    """Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning).
 
     Currently supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
     result in faster responses and fewer tokens used on reasoning in a response.
@@ -121,6 +118,27 @@ class OpenAIResponsesModelSettings(OpenAIModelSettings, total=False):
     See [OpenAI's built-in tools](https://platform.openai.com/docs/guides/tools?api-mode=responses) for more details.
     """
 
+    openai_reasoning_generate_summary: Literal['detailed', 'concise']
+    """A summary of the reasoning performed by the model.
+
+    This can be useful for debugging and understanding the model's reasoning process.
+    One of `concise` or `detailed`.
+
+    Check the [OpenAI Computer use documentation](https://platform.openai.com/docs/guides/tools-computer-use#1-send-a-request-to-the-model)
+    for more details.
+    """
+
+    openai_truncation: Literal['disabled', 'auto']
+    """The truncation strategy to use for the model response.
+
+    It can be either:
+    - `disabled` (default): If a model response will exceed the context window size for a model, the
+        request will fail with a 400 error.
+    - `auto`: If the context of this response and previous ones exceeds the model's context window size,
+        the model will truncate the response to fit the context window by dropping input items in the
+        middle of the conversation.
+    """
+
 
 @dataclass(init=False)
 class OpenAIModel(Model):
@@ -567,12 +585,7 @@ async def _responses_create(
             tool_choice = 'auto'
 
         system_prompt, openai_messages = await self._map_message(messages)
-
-        reasoning_effort = model_settings.get('openai_reasoning_effort', NOT_GIVEN)
-        if not isinstance(reasoning_effort, NotGiven):
-            reasoning = Reasoning(effort=reasoning_effort)
-        else:
-            reasoning = NOT_GIVEN
+        reasoning = self._get_reasoning(model_settings)
 
         try:
             return await self.client.responses.create(
@@ -586,6 +599,7 @@ async def _responses_create(
                 stream=stream,
                 temperature=model_settings.get('temperature', NOT_GIVEN),
                 top_p=model_settings.get('top_p', NOT_GIVEN),
+                truncation=model_settings.get('openai_truncation', NOT_GIVEN),
                 timeout=model_settings.get('timeout', NOT_GIVEN),
                 reasoning=reasoning,
                 user=model_settings.get('user', NOT_GIVEN),
@@ -595,6 +609,14 @@ async def _responses_create(
                 raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=e.body) from e
             raise
 
+    def _get_reasoning(self, model_settings: OpenAIResponsesModelSettings) -> Reasoning | NotGiven:
+        reasoning_effort = model_settings.get('openai_reasoning_effort', None)
+        reasoning_generate_summary = model_settings.get('openai_reasoning_generate_summary', None)
+
+        if reasoning_effort is None and reasoning_generate_summary is None:
+            return NOT_GIVEN
+        return Reasoning(effort=reasoning_effort, generate_summary=reasoning_generate_summary)
+
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[responses.FunctionToolParam]:
         tools = [self._map_tool_definition(r) for r in model_request_parameters.function_tools]
         if model_request_parameters.result_tools:

tests/models/cassettes/test_openai_responses/test_openai_responses_reasoning_generate_summary.yaml

@@ -0,0 +1,105 @@
+interactions:
+- request:
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '218'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+    method: POST
+    parsed_body:
+      input:
+      - content: What should I do to cross the street?
+        role: user
+      instructions: ''
+      model: computer-use-preview
+      reasoning:
+        effort: null
+        generate_summary: concise
+      stream: false
+      truncation: auto
+    uri: https://api.openai.com/v1/responses
+  response:
+    headers:
+      alt-svc:
+      - h3=":443"; ma=86400
+      connection:
+      - keep-alive
+      content-length:
+      - '1976'
+      content-type:
+      - application/json
+      openai-organization:
+      - pydantic-28gund
+      openai-processing-ms:
+      - '2793'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      transfer-encoding:
+      - chunked
+    parsed_body:
+      created_at: 1743514924
+      error: null
+      id: resp_67ebed2c92cc81919d2fe37992a6a78b0e0766e7260ad9b9
+      incomplete_details: null
+      instructions: ''
+      max_output_tokens: null
+      metadata: {}
+      model: computer-use-preview-2025-03-11
+      object: response
+      output:
+      - content:
+        - annotations: []
+          text: |-
+            To cross the street safely, follow these steps:
+
+            1. **Use a Crosswalk**: Always use a designated crosswalk or pedestrian crossing whenever available.
+            2. **Press the Button**: If there is a pedestrian signal button, press it and wait for the signal.
+            3. **Look Both Ways**: Look left, right, and left again before stepping off the curb.
+            4. **Wait for the Signal**: Cross only when the pedestrian signal indicates it is safe to do so or when there is a clear gap in traffic.
+            5. **Stay Alert**: Be mindful of turning vehicles and stay attentive while crossing.
+            6. **Walk, Don't Run**: Walk across the street; running can increase the risk of falling or not noticing an oncoming vehicle.
+
+            Always follow local traffic rules and be cautious, even when crossing at a crosswalk. Safety is the priority.
+          type: output_text
+        id: msg_67ebed2db814819195e77f3dd1f057640e0766e7260ad9b9
+        role: assistant
+        status: completed
+        type: message
+      parallel_tool_calls: true
+      previous_response_id: null
+      reasoning:
+        effort: medium
+        generate_summary: concise
+      status: completed
+      store: true
+      temperature: 1.0
+      text:
+        format:
+          type: text
+      tool_choice: auto
+      tools: []
+      top_p: 1.0
+      truncation: auto
+      usage:
+        input_tokens: 15
+        input_tokens_details:
+          cached_tokens: 0
+        output_tokens: 180
+        output_tokens_details:
+          reasoning_tokens: 0
+        total_tokens: 195
+      user: null
+    status:
+      code: 200
+      message: OK
+version: 1

tests/models/test_openai_responses.py

@@ -118,6 +118,30 @@ async def test_openai_responses_reasoning_effort(allow_model_requests: None, ope
     )
 
 
+async def test_openai_responses_reasoning_generate_summary(allow_model_requests: None, openai_api_key: str):
+    model = OpenAIResponsesModel('computer-use-preview', provider=OpenAIProvider(api_key=openai_api_key))
+    agent = Agent(
+        model=model,
+        model_settings=OpenAIResponsesModelSettings(
+            openai_reasoning_generate_summary='concise',
+            openai_truncation='auto',
+        ),
+    )
+    result = await agent.run('What should I do to cross the street?')
+    assert result.data == snapshot("""\
+To cross the street safely, follow these steps:
+
+1. **Use a Crosswalk**: Always use a designated crosswalk or pedestrian crossing whenever available.
+2. **Press the Button**: If there is a pedestrian signal button, press it and wait for the signal.
+3. **Look Both Ways**: Look left, right, and left again before stepping off the curb.
+4. **Wait for the Signal**: Cross only when the pedestrian signal indicates it is safe to do so or when there is a clear gap in traffic.
+5. **Stay Alert**: Be mindful of turning vehicles and stay attentive while crossing.
+6. **Walk, Don't Run**: Walk across the street; running can increase the risk of falling or not noticing an oncoming vehicle.
+
+Always follow local traffic rules and be cautious, even when crossing at a crosswalk. Safety is the priority.\
+""")
+
+
 async def test_openai_responses_system_prompt(allow_model_requests: None, openai_api_key: str):
     model = OpenAIResponsesModel('gpt-4o', provider=OpenAIProvider(api_key=openai_api_key))
     agent = Agent(model=model, system_prompt='You are a helpful assistant.')