pydantic-ai-slim 0.0.48__tar.gz → 0.0.50__tar.gz

{pydantic_ai_slim-0.0.48 → pydantic_ai_slim-0.0.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.48
+Version: 0.0.50
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -29,7 +29,7 @@ Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.0.48
+Requires-Dist: pydantic-graph==0.0.50
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: anthropic
@@ -45,7 +45,7 @@ Requires-Dist: cohere>=5.13.11; (platform_system != 'Emscripten') and extra == '
 Provides-Extra: duckduckgo
 Requires-Dist: duckduckgo-search>=7.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.0.48; extra == 'evals'
+Requires-Dist: pydantic-evals==0.0.50; extra == 'evals'
 Provides-Extra: groq
 Requires-Dist: groq>=0.15.0; extra == 'groq'
 Provides-Extra: logfire

{pydantic_ai_slim-0.0.48 → pydantic_ai_slim-0.0.50}/pydantic_ai/_cli.py

@@ -3,19 +3,20 @@ from __future__ import annotations as _annotations
 import argparse
 import asyncio
 import sys
+from asyncio import CancelledError
 from collections.abc import Sequence
 from contextlib import ExitStack
 from datetime import datetime, timezone
 from importlib.metadata import version
 from pathlib import Path
-from typing import cast
+from typing import Any, cast
 
 from typing_inspection.introspection import get_literal_values
 
 from pydantic_ai.agent import Agent
 from pydantic_ai.exceptions import UserError
 from pydantic_ai.messages import ModelMessage, PartDeltaEvent, TextPartDelta
-from pydantic_ai.models import KnownModelName
+from pydantic_ai.models import KnownModelName, infer_model
 
 try:
     import argcomplete
@@ -47,7 +48,7 @@ class SimpleCodeBlock(CodeBlock):
     This avoids a background color which messes up copy-pasting and sets the language name as dim prefix and suffix.
     """
 
-    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:  # pragma: no cover
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         code = str(self.text).rstrip()
         yield Text(self.lexer_name, style='dim')
         yield Syntax(code, self.lexer_name, theme=self.theme, background_color='default', word_wrap=True)
@@ -57,7 +58,7 @@ class SimpleCodeBlock(CodeBlock):
 class LeftHeading(Heading):
     """Customised headings in markdown to stop centering and prepend markdown style hashes."""
 
-    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:  # pragma: no cover
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         # note we use `Style(bold=True)` not `self.style_name` here to disable underlining which is ugly IMHO
         yield Text(f'{"#" * int(self.tag[1:])} {self.text.plain}', style=Style(bold=True))
 
@@ -68,7 +69,21 @@ Markdown.elements.update(
 )
 
 
-def cli(args_list: Sequence[str] | None = None) -> int:  # noqa: C901  # pragma: no cover
+cli_agent = Agent()
+
+
+@cli_agent.system_prompt
+def cli_system_prompt() -> str:
+    now_utc = datetime.now(timezone.utc)
+    tzinfo = now_utc.astimezone().tzinfo
+    tzname = tzinfo.tzname(now_utc) if tzinfo else ''
+    return f"""\
+Help the user by responding to their request, the output should be concise and always written in markdown.
+The current date and time is {datetime.now()} {tzname}.
+The user is running {sys.platform}."""
+
+
+def cli(args_list: Sequence[str] | None = None) -> int:
     parser = argparse.ArgumentParser(
         prog='pai',
         description=f"""\
@@ -124,18 +139,10 @@ Special prompt:
             console.print(f'  {model}', highlight=False)
         return 0
 
-    now_utc = datetime.now(timezone.utc)
-    tzname = now_utc.astimezone().tzinfo.tzname(now_utc)  # type: ignore
     try:
-        agent = Agent(
-            model=args.model,
-            system_prompt=f"""\
-    Help the user by responding to their request, the output should be concise and always written in markdown.
-    The current date and time is {datetime.now()} {tzname}.
-    The user is running {sys.platform}.""",
-        )
-    except UserError:
-        console.print(f'[red]Invalid model "{args.model}"[/red]')
+        cli_agent.model = infer_model(args.model)
+    except UserError as e:
+        console.print(f'Error initializing [magenta]{args.model}[/magenta]:\n[red]{e}[/red]')
         return 1
 
     stream = not args.no_stream
@@ -148,67 +155,44 @@ Special prompt:
 
     if prompt := cast(str, args.prompt):
         try:
-            asyncio.run(ask_agent(agent, prompt, stream, console, code_theme))
+            asyncio.run(ask_agent(cli_agent, prompt, stream, console, code_theme))
         except KeyboardInterrupt:
             pass
         return 0
 
     history = Path.home() / '.pai-prompt-history.txt'
-    session = PromptSession(history=FileHistory(str(history)))  # type: ignore
+    # doing this instead of `PromptSession[Any](history=` allows mocking of PromptSession in tests
+    session: PromptSession[Any] = PromptSession(history=FileHistory(str(history)))
+    try:
+        return asyncio.run(run_chat(session, stream, cli_agent, console, code_theme))
+    except KeyboardInterrupt:  # pragma: no cover
+        return 0
+
+
+async def run_chat(session: PromptSession[Any], stream: bool, agent: Agent, console: Console, code_theme: str) -> int:
     multiline = False
     messages: list[ModelMessage] = []
 
     while True:
         try:
             auto_suggest = CustomAutoSuggest(['/markdown', '/multiline', '/exit'])
-            text = cast(str, session.prompt('pai ➤ ', auto_suggest=auto_suggest, multiline=multiline))
-        except (KeyboardInterrupt, EOFError):
+            text = await session.prompt_async('pai ➤ ', auto_suggest=auto_suggest, multiline=multiline)
+        except (KeyboardInterrupt, EOFError):  # pragma: no cover
             return 0
 
         if not text.strip():
             continue
 
-        ident_prompt = text.lower().strip(' ').replace(' ', '-').lstrip(' ')
+        ident_prompt = text.lower().strip().replace(' ', '-')
         if ident_prompt.startswith('/'):
-            if ident_prompt == '/markdown':
-                try:
-                    parts = messages[-1].parts
-                except IndexError:
-                    console.print('[dim]No markdown output available.[/dim]')
-                    continue
-                console.print('[dim]Markdown output of last question:[/dim]\n')
-                for part in parts:
-                    if part.part_kind == 'text':
-                        console.print(
-                            Syntax(
-                                part.content,
-                                lexer='markdown',
-                                theme=code_theme,
-                                word_wrap=True,
-                                background_color='default',
-                            )
-                        )
-
-            elif ident_prompt == '/multiline':
-                multiline = not multiline
-                if multiline:
-                    console.print(
-                        'Enabling multiline mode. '
-                        '[dim]Press [Meta+Enter] or [Esc] followed by [Enter] to accept input.[/dim]'
-                    )
-                else:
-                    console.print('Disabling multiline mode.')
-            elif ident_prompt == '/exit':
-                console.print('[dim]Exiting…[/dim]')
-                return 0
-            else:
-                console.print(f'[red]Unknown command[/red] [magenta]`{ident_prompt}`[/magenta]')
+            exit_value, multiline = handle_slash_command(ident_prompt, messages, multiline, console, code_theme)
+            if exit_value is not None:
+                return exit_value
         else:
             try:
-                messages = asyncio.run(ask_agent(agent, text, stream, console, code_theme, messages))
-            except KeyboardInterrupt:
+                messages = await ask_agent(agent, text, stream, console, code_theme, messages)
+            except CancelledError:  # pragma: no cover
                 console.print('[dim]Interrupted[/dim]')
-                messages = []
 
 
 async def ask_agent(
@@ -218,7 +202,7 @@ async def ask_agent(
     console: Console,
     code_theme: str,
     messages: list[ModelMessage] | None = None,
-) -> list[ModelMessage]:  # pragma: no cover
+) -> list[ModelMessage]:
     status = Status('[dim]Working on it…[/dim]', console=console)
 
     if not stream:
@@ -248,7 +232,7 @@ async def ask_agent(
 
 
 class CustomAutoSuggest(AutoSuggestFromHistory):
-    def __init__(self, special_suggestions: list[str] | None = None):  # pragma: no cover
+    def __init__(self, special_suggestions: list[str] | None = None):
         super().__init__()
         self.special_suggestions = special_suggestions or []
 
@@ -264,5 +248,44 @@ class CustomAutoSuggest(AutoSuggestFromHistory):
         return suggestion
 
 
+def handle_slash_command(
+    ident_prompt: str, messages: list[ModelMessage], multiline: bool, console: Console, code_theme: str
+) -> tuple[int | None, bool]:
+    if ident_prompt == '/markdown':
+        try:
+            parts = messages[-1].parts
+        except IndexError:
+            console.print('[dim]No markdown output available.[/dim]')
+        else:
+            console.print('[dim]Markdown output of last question:[/dim]\n')
+            for part in parts:
+                if part.part_kind == 'text':
+                    console.print(
+                        Syntax(
+                            part.content,
+                            lexer='markdown',
+                            theme=code_theme,
+                            word_wrap=True,
+                            background_color='default',
+                        )
+                    )
+
+    elif ident_prompt == '/multiline':
+        multiline = not multiline
+        if multiline:
+            console.print(
+                'Enabling multiline mode. [dim]Press [Meta+Enter] or [Esc] followed by [Enter] to accept input.[/dim]'
+            )
+        else:
+            console.print('Disabling multiline mode.')
+        return None, multiline
+    elif ident_prompt == '/exit':
+        console.print('[dim]Exiting…[/dim]')
+        return 0, multiline
+    else:
+        console.print(f'[red]Unknown command[/red] [magenta]`{ident_prompt}`[/magenta]')
+    return None, multiline
+
+
 def app():  # pragma: no cover
     sys.exit(cli())

{pydantic_ai_slim-0.0.48 → pydantic_ai_slim-0.0.50}/pydantic_ai/models/__init__.py

@@ -106,6 +106,7 @@ KnownModelName = TypeAliasType(
         'google-gla:gemini-2.0-flash',
         'google-gla:gemini-2.0-flash-lite-preview-02-05',
         'google-gla:gemini-2.0-pro-exp-02-05',
+        'google-gla:gemini-2.5-pro-exp-03-25',
         'google-vertex:gemini-1.0-pro',
         'google-vertex:gemini-1.5-flash',
         'google-vertex:gemini-1.5-flash-8b',
@@ -116,6 +117,7 @@ KnownModelName = TypeAliasType(
         'google-vertex:gemini-2.0-flash',
         'google-vertex:gemini-2.0-flash-lite-preview-02-05',
         'google-vertex:gemini-2.0-pro-exp-02-05',
+        'google-vertex:gemini-2.5-pro-exp-03-25',
         'gpt-3.5-turbo',
         'gpt-3.5-turbo-0125',
         'gpt-3.5-turbo-0301',

{pydantic_ai_slim-0.0.48 → pydantic_ai_slim-0.0.50}/pydantic_ai/models/anthropic.py

@@ -1,6 +1,5 @@
 from __future__ import annotations as _annotations
 
-import base64
 import io
 from collections.abc import AsyncGenerator, AsyncIterable, AsyncIterator
 from contextlib import asynccontextmanager
@@ -9,7 +8,6 @@ from datetime import datetime, timezone
 from json import JSONDecodeError, loads as json_loads
 from typing import Any, Literal, Union, cast, overload
 
-from anthropic.types import DocumentBlockParam
 from typing_extensions import assert_never
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
@@ -40,6 +38,7 @@ try:
     from anthropic.types import (
         Base64PDFSourceParam,
         ContentBlock,
+        DocumentBlockParam,
         ImageBlockParam,
         Message as AnthropicMessage,
         MessageParam,
@@ -354,48 +353,13 @@ class AnthropicModel(Model):
                     else:
                         raise RuntimeError('Only images and PDFs are supported for binary content')
                 elif isinstance(item, ImageUrl):
-                    try:
-                        response = await cached_async_http_client().get(item.url)
-                        response.raise_for_status()
-                        yield ImageBlockParam(
-                            source={
-                                'data': io.BytesIO(response.content),
-                                'media_type': item.media_type,
-                                'type': 'base64',
-                            },
-                            type='image',
-                        )
-                    except ValueError:
-                        # Download the file if can't find the mime type.
-                        client = cached_async_http_client()
-                        response = await client.get(item.url, follow_redirects=True)
-                        response.raise_for_status()
-                        base64_encoded = base64.b64encode(response.content).decode('utf-8')
-                        if (mime_type := response.headers['Content-Type']) in (
-                            'image/jpeg',
-                            'image/png',
-                            'image/gif',
-                            'image/webp',
-                        ):
-                            yield ImageBlockParam(
-                                source={'data': base64_encoded, 'media_type': mime_type, 'type': 'base64'},
-                                type='image',
-                            )
-                        else:  # pragma: no cover
-                            raise RuntimeError(f'Unsupported image type: {mime_type}')
+                    yield ImageBlockParam(source={'type': 'url', 'url': item.url}, type='image')
                 elif isinstance(item, DocumentUrl):
-                    response = await cached_async_http_client().get(item.url)
-                    response.raise_for_status()
                     if item.media_type == 'application/pdf':
-                        yield DocumentBlockParam(
-                            source=Base64PDFSourceParam(
-                                data=io.BytesIO(response.content),
-                                media_type=item.media_type,
-                                type='base64',
-                            ),
-                            type='document',
-                        )
+                        yield DocumentBlockParam(source={'url': item.url, 'type': 'url'}, type='document')
                     elif item.media_type == 'text/plain':
+                        response = await cached_async_http_client().get(item.url)
+                        response.raise_for_status()
                         yield DocumentBlockParam(
                             source=PlainTextSourceParam(data=response.text, media_type=item.media_type, type='text'),
                             type='document',

{pydantic_ai_slim-0.0.48 → pydantic_ai_slim-0.0.50}/pydantic_ai/models/cohere.py

@@ -5,7 +5,6 @@ from dataclasses import dataclass, field
 from itertools import chain
 from typing import Literal, Union, cast
 
-from cohere import TextAssistantMessageContentItem
 from typing_extensions import assert_never
 
 from .. import ModelHTTPError, result
@@ -38,6 +37,7 @@ try:
         ChatMessageV2,
         ChatResponse,
         SystemChatMessageV2,
+        TextAssistantMessageContentItem,
         ToolCallV2,
         ToolCallV2Function,
         ToolChatMessageV2,

{pydantic_ai_slim-0.0.48 → pydantic_ai_slim-0.0.50}/pydantic_ai/models/gemini.py

@@ -57,6 +57,7 @@ LatestGeminiModelNames = Literal[
     'gemini-2.0-flash',
     'gemini-2.0-flash-lite-preview-02-05',
     'gemini-2.0-pro-exp-02-05',
+    'gemini-2.5-pro-exp-03-25',
 ]
 """Latest Gemini models."""
 
@@ -134,7 +135,8 @@ class GeminiModel(Model):
         async with self._make_request(
             messages, False, cast(GeminiModelSettings, model_settings or {}), model_request_parameters
         ) as http_response:
-            response = _gemini_response_ta.validate_json(await http_response.aread())
+            data = await http_response.aread()
+            response = _gemini_response_ta.validate_json(data)
         return self._process_response(response), _metadata_as_usage(response)
 
     @asynccontextmanager
@@ -639,10 +641,7 @@ class _GeminiFunction(TypedDict):
 
 def _function_from_abstract_tool(tool: ToolDefinition) -> _GeminiFunction:
     json_schema = _GeminiJsonSchema(tool.parameters_json_schema).simplify()
-    f = _GeminiFunction(
-        name=tool.name,
-        description=tool.description,
-    )
+    f = _GeminiFunction(name=tool.name, description=tool.description)
     if json_schema.get('properties'):
         f['parameters'] = json_schema
     return f
@@ -769,6 +768,9 @@ class _GeminiJsonSchema:
     def _simplify(self, schema: dict[str, Any], refs_stack: tuple[str, ...]) -> None:
         schema.pop('title', None)
         schema.pop('default', None)
+        schema.pop('$schema', None)
+        schema.pop('exclusiveMaximum', None)
+        schema.pop('exclusiveMinimum', None)
         if ref := schema.pop('$ref', None):
             # noinspection PyTypeChecker
             key = re.sub(r'^#/\$defs/', '', ref)

{pydantic_ai_slim-0.0.48 → pydantic_ai_slim-0.0.50}/pydantic_ai/models/openai.py

@@ -2,14 +2,12 @@ from __future__ import annotations as _annotations
 
 import base64
 import warnings
-from collections.abc import AsyncIterable, AsyncIterator
+from collections.abc import AsyncIterable, AsyncIterator, Sequence
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 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 @@ from . import (
 )
 
 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,
@@ -55,6 +53,7 @@ try:
     )
     from openai.types.chat.chat_completion_content_part_image_param import ImageURL
     from openai.types.chat.chat_completion_content_part_input_audio_param import InputAudio
+    from openai.types.responses import ComputerToolParam, FileSearchToolParam, WebSearchToolParam
     from openai.types.responses.response_input_param import FunctionCallOutput, Message
     from openai.types.shared import ReasoningEffort
     from openai.types.shared_params import Reasoning
@@ -64,6 +63,14 @@ except ImportError as _import_error:
         'you can use the `openai` optional group — `pip install "pydantic-ai-slim[openai]"`'
     ) from _import_error
 
+__all__ = (
+    'OpenAIModel',
+    'OpenAIResponsesModel',
+    'OpenAIModelSettings',
+    'OpenAIResponsesModelSettings',
+    'OpenAIModelName',
+)
+
 OpenAIModelName = Union[str, ChatModel]
 """
 Possible OpenAI model names.
@@ -86,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.
@@ -100,6 +106,40 @@ class OpenAIModelSettings(ModelSettings, total=False):
     """
 
 
+class OpenAIResponsesModelSettings(OpenAIModelSettings, total=False):
+    """Settings used for an OpenAI Responses model request.
+
+    ALL FIELDS MUST BE `openai_` PREFIXED SO YOU CAN MERGE THEM WITH OTHER MODELS.
+    """
+
+    openai_builtin_tools: Sequence[FileSearchToolParam | WebSearchToolParam | ComputerToolParam]
+    """The provided OpenAI built-in tools to use.
+
+    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):
     """A model that uses the OpenAI API.
@@ -417,6 +457,8 @@ class OpenAIResponsesModel(Model):
     - [File search](https://platform.openai.com/docs/guides/tools-file-search)
     - [Computer use](https://platform.openai.com/docs/guides/tools-computer-use)
 
+    Use the `openai_builtin_tools` setting to add these tools to your model.
+
     If you are interested in the differences between the Responses API and the Chat Completions API,
     see the [OpenAI API docs](https://platform.openai.com/docs/guides/responses-vs-chat-completions).
     """
@@ -462,7 +504,7 @@ class OpenAIResponsesModel(Model):
     ) -> tuple[ModelResponse, usage.Usage]:
         check_allow_model_requests()
         response = await self._responses_create(
-            messages, False, cast(OpenAIModelSettings, model_settings or {}), model_request_parameters
+            messages, False, cast(OpenAIResponsesModelSettings, model_settings or {}), model_request_parameters
         )
         return self._process_response(response), _map_usage(response)
 
@@ -475,7 +517,7 @@ class OpenAIResponsesModel(Model):
     ) -> AsyncIterator[StreamedResponse]:
         check_allow_model_requests()
         response = await self._responses_create(
-            messages, True, cast(OpenAIModelSettings, model_settings or {}), model_request_parameters
+            messages, True, cast(OpenAIResponsesModelSettings, model_settings or {}), model_request_parameters
         )
         async with response:
             yield await self._process_streamed_response(response)
@@ -511,7 +553,7 @@ class OpenAIResponsesModel(Model):
         self,
         messages: list[ModelRequest | ModelResponse],
         stream: Literal[False],
-        model_settings: OpenAIModelSettings,
+        model_settings: OpenAIResponsesModelSettings,
         model_request_parameters: ModelRequestParameters,
     ) -> responses.Response: ...
 
@@ -520,7 +562,7 @@ class OpenAIResponsesModel(Model):
         self,
         messages: list[ModelRequest | ModelResponse],
         stream: Literal[True],
-        model_settings: OpenAIModelSettings,
+        model_settings: OpenAIResponsesModelSettings,
         model_request_parameters: ModelRequestParameters,
     ) -> AsyncStream[responses.ResponseStreamEvent]: ...
 
@@ -528,10 +570,11 @@ class OpenAIResponsesModel(Model):
         self,
         messages: list[ModelRequest | ModelResponse],
         stream: bool,
-        model_settings: OpenAIModelSettings,
+        model_settings: OpenAIResponsesModelSettings,
         model_request_parameters: ModelRequestParameters,
     ) -> responses.Response | AsyncStream[responses.ResponseStreamEvent]:
         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:
@@ -542,12 +585,7 @@ class OpenAIResponsesModel(Model):
             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(
@@ -561,6 +599,7 @@ class OpenAIResponsesModel(Model):
                 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),
@@ -570,6 +609,14 @@ class OpenAIResponsesModel(Model):
                 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:
@@ -848,7 +895,7 @@ def _map_usage(response: chat.ChatCompletion | ChatCompletionChunk | responses.R
             },
         )
     else:
-        details: dict[str, int] = {}
+        details = {}
         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: