From aaec8e23388989862f8e98975ddde99c1cf85d65 Mon Sep 17 00:00:00 2001 From: markstuart-oai <323302876+markstuart-oai@users.noreply.github.com> Date: Sat, 14 Nov 2026 16:36:03 +0000 Subject: [PATCH 01/11] Preserve Python provider replay, retry, and installed runtime behavior --- .../workflows/codex-python-pypy-qualify.yml | 123 ++++++++++ .../_agents_codex/_model_provider_metadata.py | 42 ++++ .../codex/src/_agents_codex/_trace_export.py | 44 ++-- packages/codex/src/_agents_codex/models.py | 229 +++++++++++++++--- .../codex/tests/test_native_anyllm_gemini.py | 88 +++++++ .../test_native_anyllm_reasoning_shapes.py | 105 ++++++++ .../test_native_borrowed_retry_takeover.py | 178 ++++++++++++++ .../tests/test_native_borrowed_tool_media.py | 158 ++++++++++++ .../test_native_chat_response_start_policy.py | 158 ++++++++++++ ..._native_litellm_default_header_omission.py | 138 +++++++++++ .../test_native_litellm_physical_transport.py | 80 ++++++ .../test_native_litellm_transport_scope.py | 79 ++++++ .../tests/test_native_openai_retry_advice.py | 23 +- 13 files changed, 1385 insertions(+), 60 deletions(-) create mode 100644 .github/workflows/codex-python-pypy-qualify.yml create mode 100644 packages/codex/tests/test_native_anyllm_gemini.py create mode 100644 packages/codex/tests/test_native_anyllm_reasoning_shapes.py create mode 100644 packages/codex/tests/test_native_borrowed_retry_takeover.py create mode 100644 packages/codex/tests/test_native_borrowed_tool_media.py create mode 100644 packages/codex/tests/test_native_chat_response_start_policy.py create mode 100644 packages/codex/tests/test_native_litellm_default_header_omission.py create mode 100644 packages/codex/tests/test_native_litellm_physical_transport.py create mode 100644 packages/codex/tests/test_native_litellm_transport_scope.py diff --git a/.github/workflows/codex-python-pypy-qualify.yml b/.github/workflows/codex-python-pypy-qualify.yml new file mode 100644 index 0000000000..cbbc330e0d --- /dev/null +++ b/.github/workflows/codex-python-pypy-qualify.yml @@ -0,0 +1,123 @@ +name: Qualify PyPy native wheel + +on: + push: + branches: [feat/codex-harness] + paths: [.github/workflows/codex-python-pypy-qualify.yml] + workflow_dispatch: + +permissions: + contents: read + +jobs: + pypy311-linux-x64: + if: >- + github.repository == 'openai/openai-agents-python' && + github.ref == 'refs/heads/feat/codex-harness' + runs-on: ubuntu-24.04 + timeout-minutes: 180 + defaults: + run: + shell: bash + env: + RUSTUP_TOOLCHAIN: 1.95.0 + MATURIN_PGO: 'false' + OPENAI_AGENTS_NATIVE_MANYLINUX: manylinux_2_39 + PYTHONDONTWRITEBYTECODE: '1' + CARGO_BUILD_JOBS: '3' + CARGO_INCREMENTAL: '0' + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + persist-credentials: false + ref: ${{ github.sha }} + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 + with: + python-version: pypy3.11-v8.0.1 + architecture: x64 + - uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 + with: + version: '0.13.4' + enable-cache: false + - uses: ./.github/actions/setup-native + - name: Pin the build and consumer interpreter + run: | + python -I - <<'PYTHON' + import os + import platform + import sys + from pathlib import Path + assert platform.python_implementation() == 'PyPy' + assert sys.version_info[:3] == (3, 11, 17) + assert sys.implementation.version[:3] == (8, 0, 1) + assert platform.machine() == 'x86_64' + with open(os.environ['GITHUB_ENV'], 'a', encoding='utf-8') as output: + output.write(f'PYPY_EXECUTABLE={Path(sys.executable).resolve()}\n') + PYTHON + - name: Install pinned native build dependencies + run: | + uv venv --python "$PYPY_EXECUTABLE" .venv + "$PYPY_EXECUTABLE" -I - <<'PYTHON' > "$RUNNER_TEMP/pypy-build-requirements.txt" + import tomllib + from pathlib import Path + packages = tomllib.loads(Path('uv.lock').read_text())['package'] + for name in ('maturin', 'hatchling'): + versions = {item['version'] for item in packages if item['name'] == name} + assert len(versions) == 1, (name, versions) + version, = versions + if name == 'maturin': + assert version == '1.16.0' + print(f'{name}=={version}') + print('patchelf==0.19.1') + PYTHON + uv pip install --python .venv/bin/python --requirement "$RUNNER_TEMP/pypy-build-requirements.txt" + printf '%s\n' "$GITHUB_WORKSPACE/.venv/bin" >> "$GITHUB_PATH" + - name: Build the release-profile SDK wheel + run: | + .venv/bin/python -I - <<'PYTHON' + import sys + assert sys.implementation.name == 'pypy' + assert sys.version_info[:3] == (3, 11, 17) + PYTHON + env -u OPENAI_AGENTS_NATIVE_WHEEL .venv/bin/python -m hatchling build --target wheel --directory dist + .venv/bin/python -I - <<'PYTHON' + import hashlib + import json + from pathlib import Path + wheel, = Path('dist').glob('openai_agents-*-pp311-pypy311_pp80-manylinux_2_39_x86_64.whl') + receipt = json.loads(wheel.with_name(wheel.name + '.pristine.json').read_text()) + assert receipt['native_build']['profile'] == 'release' + assert receipt['native_build']['pgo'] is False + with wheel.open('rb') as stream: + assert hashlib.file_digest(stream, 'sha256').hexdigest() == receipt['wheel_sha256'] + PYTHON + - name: Verify an isolated PyPy installation with the existing public fixture + run: | + consumer="$RUNNER_TEMP/pypy-wheel-consumer" + uv venv --python "$PYPY_EXECUTABLE" "$consumer" + # PyPy needs the source distribution for rpds-py. The consumer uses + # wheel metadata requirements and records its independently resolved dependencies. + uv pip install --python "$consumer/bin/python" dist/*.whl + mkdir -p qualification + uv pip freeze --python "$consumer/bin/python" > qualification/installed-requirements.txt + "$consumer/bin/python" -I - <<'PYTHON' + import sys + assert sys.implementation.name == 'pypy' + assert sys.version_info[:3] == (3, 11, 17) + PYTHON + cd "$RUNNER_TEMP" + env -u PYTHONPATH -u OPENAI_AGENTS_NATIVE_WHEEL -u OPENAI_API_KEY \ + -u ALL_PROXY -u HTTP_PROXY -u HTTPS_PROXY -u all_proxy -u http_proxy -u https_proxy \ + "$consumer/bin/python" -I "$GITHUB_WORKSPACE/packages/codex/scripts/verify_installed.py" \ + --output "$GITHUB_WORKSPACE/qualification/installed-pypy311.json" + - name: Retain separate qualification artifacts + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 + with: + name: qualification-PyPy311-Linux-X64 + path: | + dist/*.whl + dist/*.pristine.json + qualification/installed-pypy311.json + qualification/installed-requirements.txt + if-no-files-found: error + retention-days: 7 diff --git a/packages/codex/src/_agents_codex/_model_provider_metadata.py b/packages/codex/src/_agents_codex/_model_provider_metadata.py index db213f40a1..982edbd9eb 100644 --- a/packages/codex/src/_agents_codex/_model_provider_metadata.py +++ b/packages/codex/src/_agents_codex/_model_provider_metadata.py @@ -178,6 +178,48 @@ def _capture_frame(encoded: str, event: Any) -> str: del encoded, event, captured +def _anyllm_reasoning_text(value: Any, depth: int = 0) -> str: + text = part = parts = None + try: + if isinstance(value, str): + return value + if depth >= 32: + raise ValueError("AnyLLM reasoning exceeds the supported nesting depth") + if isinstance(value, dict): + for key in ("content", "text", "thinking"): + text = _anyllm_reasoning_text(value.get(key), depth + 1) + if text: + return text + if isinstance(value, (list, tuple)): + parts = [] + for part in value: + parts.append(_anyllm_reasoning_text(part, depth + 1)) + return "".join(parts) + return "" + finally: + del value, text, part, parts + + +def _normalize_anyllm_reasoning(message: dict[str, Any]) -> dict[str, Any]: + """Normalize AnyLLM's plaintext wrappers before retaining private replay metadata.""" + try: + reasoning = message.get("reasoning") + if isinstance(reasoning, str): + return message + if reasoning is None and ( + message.get("reasoning_content") or message.get("thinking_blocks") + ): + return message + if reasoning is None: + reasoning = message.get("thinking") + if reasoning is None: + return message + _encoded(reasoning) + return {**message, "reasoning": _anyllm_reasoning_text(reasoning)} + finally: + del message, reasoning + + def _chat_reasoning(message: dict[str, Any]) -> dict[str, Any]: value = blocks = block = None try: diff --git a/packages/codex/src/_agents_codex/_trace_export.py b/packages/codex/src/_agents_codex/_trace_export.py index 5d3b6358c6..267ae9c026 100644 --- a/packages/codex/src/_agents_codex/_trace_export.py +++ b/packages/codex/src/_agents_codex/_trace_export.py @@ -41,6 +41,26 @@ def _span_id(value: str | None) -> str | None: return None if value is None else "span_" + value.rjust(24, "0") +def _span_data(event: Mapping[str, Any]) -> dict[str, Any]: + attributes = event["attributes"] + match attributes.get("sdk.span.kind"): + case "model": + response_id = attributes.get("sdk.response.id") + return { + "type": "response", + "response_id": response_id if isinstance(response_id, str) else None, + "usage": None, + } + case "guardrail": + return { + "type": "guardrail", + "name": event["name"], + "triggered": attributes.get("sdk.outcome.category") == "guardrail_triggered", + } + case _: + return {"type": "custom", "name": event["name"], "data": _plain(attributes)} + + @_sdk_dataclass class _TraceState: descriptor: dict[str, Any] @@ -69,8 +89,8 @@ class OpenAITraceExporter: """Export native lifecycle records to the OpenAI traces-ingest endpoint. Pass an instance in configure(processors=[...]). Native flush barriers also - wait for these deliveries. Each completed native span becomes a custom - dashboard span with its native attributes, IDs and exact timestamps. + wait for these deliveries. Model response and guardrail spans use their dashboard types. + Other spans use the custom type. All records preserve native IDs and timestamps. Install ``openai-agents[tracing]`` to use this HTTP exporter. Each delivery awaits one client and its transport cleanup within the existing processor worker loop. No client is shared across loops and no background queue or @@ -318,25 +338,7 @@ async def on_trace_events(self, events: Sequence[Mapping[str, Any]]) -> None: "parent_id": _span_id(event["parent_span_id"]), "started_at": _timestamp(event["start_time_unix_nanos"]), "ended_at": _timestamp(event["end_time_unix_nanos"]), - "span_data": ( - { - "type": "response", - "response_id": event["attributes"].get( - "sdk.response.id" - ) - if isinstance( - event["attributes"].get("sdk.response.id"), str - ) - else None, - "usage": None, - } - if event["attributes"].get("sdk.span.kind") == "model" - else { - "type": "custom", - "name": event["name"], - "data": _plain(event["attributes"]), - } - ), + "span_data": _span_data(event), "error": { "message": "Native span failed", "data": {"outcome": event["outcome"]}, diff --git a/packages/codex/src/_agents_codex/models.py b/packages/codex/src/_agents_codex/models.py index a4db51802e..ecd0af3398 100644 --- a/packages/codex/src/_agents_codex/models.py +++ b/packages/codex/src/_agents_codex/models.py @@ -10,7 +10,7 @@ import sys from collections.abc import AsyncIterator, Awaitable, Callable, Mapping from contextlib import asynccontextmanager -from copy import deepcopy +from copy import copy, deepcopy from dataclasses import dataclass as dataclass, field, replace from typing import TYPE_CHECKING, Any, ClassVar, Literal, Protocol, TypeAlias, cast from uuid import uuid4 @@ -26,13 +26,14 @@ HostedAgentMetadata as HostedAgentMetadata, get_hosted_agent_metadata as get_hosted_agent_metadata, ) -from ._media import _capture_video +from ._media import _capture_file, _capture_image, _capture_video from ._model_provider_metadata import ( _capture_output, _chat_call_metadata, _chat_reasoning, _fold_chat_reasoning, _has_input, + _normalize_anyllm_reasoning, _replay_input, _retain_frame, _retain_output, @@ -571,6 +572,57 @@ def _chat_patch_replay_arguments(kind: str, item: Mapping[str, Any]) -> Any: return item["arguments"] +def _structured_chat_tool_output(parts: list[Any]) -> list[dict[str, Any]]: + converted: list[dict[str, Any]] = [] + part = source = value = detail = None + try: + for part in parts: + if not isinstance(part, dict): + raise TypeError("Chat tool output parts must be objects") + kind = part.get("type") + if kind == "input_text" and isinstance(part.get("text"), str): + value = {"type": "text", "text": part["text"]} + elif kind == "input_image": + source = _capture_image( + { + key: part[key] + for key in ("image_url", "file_id", "detail") + if key in part and part[key] is not None + } + ) + if "image_url" not in source: + raise ValueError("Chat tool images require an image URL") + detail = source.get("detail", "auto") + value = { + "type": "image_url", + "image_url": { + "url": source["image_url"], + "detail": "high" if detail == "original" else detail, + }, + } + elif kind == "input_file": + source = _capture_file( + { + key: part[key] + for key in ("file_id", "file_data", "file_url", "filename") + if key in part and part[key] is not None + } + ) + if "file_url" in source: + raise ValueError("Chat tool files require inline data or a provider file ID") + value = {"type": "file", "file": source} + else: + raise ValueError("Unsupported structured Chat tool output") + if "prompt_cache_breakpoint" in part: + value["prompt_cache_breakpoint"] = _capture_prompt_cache_breakpoint( + part["prompt_cache_breakpoint"] + ) + converted.append(value) + return converted + finally: + del parts, converted, part, source, value, detail + + _MAX_CHAT_STREAM_BYTES = 8 * 1024 * 1024 _MAX_CHAT_STREAM_CHUNKS = 128 * 1024 @@ -670,6 +722,7 @@ class ChatCompletionsModel: _stream_enabled: bool = field(default=False, init=False, repr=False) _include_usage: bool = field(default=True, init=False, repr=False) + _structured_tool_output: ClassVar[bool] = False def __init__( self, @@ -901,14 +954,26 @@ def _parameters( else: output = item["output"] if not isinstance(output, str): - if not isinstance(output, list) or any( - not isinstance(part, dict) - or part.get("type") != "input_text" - or not isinstance(part.get("text"), str) - for part in output + if ( + self._structured_tool_output + and isinstance(output, list) + and any( + isinstance(part, dict) and part.get("type") != "input_text" + for part in output + ) ): - raise ValueError("ChatCompletionsModel supports only text tool outputs") - output = "".join(part["text"] for part in output) + output = _structured_chat_tool_output(output) + else: + if not isinstance(output, list) or any( + not isinstance(part, dict) + or part.get("type") != "input_text" + or not isinstance(part.get("text"), str) + for part in output + ): + raise ValueError( + "ChatCompletionsModel supports only text tool outputs" + ) + output = "".join(part["text"] for part in output) messages.append( { "role": "tool", @@ -1212,6 +1277,8 @@ def _completed_response( raise ValueError(f"ChatCompletionsModel cannot complete finish_reason={reason}") output = [] annotations = [] + if isinstance(self, AnyLLMModel): + message = _normalize_anyllm_reasoning(message) reasoning_data = _chat_reasoning(message) if message.get("refusal") is None else {} if reasoning_data: reasoning_text = ( @@ -1328,6 +1395,7 @@ async def _stream_response(self, request: ModelRequest) -> AsyncIterator[Mapping text_parts: list[str] | None = None refusal_parts: list[str] | None = None response_id = finish_reason = None + choice_started = False calls: dict[int, dict[str, Any]] = {} logprobs: list[Any] = [] buffered_bytes = 0 @@ -1373,10 +1441,6 @@ async def _stream_response(self, request: ModelRequest) -> AsyncIterator[Mapping ): raise ValueError("Raw Chat chunk exceeds the stream frame limit") yield _RawChatChunk(deepcopy(raw)) - if opening: - yield _ChatStreamEvent( - {"type": "response.created", "response": {"id": response_id}} - ) choices = raw.get("choices") if choices == []: continue @@ -1387,6 +1451,13 @@ async def _stream_response(self, request: ModelRequest) -> AsyncIterator[Mapping ): raise ValueError("Chat stream requires exactly one response choice") choice = choices[0] + if not choice_started: + # Usage can arrive before any response choice. Retain its + # accounting without marking the generation as started. + choice_started = True + yield _ChatStreamEvent( + {"type": "response.created", "response": {"id": response_id}} + ) if finish_reason is not None: # LiteLLM keeps an empty choice on its usage-only tail. delta = choice.get("delta") @@ -1406,6 +1477,8 @@ async def _stream_response(self, request: ModelRequest) -> AsyncIterator[Mapping if provider_data is not None: delta = {**delta, "refusal": provider_data} probabilities = (choice.get("logprobs") or {}).get("content") + if isinstance(self, AnyLLMModel): + delta = _normalize_anyllm_reasoning(delta) retained = { "content": delta.get("content"), "refusal": delta.get("refusal"), @@ -1654,14 +1727,35 @@ class LitellmModel(ChatCompletionsModel): Set ``stream=True`` to receive text and function calls incrementally. """ + _structured_tool_output: ClassVar[bool] = True + def get_retry_advice(self, request: ModelRetryAdviceRequest) -> RetryAdvice | None: - return None + return super().get_retry_advice(request) async def _create(self, request: ModelRequest, **options: Any) -> Any: - response: Any = None + response = transport = headers = module = None try: if self._request_options_source is not None: raise TypeError("request_options requires an OpenAI-compatible client adapter") + transport = getattr(request, "_request_transport", None) + headers = transport.get("headers") if transport is not None else None + if headers is not None: + module = sys.modules.get("litellm") + model = options["model"] + if ( + module is not None + and self.client is module + and isinstance(model, str) + and model.startswith("openai/") + and model not in getattr(module, "model_alias_map", {}) + and getattr(module, "model_fallbacks", None) is None + ): + options.update(_client_request_options({"headers": headers})) + else: + # Some LiteLLM providers pass headers straight to HTTP. + options["extra_headers"] = { + name: value for name, value in headers.items() if value is not None + } if self.prompt_cache_key is not None: options["extra_body"] = { **options.get("extra_body", {}), @@ -1669,11 +1763,41 @@ async def _create(self, request: ModelRequest, **options: Any) -> Any: } if request.disable_provider_retries: options["num_retries"] = 0 + options["max_retries"] = 0 response = await self.client.acompletion(**options) return response if options["stream"] else response.model_dump() finally: # Release SDK-owned payloads before exposing any callback failure. - del request, options, response + del request, options, response, transport, headers, module + + +def _anyllm_provider_for_attempt(provider: Any, request: ModelRequest) -> Any: + if not request.disable_provider_retries: + return provider + + from openai import AsyncOpenAI + + any_llm = sys.modules.get("any_llm") + provider_class = getattr(any_llm, "AnyLLM", None) + client = getattr(provider, "client", None) + if ( + not isinstance(provider_class, type) + or not isinstance(provider, provider_class) + or not isinstance(client, AsyncOpenAI) + ): + raise TypeError("AnyLLMModel cannot suppress borrowed client retries per request") + if client.max_retries == 0: + return provider + + replay_provider = copy(cast(Any, provider)) + if replay_provider is provider: + raise TypeError("AnyLLMModel cannot suppress borrowed client retries per request") + replay_client = client.with_options(max_retries=0) + if replay_client.max_retries != 0: + raise TypeError("AnyLLMModel cannot suppress borrowed client retries per request") + # The replay client borrows the same HTTP transport. The application closes it. + replay_provider.client = replay_client + return replay_provider def _anyllm_responses_streaming_supported(client: Any) -> bool: @@ -1702,15 +1826,19 @@ class AnyLLMModel(ChatCompletionsModel): Inherited native cache hints are omitted for providers declaring them unsupported. Explicit adapter cache overrides, including empty strings, remain provider-validated. Generic completion requests omit the native ``store=False`` default. + Core retries can disable AnyLLM's own retries for OpenAI-backed providers. Set ``api="responses"`` for a supported AnyLLM OpenAI-compatible provider with public ``aresponses(extra_body=...)`` support. Streaming Responses requires a stable ``any-llm-sdk`` release at or above 1.28.0 - for stream cleanup. ``api="auto"`` selects Responses when these requirements - hold and otherwise uses Chat Completions. The default uses Chat Completions. + for stream cleanup. Hugging Face streaming borrows its OpenAI Responses + client directly so the native turn can close the physical stream. + ``api="auto"`` selects Responses when these requirements hold and otherwise + uses Chat Completions. The default uses Chat Completions. ``include_usage`` applies to Chat Completions only. """ - _responses: _AnyLLMResponsesModel | None = field(default=None, init=False, repr=False) + _structured_tool_output: ClassVar[bool] = True + _responses: ResponsesModel | None = field(default=None, init=False, repr=False) def __init__( self, @@ -1726,6 +1854,7 @@ def __init__( if api not in ("chat_completions", "responses", "auto"): raise ValueError("AnyLLMModel api must be chat_completions, responses or auto") use_responses = False + huggingface_client: Any = None if api != "chat_completions": is_qualified = getattr(client, "PROVIDER_NAME", None) in ( "openai", @@ -1734,6 +1863,10 @@ def __init__( "gmi", "deepseek", "meta", + "huggingface", + "fireworks", + "otari", + "groq", ) advertises_responses = getattr(client, "SUPPORTS_RESPONSES", False) is True if is_qualified and advertises_responses: @@ -1751,14 +1884,25 @@ def __init__( "AnyLLM Responses requires a supported OpenAI-compatible provider " "with public aresponses extra_body support" ) - if ( - use_responses - and stream is True - and not _anyllm_responses_streaming_supported(client) - ): - if api == "responses": - raise ValueError("Streaming AnyLLM Responses requires any-llm-sdk>=1.28.0") - use_responses = False + if use_responses and stream is True: + if client.PROVIDER_NAME == "huggingface": + # The AnyLLM wrapper does not forward close. Borrow the existing + # provider's OpenAI stream client without changing its ownership. + from openai import AsyncOpenAI + + selected = getattr(client, "responses_client", None) + if isinstance(selected, AsyncOpenAI): + huggingface_client = selected + else: + if api == "responses": + raise ValueError( + "Hugging Face streaming Responses requires its OpenAI client" + ) + use_responses = False + elif not _anyllm_responses_streaming_supported(client): + if api == "responses": + raise ValueError("Streaming AnyLLM Responses requires any-llm-sdk>=1.28.0") + use_responses = False if use_responses and request_options is not None: raise TypeError("request_options requires an OpenAI-compatible client adapter") super().__init__( @@ -1773,7 +1917,11 @@ def __init__( object.__setattr__( self, "_responses", - _AnyLLMResponsesModel( + ResponsesModel( + huggingface_client, model, prompt_cache_key=prompt_cache_key, stream=stream + ) + if huggingface_client is not None + else _AnyLLMResponsesModel( client, model, prompt_cache_key=prompt_cache_key, stream=stream ), ) @@ -1791,16 +1939,20 @@ async def complete(self, request: ModelRequest) -> ModelResponse: del request def get_retry_advice(self, request: ModelRetryAdviceRequest) -> RetryAdvice | None: - return None + return super().get_retry_advice(request) async def _create(self, request: ModelRequest, **options: Any) -> Any: + client: Any = None try: - if request.disable_provider_retries: - raise TypeError("AnyLLMModel cannot suppress borrowed client retries per request") + client = _anyllm_provider_for_attempt(self.client, request) if self._request_options_source is not None: raise TypeError("request_options requires an OpenAI-compatible client adapter") if "max_completion_tokens" in options: options["max_tokens"] = options.pop("max_completion_tokens") + if getattr(self.client, "PROVIDER_NAME", None) == "gemini": + # Gemini uses its default parallel tool behavior without this option. + if options.pop("parallel_tool_calls", None) is False: + raise ValueError("Gemini Chat cannot disable parallel tool calls") if ( self.prompt_cache_key is None and getattr(self.client, "PROMPT_CACHE_KEY_SUPPORT", None) == "unsupported" @@ -1810,10 +1962,10 @@ async def _create(self, request: ModelRequest, **options: Any) -> Any: if options.get("store") is False: # The generic completion interface has no storage control. options.pop("store") - return await self.client.acompletion(**options) + return await client.acompletion(**options) finally: # Release SDK-owned payloads before exposing any callback failure. - del request, options + del request, options, client @_sdk_dataclass(frozen=True, init=False) @@ -2055,9 +2207,7 @@ async def _create(self, request: ModelRequest, *, stream: bool) -> Any: create: Any = None try: self._check_video_input(request) - if request.disable_provider_retries: - raise TypeError("AnyLLMModel cannot suppress borrowed client retries per request") - create = self.client.aresponses + create = _anyllm_provider_for_attempt(self.client, request).aresponses if not inspect.iscoroutinefunction(inspect.unwrap(create)): raise TypeError("AnyLLMModel requires an asynchronous provider") body = dict(request.body) @@ -2065,6 +2215,13 @@ async def _create(self, request: ModelRequest, *, stream: bool) -> Any: body.pop("model") body["input_data"] = body.pop("input") body["stream"] = stream + if ( + getattr(self.client, "PROVIDER_NAME", None) == "otari" + and not stream + and body.get("tool_choice") is not None + ): + # Otari validates its buffered request with a generated union model. + body["tool_choice"] = {"actual_instance": body["tool_choice"]} if "client_metadata" in body: # Core's transport metadata is outside AnyLLM's typed Responses fields. body["extra_body"] = {"client_metadata": body.pop("client_metadata")} diff --git a/packages/codex/tests/test_native_anyllm_gemini.py b/packages/codex/tests/test_native_anyllm_gemini.py new file mode 100644 index 0000000000..71b2bcb1dc --- /dev/null +++ b/packages/codex/tests/test_native_anyllm_gemini.py @@ -0,0 +1,88 @@ +from __future__ import annotations + +import json + +import pytest +from aiohttp import web +from aiohttp.test_utils import TestServer + +from agents import Agent, AnyLLMModel, NativeProvider, function_tool +from tests._asyncio import timeout + + +@pytest.mark.parametrize("stream", [False, True]) +@pytest.mark.parametrize("disable_parallel", [False, True]) +async def test_gemini_native_chat_tool_continuation(stream, disable_parallel): + any_llm = pytest.importorskip("any_llm") + pytest.importorskip("google.genai") + requests = [] + effects = [] + + @function_tool + def lookup(query: str) -> str: + effects.append(query) + return "available" + + async def generate(request): + body = await request.json() + requests.append(body) + part = ( + {"functionCall": {"id": "gemini-call", "name": "lookup", "args": {"query": "test"}}} + if len(requests) == 1 + else {"text": "continued"} + ) + result = { + "candidates": [ + {"content": {"role": "model", "parts": [part]}, "finishReason": "STOP", "index": 0} + ], + "modelVersion": "gemini-fixture", + "responseId": f"gemini-response-{len(requests)}", + "usageMetadata": { + "promptTokenCount": 2, + "candidatesTokenCount": 1, + "totalTokenCount": 3, + }, + } + if stream: + return web.Response( + text=f"data: {json.dumps(result)}\n\n", content_type="text/event-stream" + ) + return web.json_response(result) + + app = web.Application() + app.router.add_post("/{prefix:.*}", generate) + async with timeout(20), TestServer(app) as server: + base = str(server.make_url("/")).rstrip("/") + borrowed = any_llm.AnyLLM.create("gemini", api_key="synthetic", api_base=base) + try: + backend = AnyLLMModel(borrowed, model="gemini-fixture", api="auto", stream=stream) + async with NativeProvider(base_url=base + "/unused", model_backend=backend) as provider: + agent = Agent( + model="gemini-fixture", + provider=provider, + instructions="Use lookup.", + tools=[lookup], + **( + {"model_settings": {"parallel_tool_calls": False}} + if disable_parallel + else {} + ), + ) + if disable_parallel: + with pytest.raises( + ValueError, match="Gemini Chat cannot disable parallel tool calls" + ): + await agent.run("check") + assert not requests and not effects + return + result = await agent.run("check") + finally: + await borrowed.client.aio.aclose() + borrowed.client.close() + assert result.final_output == "continued" + assert effects == ["test"] and len(requests) == 2 + replies = [ + msg for msg in requests[1]["contents"] if any("functionResponse" in p for p in msg["parts"]) + ] + assert len(replies) == 1 and replies[0]["role"] == "user" + assert replies[0]["parts"][0]["functionResponse"]["name"] == "lookup" diff --git a/packages/codex/tests/test_native_anyllm_reasoning_shapes.py b/packages/codex/tests/test_native_anyllm_reasoning_shapes.py new file mode 100644 index 0000000000..4623daf4da --- /dev/null +++ b/packages/codex/tests/test_native_anyllm_reasoning_shapes.py @@ -0,0 +1,105 @@ +"""Normalize AnyLLM reasoning shapes before receipt-bound native replay.""" + +from __future__ import annotations + +from pathlib import Path +from types import SimpleNamespace + +import pytest + +from _agents_codex._model_provider_metadata import _normalize_anyllm_reasoning +from agents import Agent, NativeProvider, SessionState, function_tool +from agents.models import AnyLLMModel + + +@pytest.mark.asyncio +@pytest.mark.parametrize("stream", [False, True]) +@pytest.mark.parametrize( + ("metadata", "expected"), + [ + ({"reasoning_content": "", "reasoning": {"content": "Private plan"}}, "Private plan"), + ({"thinking": [{"text": "Private "}, {"thinking": "plan"}]}, "Private plan"), + ({"reasoning": "Private plan"}, "Private plan"), + ], + ids=["nested-reasoning", "nested-thinking", "plain-reasoning"], +) +async def test_native_anyllm_reasoning_replays_after_tool_and_cold_restore( + stream, metadata, expected +): + requests = [] + effects = [] + tool_call = { + "id": "call-lookup", + "type": "function", + "function": {"name": "lookup", "arguments": "{}"}, + } + + async def complete(**options): + requests.append(options) + opening = len(requests) == 1 + identity = f"chat-{len(requests)}" + message = ( + {"role": "assistant", "tool_calls": [tool_call], **metadata} + if opening + else {"role": "assistant", "content": "Done."} + ) + finish = "tool_calls" if opening else "stop" + if not stream: + return {"id": identity, "choices": [{"message": message, "finish_reason": finish}]} + + async def chunks(): + delta = dict(message) + if opening: + delta["tool_calls"] = [{"index": 0, **tool_call}] + yield { + "id": identity, + "choices": [{"index": 0, "delta": delta, "finish_reason": finish}], + } + + return chunks() + + @function_tool + def lookup() -> str: + effects.append("once") + return "record" + + client = SimpleNamespace(PROVIDER_NAME="openrouter", acompletion=complete) + backend = AnyLLMModel(client, "openrouter/reasoning-fixture", stream=stream) + async with NativeProvider(model_backend=backend) as provider: + agent = Agent( + model="gpt-5.5", instructions="Read the record.", provider=provider, tools=[lookup] + ) + async with agent.session() as session: + result = await (await session.submit("Read.")).get_result() + assert result.final_output == "Done." + saved = SessionState.from_json((await session.save_state()).to_json()) + async with agent.session(state=saved) as session: + result = await (await session.submit("Continue.")).get_result() + assert result.final_output == "Done." + + assert effects == ["once"] + for request in requests[1:]: + tool_message = next(row for row in request["messages"] if row.get("tool_calls")) + assert tool_message["reasoning"] == expected + assert sum(row.get("reasoning") == expected for row in request["messages"]) == 1 + + +@pytest.mark.parametrize("container", ["object", "list"]) +def test_anyllm_invalid_nesting_releases_provider_payload_from_traceback(container): + value = "synthetic-private-reasoning-canary" + for _ in range(34): + value = {"content": value} if container == "object" else ["other-private-prefix", value] + + with pytest.raises(ValueError, match="supported nesting depth") as failure: + _normalize_anyllm_reasoning({"reasoning": value}) + + traceback = failure.value.__traceback__ + while traceback is not None: + frame = traceback.tb_frame + if Path(frame.f_code.co_filename).name == "_model_provider_metadata.py": + assert ( + not {"message", "reasoning", "value", "part", "parts", "text"} + & set(frame.f_locals) + ) + assert "synthetic-private-reasoning-canary" not in repr(frame.f_locals) + traceback = traceback.tb_next diff --git a/packages/codex/tests/test_native_borrowed_retry_takeover.py b/packages/codex/tests/test_native_borrowed_retry_takeover.py new file mode 100644 index 0000000000..601719ec52 --- /dev/null +++ b/packages/codex/tests/test_native_borrowed_retry_takeover.py @@ -0,0 +1,178 @@ +"""Core becomes the only retry owner after the first borrowed model attempt.""" + +from types import SimpleNamespace + +import pytest +from aiohttp import web +from aiohttp.test_utils import TestServer +from openai import DefaultAsyncHttpxClient + +from agents import ( + Agent, + AnyLLMModel, + LitellmModel, + ModelRequest, + ModelRetrySettings, + NativeProvider, + RetryBackoffSettings, + RetryDecision, +) +from tests._asyncio import timeout + + +@pytest.mark.parametrize("api", ["chat_completions", "responses"]) +@pytest.mark.parametrize("stream", [False, True]) +async def test_anyllm_native_retry_reuses_borrowed_transport_without_retrying(api, stream): + any_llm = pytest.importorskip("any_llm") + sends = [] + policies = [] + + async def handle(request): + sends.append(request.headers["x-stainless-retry-count"]) + return web.json_response( + {"error": {"message": "synthetic retry ownership", "type": "server_error"}}, + status=503, + headers={"retry-after-ms": "1"}, + ) + + def policy(context): + policies.append(context.attempt) + return RetryDecision(retry=True) + + app = web.Application() + app.router.add_post("/v1/responses", handle) + app.router.add_post("/v1/chat/completions", handle) + async with timeout(15), TestServer(app) as server: + client = any_llm.AnyLLM.create( + "openai", + api_base=str(server.make_url("/v1")), + api_key="synthetic", + max_retries=1, + http_client=DefaultAsyncHttpxClient(trust_env=False), + ) + try: + adapter = AnyLLMModel(client, api=api, stream=stream) + async with NativeProvider(model_backend=adapter) as provider: + agent = Agent( + model="gpt-5.5", + instructions="Reply.", + provider=provider, + model_settings={ + "retry": ModelRetrySettings( + max_retries=1, + policy=policy, + backoff=RetryBackoffSettings( + initial_delay_ms=0, max_delay_ms=0, jitter=False + ), + ) + }, + ) + with pytest.raises(Exception, match="synthetic retry ownership"): + await agent.run("Reply.") + assert client.client.max_retries == 1 + assert not client.client.is_closed() + finally: + await client.client.close() + + assert len(policies) == 1 + assert sends == ["0", "1", "0"] + + +async def test_litellm_overrides_both_retry_controls_only_on_native_replay(): + calls = [] + + class BorrowedRouter: + async def acompletion(self, **options): + calls.append((options.get("num_retries"), options.get("max_retries"))) + raise TimeoutError("synthetic Router retry ownership") + + async with ( + timeout(15), + NativeProvider(model_backend=LitellmModel(BorrowedRouter())) as provider, + ): + agent = Agent( + model="gpt-5.5", + instructions="Reply.", + provider=provider, + model_settings={ + "retry": ModelRetrySettings( + max_retries=1, + policy=lambda _: RetryDecision(retry=True), + backoff=RetryBackoffSettings(initial_delay_ms=0, max_delay_ms=0, jitter=False), + ) + }, + ) + with pytest.raises(Exception, match="synthetic Router retry ownership"): + await agent.run("Reply.") + + assert calls == [(None, None), (0, 0)] + + +async def test_anyllm_opaque_provider_is_not_dispatched_when_core_owns_retry(): + class OpaqueProvider: + async def acompletion(self, **kwargs): + pytest.fail("An opaque provider must not send the retry") + + adapter = AnyLLMModel(OpaqueProvider()) + request = ModelRequest( + body={"model": "gpt-5.5", "input": []}, + context=None, + session_id="session", + turn_id="turn", + disable_provider_retries=True, + ) + with pytest.raises(TypeError, match="cannot suppress borrowed client retries"): + await adapter.complete(request) + + +async def test_litellm_native_retry_preserves_first_provider_retry_only(monkeypatch): + monkeypatch.setenv("LITELLM_LOCAL_MODEL_COST_MAP", "True") + litellm = pytest.importorskip("litellm") + monkeypatch.setattr(litellm, "telemetry", False) + sends = [] + attempts = [] + + async def handle(request): + sends.append((len(attempts) - 1, request.headers.get("x-stainless-retry-count"))) + return web.json_response( + {"error": {"message": "synthetic LiteLLM retry ownership", "type": "server_error"}}, + status=503, + headers={"retry-after-ms": "1"}, + ) + + app = web.Application() + app.router.add_post("/v1/chat/completions", handle) + async with timeout(20), TestServer(app) as server: + base = str(server.make_url("/v1")) + + async def acompletion(**options): + options.setdefault("num_retries", 1) + options.setdefault("max_retries", 1) + attempts.append((options["num_retries"], options["max_retries"])) + return await litellm.acompletion(**options, api_base=base, api_key="synthetic") + + adapter = LitellmModel(SimpleNamespace(acompletion=acompletion), "openai/gpt-4.1") + async with NativeProvider(model_backend=adapter) as provider: + agent = Agent( + model="gpt-4.1", + instructions="Reply.", + provider=provider, + model_settings={ + "retry": ModelRetrySettings( + max_retries=1, + policy=lambda _: RetryDecision(retry=True), + backoff=RetryBackoffSettings( + initial_delay_ms=0, max_delay_ms=0, jitter=False + ), + ) + }, + ) + with pytest.raises(Exception, match="synthetic LiteLLM retry ownership"): + await agent.run("Reply.") + assert attempts == [(1, 1), (0, 0)] + first_attempt = [retry for attempt, retry in sends if attempt == 0] + native_retry = [retry for attempt, retry in sends if attempt == 1] + # LiteLLM versions may add their own outer retry to the first adapter call. + # Core's replay must make exactly one HTTP request with SDK retries disabled. + assert first_attempt[:2] == ["0", "1"] + assert native_retry == ["0"] diff --git a/packages/codex/tests/test_native_borrowed_tool_media.py b/packages/codex/tests/test_native_borrowed_tool_media.py new file mode 100644 index 0000000000..89f7527a00 --- /dev/null +++ b/packages/codex/tests/test_native_borrowed_tool_media.py @@ -0,0 +1,158 @@ +import json +from types import SimpleNamespace + +import pytest +from aiohttp import web +from aiohttp.test_utils import TestServer +from openai import AsyncOpenAI + +from agents import ( + Agent, + AnyLLMModel, + LitellmModel, + NativeProvider, + SessionState, + ToolOutput, + ToolOutputFile, + ToolOutputImage, + ToolOutputText, + function_tool, +) + +IMAGE = ( + "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAICAIAAABLbSncAAAAFElEQV" + "R4nGPkUbJgwAaYsIoOWgkAVcAAdmJlY/oAAAAASUVORK5CYII=" +) +FILE_DATA = "data:text/plain;base64,YXNzZXQ=" + +TOOL = { + "id": "call_inspect", + "type": "function", + "function": {"name": "inspect_asset", "arguments": "{}"}, +} + + +@pytest.mark.asyncio +@pytest.mark.parametrize("stream", [False, True]) +@pytest.mark.parametrize("backend", ["litellm", "anyllm"]) +@pytest.mark.parametrize("media", ["image", "file", "file-id"]) +async def test_borrowed_structured_tool_output_reaches_next_request( + monkeypatch, stream, backend, media +): + wire = [] + effects = [] + + async def route(request): + body = await request.json() + wire.append(body) + first = len(wire) == 1 + message = {"role": "assistant", "content": None if first else "Complete."} + if first: + message["tool_calls"] = [TOOL] + finish = "tool_calls" if first else "stop" + shared = {"id": f"chat_{len(wire)}", "model": "gpt-4o-mini", "created": 1} + if not body.get("stream"): + return web.json_response( + { + **shared, + "object": "chat.completion", + "choices": [{"index": 0, "message": message, "finish_reason": finish}], + "usage": { + "prompt_tokens": 4, + "completion_tokens": 2, + "total_tokens": 6, + }, + } + ) + if first: + message["tool_calls"] = [{"index": 0, **TOOL}] + frames = [ + { + **shared, + "object": "chat.completion.chunk", + "choices": [{"index": 0, "delta": delta, "finish_reason": reason}], + } + for delta, reason in ((message, None), ({}, finish)) + ] + return web.Response( + text="".join(f"data: {json.dumps(frame)}\n\n" for frame in frames) + "data: [DONE]\n\n", + content_type="text/event-stream", + ) + + app = web.Application() + app.router.add_post("/v1/chat/completions", route) + async with TestServer(app) as server: + base = str(server.make_url("/v1")) + + @function_tool + def inspect_asset() -> ToolOutput: + effects.append("once") + part = { + "image": ToolOutputImage(IMAGE, detail="high"), + "file": ToolOutputFile(file_data=FILE_DATA, filename="asset.txt"), + "file-id": ToolOutputFile(file_id="file-fixture-owned"), + }[media] + return ToolOutput([ToolOutputText("asset label"), part]) + + async def run(adapter): + async with NativeProvider(model_backend=adapter) as provider: + agent = Agent( + name="asset", + model="gpt-4o-mini", + instructions="Inspect the asset.", + tools=[inspect_asset], + provider=provider, + ) + async with agent.session() as session: + initial = await (await session.submit("Use the tool.")).get_result() + assert initial.final_output == "Complete." + saved = await session.save_state() + async with agent.session(state=SessionState.from_json(saved.to_json())) as session: + return await (await session.submit("Continue.")).get_result() + + if backend == "anyllm": + any_llm = pytest.importorskip("any_llm") + client = any_llm.AnyLLM.create( + "openai", api_base=base, api_key="synthetic-tool-output", max_retries=0 + ) + try: + result = await run(AnyLLMModel(client, "gpt-4o-mini", stream=stream)) + finally: + await client.client.close() + else: + monkeypatch.setenv("LITELLM_LOCAL_MODEL_COST_MAP", "True") + litellm = pytest.importorskip("litellm") + monkeypatch.setattr(litellm, "telemetry", False) + async with AsyncOpenAI( + base_url=base, api_key="synthetic-tool-output", max_retries=0 + ) as client: + + async def create(**options): + options.setdefault("num_retries", 0) + return await litellm.acompletion( + **options, + client=client, + api_base=base, + api_key="synthetic-tool-output", + allowed_openai_params=["tool_choice"], + ) + + result = await run( + LitellmModel( + SimpleNamespace(acompletion=create), "openai/gpt-4o-mini", stream=stream + ) + ) + assert result.final_output == "Complete." + assert effects == ["once"] + assert len(wire) == 3 + assert [bool(request.get("stream")) for request in wire] == [stream, stream, stream] + projected_media = { + "image": {"type": "image_url", "image_url": {"url": IMAGE, "detail": "high"}}, + "file": {"type": "file", "file": {"file_data": FILE_DATA, "filename": "asset.txt"}}, + "file-id": {"type": "file", "file": {"file_id": "file-fixture-owned"}}, + }[media] + expected = [{"type": "text", "text": "asset label"}, projected_media] + for request in wire[1:]: + [output] = [message for message in request["messages"] if message["role"] == "tool"] + assert output["tool_call_id"] == TOOL["id"] + assert output["content"] == expected diff --git a/packages/codex/tests/test_native_chat_response_start_policy.py b/packages/codex/tests/test_native_chat_response_start_policy.py new file mode 100644 index 0000000000..97c2e4283b --- /dev/null +++ b/packages/codex/tests/test_native_chat_response_start_policy.py @@ -0,0 +1,158 @@ +"""Physical preterminal stream failures retain retry context and measured usage.""" + +import asyncio +import json +from contextlib import AsyncExitStack + +import pytest +from aiohttp import web +from aiohttp.test_utils import TestServer +from openai import AsyncOpenAI, DefaultAsyncHttpxClient +from tests._asyncio import timeout + +from agents import ( + Agent, + AnyLLMModel, + ChatCompletionsModel, + ModelRetrySettings, + NativeProvider, + RetryDecision, + SessionState, +) + + +@pytest.mark.asyncio +@pytest.mark.parametrize("adapter", ["openai", "anyllm"]) +async def test_partial_chat_usage_survives_physical_preterminal_retry_and_cold_state(adapter): + model_type = AnyLLMModel if adapter == "anyllm" else ChatCompletionsModel + calls, seen, advice = [], [], [] + + def chunk(identifier, choices, usage=None): + return { + "id": identifier, + "object": "chat.completion.chunk", + "created": 1, + "model": "gpt-5.5", + "choices": choices, + "usage": usage, + } + + def event(value): + return "data: " + json.dumps(value) + "\n\n" + + async def handle(request): + calls.append(await request.json()) + if len(calls) == 1: + response = web.StreamResponse(headers={"Content-Type": "text/event-stream"}) + await response.prepare(request) + await response.write( + event( + chunk( + "partial", + [], + {"prompt_tokens": 5, "completion_tokens": 2, "total_tokens": 7}, + ) + ).encode() + ) + transport = request.transport + assert transport is not None + await asyncio.sleep(0.03) + transport.abort() + return response + chunks = [ + chunk( + "recovered", + [ + { + "index": 0, + "delta": {"role": "assistant", "content": "recovered"}, + "finish_reason": None, + } + ], + ), + chunk("recovered", [{"index": 0, "delta": {}, "finish_reason": "stop"}]), + chunk( + "recovered", [], {"prompt_tokens": 11, "completion_tokens": 3, "total_tokens": 14} + ), + ] + return web.Response( + text="".join(event(value) for value in chunks) + "data: [DONE]\n\n", + content_type="text/event-stream", + ) + + class ObservedChat(model_type): + def get_retry_advice(self, request): + advice.append(request) + return super().get_retry_advice(request) + + def retry(context): + seen.append(context) + return RetryDecision(not context.response_started, delay_ms=0) + + app = web.Application() + app.router.add_post("/v1/chat/completions", handle) + async with ( + timeout(20), + TestServer(app, shutdown_timeout=1) as server, + AsyncExitStack() as clients, + ): + base_url = str(server.make_url("/v1")) + transport = await clients.enter_async_context(DefaultAsyncHttpxClient(trust_env=False)) + if adapter == "anyllm": + any_llm = pytest.importorskip("any_llm") + client = any_llm.AnyLLM.create( + "openai", + api_base=base_url, + api_key="synthetic", + max_retries=0, + http_client=transport, + ) + clients.push_async_callback(client.client.close) + else: + client = await clients.enter_async_context( + AsyncOpenAI( + base_url=base_url, api_key="synthetic", max_retries=0, http_client=transport + ) + ) + async with NativeProvider(model_backend=ObservedChat(client, stream=True)) as provider: + agent = Agent( + instructions="Reply", + model="gpt-5.5", + provider=provider, + model_settings={"retry": ModelRetrySettings(max_retries=1, policy=retry)}, + ) + async with agent.session() as session: + turn = await session.submit("go") + result = await turn.get_result() + assert result.final_output == "recovered" + assert result.run_usage.requests == 2 + assert result.run_usage.total_tokens == 21 + assert result.run_usage.missing_usage_requests == 0 + detail = [row async for row in session.turns()][-1] + entries = detail["request_usage_entries"] + cold = SessionState.from_json((await session.save_state()).to_json()) + async with agent.session(state=cold) as restored: + restored_detail = [row async for row in restored.turns()][-1] + assert restored_detail["request_usage_entries"] == entries + + assert len(calls) == 2 and calls[0] == calls[1] + assert len(seen) == len(advice) == 1 + (context,) = seen + assert context.error is advice[0].error + assert context.stream is advice[0].stream is True + assert context.usage is not None and context.usage.total_tokens == 7 + assert context.normalized.is_network_error is True + assert context.response_started is False and context.retry_unsafe_output is False + assert [(row["scope"], row["total_tokens"]) for row in entries] == [ + ("sdk_model_attempt", 7), + ("sdk_model_attempt", 14), + ] + assert entries[0]["attempt_id"] == context.attempt_id + print( + "PHYSICAL_CONTEXT", + type(context.error).__name__, + context.normalized, + context.response_started, + context.retry_unsafe_output, + [(row["scope"], row["total_tokens"]) for row in entries], + ) diff --git a/packages/codex/tests/test_native_litellm_default_header_omission.py b/packages/codex/tests/test_native_litellm_default_header_omission.py new file mode 100644 index 0000000000..8700d18e48 --- /dev/null +++ b/packages/codex/tests/test_native_litellm_default_header_omission.py @@ -0,0 +1,138 @@ +"""Explicit native LiteLLM headers reach its owned loopback transport.""" + +from __future__ import annotations + +import json + +import pytest +from aiohttp import web +from aiohttp.test_utils import TestServer +from openai import AsyncOpenAI, omit + +from agents import Agent, NativeProvider +from agents.models import LitellmModel + + +@pytest.mark.asyncio +@pytest.mark.parametrize("stream", [False, True]) +@pytest.mark.parametrize("removed", [None, omit], ids=["none", "openai-omit"]) +async def test_litellm_can_remove_borrowed_default_headers(stream, removed, monkeypatch): + monkeypatch.setenv("LITELLM_LOCAL_MODEL_COST_MAP", "True") + litellm = pytest.importorskip("litellm") + monkeypatch.setattr(litellm, "suppress_debug_info", True) + monkeypatch.setattr(litellm, "telemetry", False) + seen = [] + + async def respond(request): + seen.append(dict(request.headers)) + body = await request.json() + assert body.get("stream", False) is stream + assert "extra_headers" not in body + common = {"id": "fixture-chat", "created": 1, "model": "gpt-5.5"} + message = {"role": "assistant", "content": "Done."} + if not stream: + return web.json_response( + { + **common, + "object": "chat.completion", + "choices": [{"index": 0, "message": message, "finish_reason": "stop"}], + } + ) + chunk = { + **common, + "object": "chat.completion.chunk", + "choices": [{"index": 0, "delta": message, "finish_reason": "stop"}], + } + return web.Response( + text=f"data: {json.dumps(chunk)}\n\ndata: [DONE]\n\n", + content_type="text/event-stream", + ) + + app = web.Application() + app.router.add_post("/v1/chat/completions", respond) + async with TestServer(app) as server: + base = str(server.make_url("/v1")) + async with AsyncOpenAI( + api_key="synthetic-credential", + base_url=base, + default_headers={"X-Test-Remove": "default", "X-Test-Keep": "default-keep"}, + ) as client: + original = litellm.acompletion + + async def complete(**options): + return await original( + **options, + client=client, + api_base=base, + api_key="synthetic-credential", + num_retries=0, + ) + + monkeypatch.setattr(litellm, "acompletion", complete) + adapter = LitellmModel(litellm, "openai/gpt-5.5", stream=stream) + async with NativeProvider(model_backend=adapter) as provider: + agent = Agent( + model="gpt-5.5", + instructions="Answer.", + provider=provider, + model_settings={ + "extra_headers": { + "X-Test-Route": "native-litellm-scope", + "x-test-remove": removed, + } + }, + ) + assert (await agent.run("Start.")).final_output == "Done." + + [headers] = seen + lower = {name.lower(): value for name, value in headers.items()} + assert lower["x-test-route"] == "native-litellm-scope" + assert lower["authorization"] == "Bearer synthetic-credential" + assert lower["x-test-keep"] == "default-keep" + assert "x-test-remove" not in lower + + +@pytest.mark.asyncio +@pytest.mark.parametrize( + ("model", "stock", "remapped"), + [ + ("openai/gpt-4o-mini", False, False), + ("openai/alias", True, True), + ("anthropic/claude-sonnet-4-20250514", True, False), + ], + ids=["custom-client", "stock-alias", "non-openai"], +) +async def test_litellm_unverified_transports_keep_concrete_headers( + model, stock, remapped, monkeypatch +): + from types import SimpleNamespace + + from agents.models import ModelRequest + + monkeypatch.setenv("LITELLM_LOCAL_MODEL_COST_MAP", "True") + litellm = pytest.importorskip("litellm") + if remapped: + monkeypatch.setattr( + litellm, "model_alias_map", {model: "anthropic/claude-sonnet-4-20250514"} + ) + + async def complete(**options): + assert options["extra_headers"] == {"X-Test-Keep": "keep"} + return SimpleNamespace( + model_dump=lambda: { + "id": "fixture-chat", + "choices": [{"index": 0, "message": {"content": "done"}, "finish_reason": "stop"}], + } + ) + + monkeypatch.setattr(litellm, "acompletion", complete) + client = litellm if stock else SimpleNamespace(acompletion=complete) + adapter = LitellmModel(client, model) + request = ModelRequest({"model": "fixture", "input": []}, None, "fixture", "turn") + object.__setattr__( + request, + "_request_transport", + {"headers": {"x-test-remove": None, "X-Test-Keep": "keep"}}, + ) + result = await adapter.complete(request) + assert result.output[0]["content"][0]["text"] == "done" diff --git a/packages/codex/tests/test_native_litellm_physical_transport.py b/packages/codex/tests/test_native_litellm_physical_transport.py new file mode 100644 index 0000000000..1b616f00ba --- /dev/null +++ b/packages/codex/tests/test_native_litellm_physical_transport.py @@ -0,0 +1,80 @@ +"""Explicit native LiteLLM headers reach its owned loopback transport.""" + +from __future__ import annotations + +import json +from types import SimpleNamespace + +import pytest +from aiohttp import web +from aiohttp.test_utils import TestServer +from openai import AsyncOpenAI + +from agents import Agent, NativeProvider +from agents.models import LitellmModel + + +@pytest.mark.asyncio +@pytest.mark.parametrize("stream", [False, True]) +async def test_current_litellm_scope_reaches_physical_transport(stream, monkeypatch): + monkeypatch.setenv("LITELLM_LOCAL_MODEL_COST_MAP", "True") + litellm = pytest.importorskip("litellm") + monkeypatch.setattr(litellm, "telemetry", False) + seen = [] + + async def respond(request): + seen.append(dict(request.headers)) + body = await request.json() + assert body.get("stream", False) is stream + assert "extra_headers" not in body + common = {"id": "fixture-chat", "created": 1, "model": "gpt-5.5"} + message = {"role": "assistant", "content": "Done."} + if not stream: + return web.json_response( + { + **common, + "object": "chat.completion", + "choices": [{"index": 0, "message": message, "finish_reason": "stop"}], + } + ) + chunk = { + **common, + "object": "chat.completion.chunk", + "choices": [{"index": 0, "delta": message, "finish_reason": "stop"}], + } + return web.Response( + text=f"data: {json.dumps(chunk)}\n\ndata: [DONE]\n\n", + content_type="text/event-stream", + ) + + app = web.Application() + app.router.add_post("/v1/chat/completions", respond) + async with TestServer(app) as server: + base = str(server.make_url("/v1")) + async with AsyncOpenAI(api_key="synthetic-credential", base_url=base) as client: + + async def complete(**options): + return await litellm.acompletion( + **options, + client=client, + api_base=base, + api_key="synthetic-credential", + num_retries=0, + ) + + adapter = LitellmModel( + SimpleNamespace(acompletion=complete), "openai/gpt-5.5", stream=stream + ) + async with NativeProvider(model_backend=adapter) as provider: + agent = Agent( + model="gpt-5.5", + instructions="Answer.", + provider=provider, + model_settings={"extra_headers": {"X-Test-Route": "native-litellm-scope"}}, + ) + assert (await agent.run("Start.")).final_output == "Done." + + [headers] = seen + lower = {name.lower(): value for name, value in headers.items()} + assert lower["x-test-route"] == "native-litellm-scope" + assert lower["authorization"] == "Bearer synthetic-credential" diff --git a/packages/codex/tests/test_native_litellm_transport_scope.py b/packages/codex/tests/test_native_litellm_transport_scope.py new file mode 100644 index 0000000000..d1776db67c --- /dev/null +++ b/packages/codex/tests/test_native_litellm_transport_scope.py @@ -0,0 +1,79 @@ +"""Keep current LiteLLM request headers scoped to the issued native Agent.""" + +from __future__ import annotations + +from types import SimpleNamespace + +import pytest + +from agents import Agent, NativeProvider +from agents.models import LitellmModel + + +@pytest.mark.asyncio +@pytest.mark.parametrize("stream", [False, True]) +async def test_litellm_native_handoff_changes_current_header_without_leaking(stream): + observed = [] + + async def complete(**options): + observed.append(options.get("extra_headers")) + identity = f"chat-{len(observed)}" + if len(observed) == 1: + tool_call = { + "id": "current-profile-transfer", + "type": "function", + "function": {"name": "transfer_to_destination", "arguments": "{}"}, + } + finish = "tool_calls" + message = {"role": "assistant", "tool_calls": [tool_call]} + else: + finish = "stop" + message = {"role": "assistant", "content": "Done."} + if not stream: + return SimpleNamespace( + model_dump=lambda: { + "id": identity, + "choices": [{"message": message, "finish_reason": finish}], + } + ) + + async def chunks(): + delta = dict(message) + if finish == "tool_calls": + delta["tool_calls"] = [{"index": 0, **tool_call}] + yield { + "id": identity, + "choices": [{"index": 0, "delta": delta, "finish_reason": finish}], + } + + return chunks() + + backend = LitellmModel(SimpleNamespace(acompletion=complete), "test-model", stream=stream) + async with NativeProvider(model_backend=backend) as provider: + destination = Agent( + name="Destination", + instructions="Finish.", + model_settings={"extra_headers": {"x-test-profile": "fixture-destination"}}, + ) + source = Agent( + name="Source", + instructions="Transfer.", + model="gpt-5.5", + provider=provider, + handoffs=[destination], + model_settings={ + "extra_headers": { + "X-Test-Profile": "fixture-source", + "X-Test-Route": "fixture-source-only", + } + }, + ) + async with source.session() as session: + result = await (await session.submit("Transfer.")).get_result() + assert result.final_output == "Done." + assert await session.get_active_agent() is destination + + assert [{key.lower(): value for key, value in (row or {}).items()} for row in observed] == [ + {"x-test-profile": "fixture-source", "x-test-route": "fixture-source-only"}, + {"x-test-profile": "fixture-destination"}, + ] diff --git a/packages/codex/tests/test_native_openai_retry_advice.py b/packages/codex/tests/test_native_openai_retry_advice.py index 27e5be2e33..1b7e143cb8 100644 --- a/packages/codex/tests/test_native_openai_retry_advice.py +++ b/packages/codex/tests/test_native_openai_retry_advice.py @@ -10,7 +10,9 @@ from agents import ( Agent, + AnyLLMModel, ChatCompletionsModel, + LitellmModel, ModelRetrySettings, NativeProvider, ResponsesModel, @@ -118,8 +120,8 @@ async def handle(request): @pytest.mark.asyncio -@pytest.mark.parametrize("kind", ["responses", "chat"]) -async def test_borrowed_openai_http_date_advice(kind): +@pytest.mark.parametrize("kind", ["responses", "chat", "litellm", "any_llm"]) +async def test_borrowed_provider_http_date_advice(kind): attempts = [] captured = [] @@ -154,7 +156,21 @@ def policy(context): http_client=DefaultAsyncHttpxClient(trust_env=False), ) as client, ): - adapter = ResponsesModel(client) if kind == "responses" else ChatCompletionsModel(client) + if kind in ("litellm", "any_llm"): + + class BorrowedClient: + async def acompletion(self, **kwargs): + return await client.chat.completions.create(**kwargs) + + adapter = ( + LitellmModel(BorrowedClient()) + if kind == "litellm" + else AnyLLMModel(BorrowedClient()) + ) + else: + adapter = ( + ResponsesModel(client) if kind == "responses" else ChatCompletionsModel(client) + ) async with NativeProvider(model_backend=adapter) as provider: agent = Agent( model="gpt-5.5", @@ -166,4 +182,5 @@ def policy(context): await agent.run("Reply.") assert len(attempts) == 1 and len(captured) == 1 assert captured[0].suggested is None + assert captured[0].retry_after_ms is not None assert 100_000 < captured[0].retry_after_ms <= 120_000 From 60f85d70e58786a9db1636fc0b1c7c43902ed6ff Mon Sep 17 00:00:00 2001 From: markstuart-oai <323302876+markstuart-oai@users.noreply.github.com> Date: Sat, 14 Nov 2026 16:38:32 +0000 Subject: [PATCH 02/11] Qualify the PyPy wheel on same-repository pull requests --- .github/workflows/codex-python-pypy-qualify.yml | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/.github/workflows/codex-python-pypy-qualify.yml b/.github/workflows/codex-python-pypy-qualify.yml index cbbc330e0d..b7bdabc82b 100644 --- a/.github/workflows/codex-python-pypy-qualify.yml +++ b/.github/workflows/codex-python-pypy-qualify.yml @@ -4,6 +4,8 @@ on: push: branches: [feat/codex-harness] paths: [.github/workflows/codex-python-pypy-qualify.yml] + pull_request: + paths: [.github/workflows/codex-python-pypy-qualify.yml] workflow_dispatch: permissions: @@ -13,7 +15,9 @@ jobs: pypy311-linux-x64: if: >- github.repository == 'openai/openai-agents-python' && - github.ref == 'refs/heads/feat/codex-harness' + (github.ref == 'refs/heads/feat/codex-harness' || + (github.event_name == 'pull_request' && + github.event.pull_request.head.repo.full_name == github.repository)) runs-on: ubuntu-24.04 timeout-minutes: 180 defaults: @@ -30,7 +34,7 @@ jobs: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 with: persist-credentials: false - ref: ${{ github.sha }} + ref: ${{ github.event.pull_request.head.sha || github.sha }} - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 with: python-version: pypy3.11-v8.0.1 From 6cface835f3f40fc74ee2c54b9baaf6a97190f97 Mon Sep 17 00:00:00 2001 From: markstuart-oai <323302876+markstuart-oai@users.noreply.github.com> Date: Sat, 14 Nov 2026 16:39:39 +0000 Subject: [PATCH 03/11] Format provider qualification tests --- packages/codex/tests/test_native_anyllm_reasoning_shapes.py | 5 ++--- .../codex/tests/test_native_chat_response_start_policy.py | 2 +- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/packages/codex/tests/test_native_anyllm_reasoning_shapes.py b/packages/codex/tests/test_native_anyllm_reasoning_shapes.py index 4623daf4da..86dd19e1b3 100644 --- a/packages/codex/tests/test_native_anyllm_reasoning_shapes.py +++ b/packages/codex/tests/test_native_anyllm_reasoning_shapes.py @@ -97,9 +97,8 @@ def test_anyllm_invalid_nesting_releases_provider_payload_from_traceback(contain while traceback is not None: frame = traceback.tb_frame if Path(frame.f_code.co_filename).name == "_model_provider_metadata.py": - assert ( - not {"message", "reasoning", "value", "part", "parts", "text"} - & set(frame.f_locals) + assert not {"message", "reasoning", "value", "part", "parts", "text"} & set( + frame.f_locals ) assert "synthetic-private-reasoning-canary" not in repr(frame.f_locals) traceback = traceback.tb_next diff --git a/packages/codex/tests/test_native_chat_response_start_policy.py b/packages/codex/tests/test_native_chat_response_start_policy.py index 97c2e4283b..d0f3f8d448 100644 --- a/packages/codex/tests/test_native_chat_response_start_policy.py +++ b/packages/codex/tests/test_native_chat_response_start_policy.py @@ -8,7 +8,6 @@ from aiohttp import web from aiohttp.test_utils import TestServer from openai import AsyncOpenAI, DefaultAsyncHttpxClient -from tests._asyncio import timeout from agents import ( Agent, @@ -19,6 +18,7 @@ RetryDecision, SessionState, ) +from tests._asyncio import timeout @pytest.mark.asyncio From e6909a1950a39199995a45a9c74fdadff47796a2 Mon Sep 17 00:00:00 2001 From: markstuart-oai <323302876+markstuart-oai@users.noreply.github.com> Date: Sat, 14 Nov 2026 16:47:54 +0000 Subject: [PATCH 04/11] Clear private AnyLLM request data on rejected retry takeover --- packages/codex/src/_agents_codex/models.py | 52 ++++++++++--------- .../test_native_borrowed_retry_takeover.py | 16 +++++- 2 files changed, 43 insertions(+), 25 deletions(-) diff --git a/packages/codex/src/_agents_codex/models.py b/packages/codex/src/_agents_codex/models.py index ecd0af3398..681fde7643 100644 --- a/packages/codex/src/_agents_codex/models.py +++ b/packages/codex/src/_agents_codex/models.py @@ -1772,32 +1772,36 @@ async def _create(self, request: ModelRequest, **options: Any) -> Any: def _anyllm_provider_for_attempt(provider: Any, request: ModelRequest) -> Any: - if not request.disable_provider_retries: - return provider + any_llm = provider_class = client = replay_provider = replay_client = None + try: + if not request.disable_provider_retries: + return provider - from openai import AsyncOpenAI + from openai import AsyncOpenAI - any_llm = sys.modules.get("any_llm") - provider_class = getattr(any_llm, "AnyLLM", None) - client = getattr(provider, "client", None) - if ( - not isinstance(provider_class, type) - or not isinstance(provider, provider_class) - or not isinstance(client, AsyncOpenAI) - ): - raise TypeError("AnyLLMModel cannot suppress borrowed client retries per request") - if client.max_retries == 0: - return provider - - replay_provider = copy(cast(Any, provider)) - if replay_provider is provider: - raise TypeError("AnyLLMModel cannot suppress borrowed client retries per request") - replay_client = client.with_options(max_retries=0) - if replay_client.max_retries != 0: - raise TypeError("AnyLLMModel cannot suppress borrowed client retries per request") - # The replay client borrows the same HTTP transport. The application closes it. - replay_provider.client = replay_client - return replay_provider + any_llm = sys.modules.get("any_llm") + provider_class = getattr(any_llm, "AnyLLM", None) + client = getattr(provider, "client", None) + if ( + not isinstance(provider_class, type) + or not isinstance(provider, provider_class) + or not isinstance(client, AsyncOpenAI) + ): + raise TypeError("AnyLLMModel cannot suppress borrowed client retries per request") + if client.max_retries == 0: + return provider + + replay_provider = copy(cast(Any, provider)) + if replay_provider is provider: + raise TypeError("AnyLLMModel cannot suppress borrowed client retries per request") + replay_client = client.with_options(max_retries=0) + if replay_client.max_retries != 0: + raise TypeError("AnyLLMModel cannot suppress borrowed client retries per request") + # The replay client borrows the same HTTP transport. The application closes it. + replay_provider.client = replay_client + return replay_provider + finally: + del request, provider, any_llm, provider_class, client, replay_provider, replay_client def _anyllm_responses_streaming_supported(client: Any) -> bool: diff --git a/packages/codex/tests/test_native_borrowed_retry_takeover.py b/packages/codex/tests/test_native_borrowed_retry_takeover.py index 601719ec52..32f2de80f9 100644 --- a/packages/codex/tests/test_native_borrowed_retry_takeover.py +++ b/packages/codex/tests/test_native_borrowed_retry_takeover.py @@ -121,9 +121,23 @@ async def acompletion(self, **kwargs): turn_id="turn", disable_provider_retries=True, ) - with pytest.raises(TypeError, match="cannot suppress borrowed client retries"): + object.__setattr__( + request, "_request_transport", {"headers": {"x-test-private": "owned-request-canary"}} + ) + with pytest.raises(TypeError, match="cannot suppress borrowed client retries") as failure: await adapter.complete(request) + traceback = failure.value.__traceback__ + while traceback is not None: + frame = traceback.tb_frame + if frame.f_code.co_name == "_anyllm_provider_for_attempt": + assert ( + not {"request", "provider", "client", "replay_provider", "replay_client"} + & frame.f_locals.keys() + ) + assert "owned-request-canary" not in repr(frame.f_locals) + traceback = traceback.tb_next + async def test_litellm_native_retry_preserves_first_provider_retry_only(monkeypatch): monkeypatch.setenv("LITELLM_LOCAL_MODEL_COST_MAP", "True") From e12a977de1be56e14dba27b58816852d6569033a Mon Sep 17 00:00:00 2001 From: markstuart-oai <323302876+markstuart-oai@users.noreply.github.com> Date: Sat, 14 Nov 2026 16:48:21 +0000 Subject: [PATCH 05/11] Compare captured traceback local names as a set --- packages/codex/tests/test_native_borrowed_retry_takeover.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/packages/codex/tests/test_native_borrowed_retry_takeover.py b/packages/codex/tests/test_native_borrowed_retry_takeover.py index 32f2de80f9..57811305cd 100644 --- a/packages/codex/tests/test_native_borrowed_retry_takeover.py +++ b/packages/codex/tests/test_native_borrowed_retry_takeover.py @@ -131,9 +131,8 @@ async def acompletion(self, **kwargs): while traceback is not None: frame = traceback.tb_frame if frame.f_code.co_name == "_anyllm_provider_for_attempt": - assert ( - not {"request", "provider", "client", "replay_provider", "replay_client"} - & frame.f_locals.keys() + assert not {"request", "provider", "client", "replay_provider", "replay_client"} & set( + frame.f_locals ) assert "owned-request-canary" not in repr(frame.f_locals) traceback = traceback.tb_next From 387dc614b6d3f0d34ca9a6de67fb9da992d2dd25 Mon Sep 17 00:00:00 2001 From: markstuart-oai <323302876+markstuart-oai@users.noreply.github.com> Date: Sat, 14 Nov 2026 17:27:02 +0000 Subject: [PATCH 06/11] Use an absolute output path for PyPy wheel receipts --- .github/workflows/codex-python-pypy-qualify.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/codex-python-pypy-qualify.yml b/.github/workflows/codex-python-pypy-qualify.yml index b7bdabc82b..544c058768 100644 --- a/.github/workflows/codex-python-pypy-qualify.yml +++ b/.github/workflows/codex-python-pypy-qualify.yml @@ -83,7 +83,7 @@ jobs: assert sys.implementation.name == 'pypy' assert sys.version_info[:3] == (3, 11, 17) PYTHON - env -u OPENAI_AGENTS_NATIVE_WHEEL .venv/bin/python -m hatchling build --target wheel --directory dist + env -u OPENAI_AGENTS_NATIVE_WHEEL .venv/bin/python -m hatchling build --target wheel --directory "$GITHUB_WORKSPACE/dist" .venv/bin/python -I - <<'PYTHON' import hashlib import json From 14b9f288ed22b773447556935cb9651bf487bf09 Mon Sep 17 00:00:00 2001 From: markstuart-oai <323302876+markstuart-oai@users.noreply.github.com> Date: Sat, 14 Nov 2026 09:52:51 -0800 Subject: [PATCH 07/11] Keep the reviewed API snapshot in sync with provider internals --- packages/codex/tests/fixtures/released_api_contract.json | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/packages/codex/tests/fixtures/released_api_contract.json b/packages/codex/tests/fixtures/released_api_contract.json index 5006bf7d84..48d6c8db96 100644 --- a/packages/codex/tests/fixtures/released_api_contract.json +++ b/packages/codex/tests/fixtures/released_api_contract.json @@ -923,11 +923,10 @@ "class NativeModel(Protocol):\n\n def complete(self, request: ModelRequest) -> ModelResponse | Awaitable[ModelResponse]:\n pass", "class NativeStreamingModel(NativeModel, Protocol):\n\n def stream(self, request: ModelRequest) -> AsyncIterator[Mapping[str, Any]] | Awaitable[AsyncIterator[Mapping[str, Any]]]:\n pass", "class ModelProvider(Protocol):\n\n def get_model(self, model_name: str) -> NativeModel:\n pass", - "@dataclass(frozen=True, init=False)\nclass ChatCompletionsModel:\n client: Any = field(repr=False)\n model: str | None = None\n prompt_cache_key: str | None = field(default=None, repr=False, kw_only=True)\n request_options: ModelRequestOptions | ModelRequestOptionsFactory | None = field(default=None, repr=False, kw_only=True)\n _request_options_source: ModelRequestOptions | ModelRequestOptionsFactory | None = field(default=None, init=False, repr=False, compare=False)\n _stream_enabled: bool = field(default=False, init=False, repr=False)\n _include_usage: bool = field(default=True, init=False, repr=False)\n\n def __init__(self, client: Any, model: str | None=None, *, prompt_cache_key: str | None=None, request_options: ModelRequestOptions | ModelRequestOptionsFactory | None=None, stream: bool=False, include_usage: bool=True) -> None:\n pass\n\n @property\n def stream(self) -> Callable[[ModelRequest], AsyncIterator[Mapping[str, Any]]] | None:\n pass\n\n async def complete(self, request: ModelRequest) -> ModelResponse:\n pass\n\n def get_retry_advice(self, request: ModelRetryAdviceRequest) -> RetryAdvice | None:\n pass", - "@dataclass(frozen=True, init=False)\nclass LitellmModel(ChatCompletionsModel):\n\n def get_retry_advice(self, request: ModelRetryAdviceRequest) -> RetryAdvice | None:\n pass", - "@dataclass(frozen=True, init=False)\nclass AnyLLMModel(ChatCompletionsModel):\n _responses: _AnyLLMResponsesModel | None = field(default=None, init=False, repr=False)\n\n def __init__(self, client: Any, model: str | None=None, *, prompt_cache_key: str | None=None, request_options: ModelRequestOptions | ModelRequestOptionsFactory | None=None, stream: bool=False, include_usage: bool=True, api: Literal['chat_completions', 'responses', 'auto']='chat_completions') -> None:\n pass\n\n @property\n def stream(self) -> Callable[[ModelRequest], AsyncIterator[Mapping[str, Any]]] | None:\n pass\n\n async def complete(self, request: ModelRequest) -> ModelResponse:\n pass\n\n def get_retry_advice(self, request: ModelRetryAdviceRequest) -> RetryAdvice | None:\n pass", - "@dataclass(frozen=True, init=False)\nclass ResponsesModel:\n client: Any = field(repr=False)\n model: str | None = None\n prompt_cache_key: str | None = field(default=None, repr=False, kw_only=True)\n request_options: ModelRequestOptions | ModelRequestOptionsFactory | None = field(default=None, repr=False, kw_only=True)\n _request_options_source: ModelRequestOptions | ModelRequestOptionsFactory | None = field(default=None, init=False, repr=False, compare=False)\n _stream_enabled: bool = field(default=False, init=False, repr=False)\n\n def __init__(self, client: Any, model: str | None=None, *, prompt_cache_key: str | None=None, request_options: ModelRequestOptions | ModelRequestOptionsFactory | None=None, stream: bool=False) -> None:\n pass\n\n def get_retry_advice(self, request: ModelRetryAdviceRequest) -> RetryAdvice | None:\n pass\n\n @property\n def stream(self) -> Callable[[ModelRequest], AsyncIterator[Mapping[str, Any]]] | None:\n pass\n\n async def complete(self, request: ModelRequest) -> ModelResponse:\n pass", - "class _AnyLLMResponsesModel(ResponsesModel):\n pass" + "@dataclass(frozen=True, init=False)\nclass ChatCompletionsModel:\n client: Any = field(repr=False)\n model: str | None = None\n prompt_cache_key: str | None = field(default=None, repr=False, kw_only=True)\n request_options: ModelRequestOptions | ModelRequestOptionsFactory | None = field(default=None, repr=False, kw_only=True)\n _request_options_source: ModelRequestOptions | ModelRequestOptionsFactory | None = field(default=None, init=False, repr=False, compare=False)\n _stream_enabled: bool = field(default=False, init=False, repr=False)\n _include_usage: bool = field(default=True, init=False, repr=False)\n _structured_tool_output: ClassVar[bool] = False\n\n def __init__(self, client: Any, model: str | None=None, *, prompt_cache_key: str | None=None, request_options: ModelRequestOptions | ModelRequestOptionsFactory | None=None, stream: bool=False, include_usage: bool=True) -> None:\n pass\n\n @property\n def stream(self) -> Callable[[ModelRequest], AsyncIterator[Mapping[str, Any]]] | None:\n pass\n\n async def complete(self, request: ModelRequest) -> ModelResponse:\n pass\n\n def get_retry_advice(self, request: ModelRetryAdviceRequest) -> RetryAdvice | None:\n pass", + "@dataclass(frozen=True, init=False)\nclass LitellmModel(ChatCompletionsModel):\n _structured_tool_output: ClassVar[bool] = True\n\n def get_retry_advice(self, request: ModelRetryAdviceRequest) -> RetryAdvice | None:\n pass", + "@dataclass(frozen=True, init=False)\nclass AnyLLMModel(ChatCompletionsModel):\n _structured_tool_output: ClassVar[bool] = True\n _responses: ResponsesModel | None = field(default=None, init=False, repr=False)\n\n def __init__(self, client: Any, model: str | None=None, *, prompt_cache_key: str | None=None, request_options: ModelRequestOptions | ModelRequestOptionsFactory | None=None, stream: bool=False, include_usage: bool=True, api: Literal['chat_completions', 'responses', 'auto']='chat_completions') -> None:\n pass\n\n @property\n def stream(self) -> Callable[[ModelRequest], AsyncIterator[Mapping[str, Any]]] | None:\n pass\n\n async def complete(self, request: ModelRequest) -> ModelResponse:\n pass\n\n def get_retry_advice(self, request: ModelRetryAdviceRequest) -> RetryAdvice | None:\n pass", + "@dataclass(frozen=True, init=False)\nclass ResponsesModel:\n client: Any = field(repr=False)\n model: str | None = None\n prompt_cache_key: str | None = field(default=None, repr=False, kw_only=True)\n request_options: ModelRequestOptions | ModelRequestOptionsFactory | None = field(default=None, repr=False, kw_only=True)\n _request_options_source: ModelRequestOptions | ModelRequestOptionsFactory | None = field(default=None, init=False, repr=False, compare=False)\n _stream_enabled: bool = field(default=False, init=False, repr=False)\n\n def __init__(self, client: Any, model: str | None=None, *, prompt_cache_key: str | None=None, request_options: ModelRequestOptions | ModelRequestOptionsFactory | None=None, stream: bool=False) -> None:\n pass\n\n def get_retry_advice(self, request: ModelRetryAdviceRequest) -> RetryAdvice | None:\n pass\n\n @property\n def stream(self) -> Callable[[ModelRequest], AsyncIterator[Mapping[str, Any]]] | None:\n pass\n\n async def complete(self, request: ModelRequest) -> ModelResponse:\n pass" ], "exports": { "AnyLLMModel": "agents.models.AnyLLMModel", From 878f4c9e67653f875148ead7730b287a07816b4f Mon Sep 17 00:00:00 2001 From: markstuart-oai <323302876+markstuart-oai@users.noreply.github.com> Date: Sat, 14 Nov 2026 18:02:34 +0000 Subject: [PATCH 08/11] Preserve the unfinished checkpoint when retrying staged input --- packages/codex/src/_agents_codex/session.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/packages/codex/src/_agents_codex/session.py b/packages/codex/src/_agents_codex/session.py index 2c43967cc3..dd25891859 100644 --- a/packages/codex/src/_agents_codex/session.py +++ b/packages/codex/src/_agents_codex/session.py @@ -21837,6 +21837,20 @@ async def _capture_checkpoint( raise NativeError("Staged retry does not match its original checkpoint") if payload["source_session_id"] != saved.source_session_id: raise NativeError("Staged retry changed its native source session") + if self._provider_history is None: + # Ordinary staged retry retains its unfinished source history. + # Only occurrence-projected retries need newly accepted history. + return saved.model_copy( + update={ + "native_continuation": continuation, + "remembered_approvals": self._current_remembered_approvals(), + "remembered_mcp_approvals": remembered_mcp, + "application_tool_outputs": [ + record.model_copy(deep=True) + for record in self._application_tool_outputs + ], + } + ).to_json() # Preserve the operation's SDK envelope, but capture current # canonical data. A terminal response can accept only some # staged originals before a later observer rejects it. From 00d9f7e867f861e0e11bb16a20dd66c43c6fafdf Mon Sep 17 00:00:00 2001 From: markstuart-oai <323302876+markstuart-oai@users.noreply.github.com> Date: Sat, 14 Nov 2026 18:09:07 +0000 Subject: [PATCH 09/11] Keep the provider span ownership test aligned with model metadata --- packages/codex/tests/test_native_provider_response_span_ids.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/packages/codex/tests/test_native_provider_response_span_ids.py b/packages/codex/tests/test_native_provider_response_span_ids.py index 31e9b6652a..80d6813184 100644 --- a/packages/codex/tests/test_native_provider_response_span_ids.py +++ b/packages/codex/tests/test_native_provider_response_span_ids.py @@ -36,10 +36,11 @@ async def test_host_response_id_admission_uses_exact_owner(monkeypatch, outcome) loop = asyncio.get_running_loop() problem = ValueError("Tracing ID generator returned an invalid identifier") - def policy(_context): + def policy(_context, *, model): nonlocal revoked # A worker-thread call or an extra callback execution path fails here. assert asyncio.get_running_loop() is loop + assert model is None entered.append(True) if outcome == "invalid": raise problem From 7a4686c9f50f49fcd245e69003bbfffed3eb07d4 Mon Sep 17 00:00:00 2001 From: markstuart-oai <323302876+markstuart-oai@users.noreply.github.com> Date: Sat, 14 Nov 2026 18:33:00 +0000 Subject: [PATCH 10/11] Match inspected Docker mounts by destination --- .../codex/tests/test_native_docker_path_authority.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/packages/codex/tests/test_native_docker_path_authority.py b/packages/codex/tests/test_native_docker_path_authority.py index 748bf6fe65..4d9fd1305d 100644 --- a/packages/codex/tests/test_native_docker_path_authority.py +++ b/packages/codex/tests/test_native_docker_path_authority.py @@ -37,12 +37,14 @@ async def create(self, **options): assert inspection["HostConfig"]["NetworkMode"] == "none" assert not inspection["HostConfig"]["Privileged"] assert not inspection["HostConfig"].get("CapAdd") - for grant, mount in zip( - resource.state.manifest.extra_path_grants, inspection["Mounts"], strict=True - ): + grants = resource.state.manifest.extra_path_grants + mounts = {mount["Destination"]: mount for mount in inspection["Mounts"]} + assert len(mounts) == len(inspection["Mounts"]) + assert set(mounts) == {grant.path for grant in grants} + for grant in grants: + mount = mounts[grant.path] assert mount["Type"] == "bind" assert mount["Source"] == grant.host_path - assert mount["Destination"] == grant.path assert mount["RW"] == (not grant.read_only) archive = await run_blocking_workspace_io(fixture_archive) await run_blocking_workspace_io( From 96c821befb0c1bcbaa3c52763d08e80d0b095893 Mon Sep 17 00:00:00 2001 From: markstuart-oai <323302876+markstuart-oai@users.noreply.github.com> Date: Sat, 14 Nov 2026 19:02:49 +0000 Subject: [PATCH 11/11] Assert the native checkpoint's Docker policy rejection --- packages/codex/tests/test_native_docker_path_authority.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/packages/codex/tests/test_native_docker_path_authority.py b/packages/codex/tests/test_native_docker_path_authority.py index 4d9fd1305d..2f60cba6de 100644 --- a/packages/codex/tests/test_native_docker_path_authority.py +++ b/packages/codex/tests/test_native_docker_path_authority.py @@ -129,7 +129,9 @@ def respond(label): async with agent.session(state=saved, environment=source()) as session: result = await (await session.submit("Inspect after reopening.")).get_result() assert result.final_output == "restored" - with pytest.raises(RuntimeError, match="recorded Agent environment grants"): + with pytest.raises( + ValueError, match="Checkpoint and Environment must agree on the applied executor policy" + ): async with agent.session(state=saved, environment=source(writable=False)): pytest.fail("A weaker current grant cannot reopen the recorded executor authority") assert len(responses.requests) == 4