openai-agents-python/tests/models/test_model_retry.py
Kazuhiro Sera 6e6707cdcf
fix: preserve usage from failed and incomplete Responses calls (#6046)
Preserve usage from failed and incomplete Responses calls
2026-11-16 22:46:54 +00:00

3908 lines
118 KiB
Python

from __future__ import annotations
import asyncio
from collections.abc import AsyncIterator
from contextvars import ContextVar
from typing import Any, cast
import httpx2
import pytest
from openai import APIConnectionError, APIStatusError, AsyncOpenAI, BadRequestError
from openai.types.responses import ResponseFunctionCallArgumentsDeltaEvent, ResponseTextDeltaEvent
from pydantic import ValidationError
from agents import Agent, RunConfig, Runner
from agents.exceptions import ModelBehaviorError, ModelTimeoutError
from agents.items import ModelResponse, TResponseStreamEvent
from agents.model_settings import ModelSettings
from agents.models._openai_retry import get_openai_retry_advice
from agents.models._retry_runtime import (
should_disable_provider_managed_retries,
should_disable_websocket_pre_event_retries,
)
from agents.models.openai_responses import OpenAIResponsesModel, OpenAIResponsesWSModel
from agents.retry import (
ModelRetryAdvice,
ModelRetryAdviceRequest,
ModelRetryBackoffSettings,
ModelRetryNormalizedError,
ModelRetrySettings,
RetryDecision,
RetryPolicyContext,
retry_policies,
retry_policy_retries_all_transient_errors,
retry_policy_retries_safe_transport_errors,
)
from agents.run_internal.model_retry import get_response_with_retry, stream_response_with_retry
from agents.testing import ModelCall, ModelStep, ScriptedModel
from agents.usage import Usage
from tests.model_test_helpers import get_response_obj
from tests.test_responses import get_text_message
@pytest.mark.parametrize(
"make_backoff",
[
lambda: ModelRetryBackoffSettings(initial_delay=-0.1),
lambda: ModelRetryBackoffSettings(max_delay=-0.1),
lambda: ModelRetryBackoffSettings(multiplier=-0.1),
],
)
def test_model_retry_backoff_settings_reject_negative_values(make_backoff: Any) -> None:
with pytest.raises(ValidationError, match="greater than or equal to 0"):
make_backoff()
def test_model_retry_settings_rejects_negative_backoff_dict() -> None:
with pytest.raises(ValidationError, match="greater than or equal to 0"):
ModelRetrySettings(backoff={"initial_delay": -0.1})
def test_model_retry_backoff_settings_allow_zero_values() -> None:
backoff = ModelRetryBackoffSettings(initial_delay=0, max_delay=0, multiplier=0)
assert backoff.initial_delay == 0
assert backoff.max_delay == 0
assert backoff.multiplier == 0
@pytest.mark.parametrize("timeout", [0, -0.1, float("inf"), float("nan")])
def test_model_settings_rejects_invalid_model_call_timeout(timeout: float) -> None:
with pytest.raises(ValidationError):
ModelSettings(timeout=timeout)
def test_model_settings_accepts_finite_model_call_timeout() -> None:
settings = ModelSettings(timeout=1.25)
assert settings.timeout == 1.25
assert settings.to_traceable_dict()["timeout"] == 1.25
def test_retry_capabilities_preserve_falsey_policy() -> None:
class FalseyPolicy:
_openai_agents_retries_safe_transport_errors: bool
_openai_agents_retries_all_transient_errors: bool
def __bool__(self) -> bool:
return False
def __call__(self, _context: RetryPolicyContext) -> bool:
return False
policy = FalseyPolicy()
policy._openai_agents_retries_safe_transport_errors = True
policy._openai_agents_retries_all_transient_errors = True
assert retry_policy_retries_safe_transport_errors(policy) is True
assert retry_policy_retries_all_transient_errors(policy) is True
def _connection_error(message: str = "connection error") -> APIConnectionError:
return APIConnectionError(
message=message,
request=httpx2.Request("POST", "https://example.com"),
)
def _conversation_locked_error() -> BadRequestError:
request = httpx2.Request("POST", "https://example.com")
response = httpx2.Response(
400,
request=request,
json={"error": {"code": "conversation_locked", "message": "locked"}},
)
error = BadRequestError(
"locked",
response=response,
body={"error": {"code": "conversation_locked"}},
)
error.code = "conversation_locked"
return error
def _status_error(status_code: int, code: str = "server_error") -> APIStatusError:
request = httpx2.Request("POST", "https://example.com")
response = httpx2.Response(
status_code,
request=request,
json={"error": {"code": code, "message": code}},
)
error = APIStatusError(
code,
response=response,
body={"error": {"code": code, "message": code}},
)
error.code = code
return error
def _status_error_without_code(status_code: int, body_code: str = "server_error") -> APIStatusError:
request = httpx2.Request("POST", "https://example.com")
response = httpx2.Response(
status_code,
request=request,
json={"error": {"code": body_code, "message": body_code}},
)
return APIStatusError(
body_code,
response=response,
body={"error": {"code": body_code, "message": body_code}},
)
@pytest.mark.asyncio
async def test_get_response_with_retry_times_out_and_retries_stateless_attempt() -> None:
calls = 0
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
await asyncio.Event().wait()
return ModelResponse(output=[get_text_message("ok")], usage=Usage(), response_id="resp")
result = await get_response_with_retry(
get_response=get_response,
rewind=lambda: asyncio.sleep(0),
retry_settings=ModelRetrySettings(
max_retries=1,
backoff={"initial_delay": 0},
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=0.01,
)
assert calls == 2
assert result.response_id == "resp"
@pytest.mark.asyncio
async def test_get_response_with_retry_blocks_unsafe_stateful_timeout_replay() -> None:
calls = 0
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
await asyncio.Event().wait()
raise AssertionError("unreachable")
with pytest.raises(ModelTimeoutError, match="timed out after 0.01 seconds"):
await get_response_with_retry(
get_response=get_response,
rewind=lambda: asyncio.sleep(0),
retry_settings=ModelRetrySettings(
max_retries=1,
backoff={"initial_delay": 0},
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id="conv_123",
timeout=0.01,
)
assert calls == 1
@pytest.mark.asyncio
async def test_model_timeout_discards_cleanup_exception_graph() -> None:
sensitive_payload = "sensitive provider payload"
async def get_response() -> ModelResponse:
try:
await asyncio.Event().wait()
except asyncio.CancelledError as exc:
raise RuntimeError(sensitive_payload) from exc
raise AssertionError("unreachable")
with pytest.raises(ModelTimeoutError) as exc_info:
await get_response_with_retry(
get_response=get_response,
rewind=lambda: asyncio.sleep(0),
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=0.01,
)
assert exc_info.value.__cause__ is None
assert exc_info.value.__context__ is None
assert sensitive_payload not in repr(exc_info.value)
traceback = exc_info.value.__traceback__
while traceback is not None:
if traceback.tb_frame.f_code.co_name == "_await_model_attempt":
frame_locals = traceback.tb_frame.f_locals
assert "awaitable" not in frame_locals
assert "task" not in frame_locals
assert "done" not in frame_locals
assert "pending" not in frame_locals
traceback = traceback.tb_next
@pytest.mark.asyncio
async def test_stream_timeout_discards_owner_task_from_traceback_locals() -> None:
sensitive_payload = "sensitive stream cleanup payload"
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
try:
await asyncio.Event().wait()
finally:
raise RuntimeError(sensitive_payload)
yield cast(TResponseStreamEvent, {"type": "response.created"})
return iterator()
with pytest.raises(ModelTimeoutError) as exc_info:
async for _event in stream_response_with_retry(
get_stream=get_stream,
rewind=lambda: asyncio.sleep(0),
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=0.01,
):
pass
assert exc_info.value.__cause__ is None
assert exc_info.value.__context__ is None
traceback = exc_info.value.__traceback__
while traceback is not None:
if traceback.tb_frame.f_code.co_name == "stream_response_with_retry":
frame_locals = traceback.tb_frame.f_locals
assert frame_locals.get("stream_owner") is None
assert frame_locals.get("stream_requests") is None
assert frame_locals.get("stream_results") is None
traceback = traceback.tb_next
@pytest.mark.asyncio
@pytest.mark.parametrize("payload_kind", ["text", "tool_arguments"])
async def test_stream_timeout_discards_previous_event_from_retry_traceback(
payload_kind: str,
) -> None:
sensitive_payload = "synthetic-sensitive-stream-payload"
event: TResponseStreamEvent
if payload_kind == "text":
event = ResponseTextDeltaEvent(
type="response.output_text.delta",
delta=sensitive_payload,
content_index=0,
output_index=0,
item_id="synthetic-item",
sequence_number=0,
logprobs=[],
)
else:
event = ResponseFunctionCallArgumentsDeltaEvent(
type="response.function_call_arguments.delta",
delta=sensitive_payload,
output_index=0,
item_id="synthetic-item",
sequence_number=0,
)
closed = asyncio.Event()
async def stream_events(_call: ModelCall) -> AsyncIterator[TResponseStreamEvent]:
try:
yield event
await asyncio.Event().wait()
finally:
closed.set()
model = ScriptedModel([ModelStep.stream(stream_events)])
result = Runner.run_streamed(
Agent(name="test", model=model, model_settings=ModelSettings(timeout=0.05)),
"synthetic-input",
run_config=RunConfig(trace_include_sensitive_data=False),
)
delivered = []
with pytest.raises(ModelTimeoutError) as exc_info:
async for stream_event in result.stream_events():
if stream_event.type == "raw_response_event":
delivered.append(stream_event.data)
assert delivered == [event]
assert event.delta == sensitive_payload
assert closed.is_set()
assert exc_info.value.timeout_seconds == 0.05
assert exc_info.value.__cause__ is None
assert exc_info.value.__context__ is None
retry_frames = []
traceback = exc_info.value.__traceback__
while traceback is not None:
if traceback.tb_frame.f_code is stream_response_with_retry.__code__:
retry_frames.append(traceback.tb_frame)
traceback = traceback.tb_next
assert retry_frames
for frame in retry_frames:
# Only the retry wrapper's aliases are covered, not caller-owned run state.
assert frame.f_locals.get("event") is None
assert frame.f_locals.get("result_value") is None
assert frame.f_locals.get("stream_owner") is None
assert frame.f_locals.get("stream_results") is None
@pytest.mark.asyncio
async def test_model_timeout_cancels_blocked_cleanup_after_deadline() -> None:
cleanup_started = asyncio.Event()
release_cleanup = asyncio.Event()
async def get_response() -> ModelResponse:
try:
await asyncio.Event().wait()
finally:
cleanup_started.set()
await release_cleanup.wait()
raise AssertionError("unreachable")
task = asyncio.create_task(
get_response_with_retry(
get_response=get_response,
rewind=lambda: asyncio.sleep(0),
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=0.01,
)
)
await cleanup_started.wait()
done, _ = await asyncio.wait({task}, timeout=0.2)
if task not in done:
release_cleanup.set()
await task
pytest.fail("Non-streaming timeout cleanup did not receive a second cancellation.")
with pytest.raises(ModelTimeoutError) as exc_info:
await task
assert exc_info.value.timeout_seconds == 0.01
@pytest.mark.asyncio
async def test_get_response_with_retry_preserves_parent_cancellation() -> None:
started = asyncio.Event()
async def get_response() -> ModelResponse:
started.set()
await asyncio.Event().wait()
raise AssertionError("unreachable")
task = asyncio.create_task(
get_response_with_retry(
get_response=get_response,
rewind=lambda: asyncio.sleep(0),
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=10,
)
)
await started.wait()
task.cancel()
with pytest.raises(asyncio.CancelledError):
await task
@pytest.mark.asyncio
async def test_get_response_with_retry_preserves_parent_cancellation_during_timeout_cleanup() -> (
None
):
cleanup_started = asyncio.Event()
release_cleanup = asyncio.Event()
async def get_response() -> ModelResponse:
try:
await asyncio.Event().wait()
except asyncio.CancelledError:
cleanup_started.set()
await release_cleanup.wait()
raise AssertionError("unreachable")
task = asyncio.create_task(
get_response_with_retry(
get_response=get_response,
rewind=lambda: asyncio.sleep(0),
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=0.01,
)
)
await cleanup_started.wait()
task.cancel()
release_cleanup.set()
with pytest.raises(asyncio.CancelledError):
await task
@pytest.mark.asyncio
async def test_get_response_with_retry_preserves_parent_cancellation_over_cleanup_error() -> None:
started = asyncio.Event()
async def get_response() -> ModelResponse:
started.set()
try:
await asyncio.Event().wait()
except asyncio.CancelledError as exc:
raise RuntimeError("cleanup failed") from exc
raise AssertionError("unreachable")
task = asyncio.create_task(
get_response_with_retry(
get_response=get_response,
rewind=lambda: asyncio.sleep(0),
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=10,
)
)
await started.wait()
task.cancel()
with pytest.raises(asyncio.CancelledError):
await task
@pytest.mark.asyncio
async def test_programmatic_request_disables_hidden_provider_retries() -> None:
provider_retry_flags: list[bool] = []
async def get_response() -> ModelResponse:
provider_retry_flags.append(should_disable_provider_managed_retries())
return ModelResponse(output=[get_text_message("ok")], usage=Usage(), response_id="resp")
result = await get_response_with_retry(
get_response=get_response,
rewind=lambda: asyncio.sleep(0),
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
replay_unsafe_request=True,
)
assert result.response_id == "resp"
assert provider_retry_flags == [True]
@pytest.mark.asyncio
async def test_programmatic_request_requires_replay_approval_for_runner_retry() -> None:
calls = 0
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise _connection_error()
with pytest.raises(APIConnectionError):
await get_response_with_retry(
get_response=get_response,
rewind=lambda: asyncio.sleep(0),
retry_settings=ModelRetrySettings(
max_retries=1,
backoff={"initial_delay": 0},
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
replay_unsafe_request=True,
)
assert calls == 1
def test_get_openai_retry_advice_returns_none_for_non_retryable_status() -> None:
advice = get_openai_retry_advice(
ModelRetryAdviceRequest(
error=_status_error(400, code="invalid_request_error"),
attempt=1,
stream=False,
)
)
assert advice is None
class _AcloseTrackingStream:
def __init__(
self,
events: list[TResponseStreamEvent] | None = None,
*,
error_before_yield: Exception | None = None,
) -> None:
self._events = list(events or [])
self._error_before_yield = error_before_yield
self.aclose_calls = 0
def __aiter__(self) -> _AcloseTrackingStream:
return self
async def __anext__(self) -> TResponseStreamEvent:
if self._error_before_yield is not None:
error = self._error_before_yield
self._error_before_yield = None
raise error
if self._events:
return self._events.pop(0)
raise StopAsyncIteration
async def aclose(self) -> None:
self.aclose_calls += 1
class _CloseTrackingStream:
def __init__(self, events: list[TResponseStreamEvent]) -> None:
self._events = list(events)
self.close_calls = 0
def __aiter__(self) -> _CloseTrackingStream:
return self
async def __anext__(self) -> TResponseStreamEvent:
if self._events:
return self._events.pop(0)
raise StopAsyncIteration
async def close(self) -> None:
self.close_calls += 1
@pytest.mark.asyncio
@pytest.mark.allow_call_model_methods
@pytest.mark.parametrize("retry_completes", [True, False], ids=["completed", "incomplete"])
async def test_runner_counts_usage_from_retried_incomplete_response(retry_completes: bool) -> None:
# A mock transport exercises Responses terminal decoding on each physical attempt.
first = get_response_obj([], usage=Usage(input_tokens=12, output_tokens=16, total_tokens=28))
first.status = "incomplete"
second = get_response_obj(
[get_text_message("ok")] if retry_completes else [],
usage=Usage(input_tokens=5, output_tokens=2, total_tokens=7),
)
second.status = "completed" if retry_completes else "incomplete"
responses = iter([first, second])
def handle(_request: httpx2.Request) -> httpx2.Response:
return httpx2.Response(200, json=next(responses).model_dump(mode="json"))
async with httpx2.AsyncClient(transport=httpx2.MockTransport(handle)) as http_client:
client = AsyncOpenAI(api_key="test", http_client=http_client)
agent = Agent(
name="test",
model=OpenAIResponsesModel("test-model", openai_client=client),
model_settings=ModelSettings(
retry=ModelRetrySettings(
max_retries=1,
policy=lambda _: True,
backoff=ModelRetryBackoffSettings(initial_delay=0),
)
),
)
if retry_completes:
result = await Runner.run(agent, "hi")
assert result.final_output == "ok"
usage = result.context_wrapper.usage
assert result.raw_responses[0].usage.requests == 2
else:
with pytest.raises(ModelBehaviorError, match="response.incomplete") as caught:
await Runner.run(agent, "hi")
assert caught.value.run_data is not None
usage = caught.value.run_data.context_wrapper.usage
assert usage.requests == 2
assert (usage.input_tokens, usage.output_tokens, usage.total_tokens) == (17, 18, 35)
assert [entry.total_tokens for entry in usage.request_usage_entries] == [28, 7]
@pytest.mark.asyncio
async def test_get_response_with_retry_retries_and_augments_usage(monkeypatch) -> None:
calls = 0
rewinds = 0
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
raise _connection_error()
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1),
response_id="resp_123",
)
result = await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(initial_delay=0.5, jitter=False),
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
assert calls == 2
assert rewinds == 1
assert sleeps == [0.5]
assert result.usage.requests == 2
@pytest.mark.asyncio
async def test_get_response_with_retry_keeps_provider_retries_on_first_attempt(
monkeypatch,
) -> None:
calls = 0
provider_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
return None
async def get_response() -> ModelResponse:
nonlocal calls
provider_retry_flags.append(should_disable_provider_managed_retries())
calls += 1
if calls == 1:
raise _connection_error()
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1),
response_id="resp_provider_retry_flag",
)
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
assert provider_retry_flags == [False, True]
@pytest.mark.asyncio
async def test_get_response_with_retry_disables_provider_retries_on_first_stateful_provider_hint(
monkeypatch,
) -> None:
calls = 0
provider_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
return None
async def get_response() -> ModelResponse:
nonlocal calls
provider_retry_flags.append(should_disable_provider_managed_retries())
calls += 1
if calls == 1:
raise _connection_error()
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1),
response_id="resp_stateful_provider_retry_flag",
)
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.provider_suggested(),
),
get_retry_advice=lambda _request: ModelRetryAdvice(
suggested=True,
replay_safety="safe",
),
previous_response_id="resp_prev",
conversation_id=None,
)
assert provider_retry_flags == [True, True]
@pytest.mark.asyncio
async def test_get_response_with_retry_disables_stateful_provider_retries_with_narrow_policy(
monkeypatch,
) -> None:
calls = 0
provider_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
raise AssertionError("Unrelated policy should not trigger runner rewind")
async def get_response() -> ModelResponse:
nonlocal calls
provider_retry_flags.append(should_disable_provider_managed_retries())
calls += 1
raise _connection_error()
with pytest.raises(APIConnectionError):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.http_status([429]),
),
get_retry_advice=lambda _request: None,
previous_response_id="resp_prev",
conversation_id=None,
)
assert calls == 1
assert provider_retry_flags == [True]
@pytest.mark.asyncio
async def test_get_response_with_retry_keeps_stateful_provider_retries_when_budget_omitted(
monkeypatch,
) -> None:
calls = 0
provider_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
raise AssertionError("Omitted retry budget should not trigger runner rewind")
async def get_response() -> ModelResponse:
nonlocal calls
provider_retry_flags.append(should_disable_provider_managed_retries())
calls += 1
raise _connection_error()
with pytest.raises(APIConnectionError):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id="resp_prev",
conversation_id=None,
)
assert calls == 1
assert provider_retry_flags == [False]
@pytest.mark.asyncio
async def test_get_response_with_retry_disables_stateful_provider_retries_for_network_only_policy(
monkeypatch,
) -> None:
calls = 0
provider_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
raise AssertionError("Stateful requests should not leave hidden provider retries enabled")
async def get_response() -> ModelResponse:
nonlocal calls
provider_retry_flags.append(should_disable_provider_managed_retries())
calls += 1
raise _status_error(500)
with pytest.raises(APIStatusError):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id="resp_prev",
conversation_id=None,
)
assert calls == 1
assert provider_retry_flags == [True]
@pytest.mark.asyncio
async def test_get_response_with_retry_disables_stateful_provider_retries_for_partial_policy(
monkeypatch,
) -> None:
calls = 0
provider_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
raise AssertionError("Stateful requests should not leave hidden provider retries enabled")
async def get_response() -> ModelResponse:
nonlocal calls
provider_retry_flags.append(should_disable_provider_managed_retries())
calls += 1
raise _status_error(429, code="rate_limit_exceeded")
with pytest.raises(APIStatusError):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.any(
retry_policies.network_error(),
retry_policies.http_status([500]),
),
),
get_retry_advice=lambda _request: None,
previous_response_id="resp_prev",
conversation_id=None,
)
assert calls == 1
assert provider_retry_flags == [True]
@pytest.mark.asyncio
async def test_get_response_with_retry_disables_provider_retries_when_explicitly_disabled(
monkeypatch,
) -> None:
calls = 0
provider_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
return None
async def get_response() -> ModelResponse:
nonlocal calls
provider_retry_flags.append(should_disable_provider_managed_retries())
calls += 1
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1),
response_id="resp_provider_retry_preserved",
)
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=0,
policy=retry_policies.never(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
assert calls == 1
assert provider_retry_flags == [True]
@pytest.mark.asyncio
async def test_get_response_with_retry_keeps_provider_retries_without_runner_policy(
monkeypatch,
) -> None:
calls = 0
provider_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
return None
async def get_response() -> ModelResponse:
nonlocal calls
provider_retry_flags.append(should_disable_provider_managed_retries())
calls += 1
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1),
response_id="resp_provider_retry_without_policy",
)
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=2,
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
assert calls == 1
assert provider_retry_flags == [False]
@pytest.mark.asyncio
async def test_get_response_with_retry_preserves_successful_request_usage_entry(
monkeypatch,
) -> None:
calls = 0
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
return None
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
raise _connection_error()
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(
requests=1,
input_tokens=11,
output_tokens=7,
total_tokens=18,
),
response_id="resp_usage_entries",
)
result = await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(jitter=False),
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
assert result.usage.requests == 2
assert len(result.usage.request_usage_entries) == 2
assert result.usage.request_usage_entries[0].total_tokens == 0
assert result.usage.request_usage_entries[1].input_tokens == 11
assert result.usage.request_usage_entries[1].output_tokens == 7
assert result.usage.request_usage_entries[1].total_tokens == 18
@pytest.mark.asyncio
async def test_get_response_with_retry_preserves_zero_token_successful_request_usage_entry(
monkeypatch,
) -> None:
calls = 0
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
return None
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
raise _connection_error()
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1),
response_id="resp_zero_usage_entries",
)
result = await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(jitter=False),
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
assert result.usage.requests == 2
assert len(result.usage.request_usage_entries) == 2
assert result.usage.request_usage_entries[0].total_tokens == 0
assert result.usage.request_usage_entries[1].total_tokens == 0
@pytest.mark.asyncio
async def test_get_response_with_retry_preserves_inferred_normalized_error_flags() -> None:
calls = 0
async def rewind() -> None:
return None
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
raise _connection_error()
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1),
response_id="resp_partial_normalized",
)
result = await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(jitter=False),
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: ModelRetryAdvice(
normalized=ModelRetryNormalizedError(status_code=429)
),
previous_response_id=None,
conversation_id=None,
)
assert calls == 2
assert result.response_id == "resp_partial_normalized"
@pytest.mark.asyncio
async def test_get_response_with_retry_honors_explicit_false_provider_normalized_override() -> None:
calls = 0
async def rewind() -> None:
raise AssertionError("Explicit false override should suppress retries")
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise _connection_error()
with pytest.raises(APIConnectionError):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(jitter=False),
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: ModelRetryAdvice(
normalized=ModelRetryNormalizedError(
is_network_error=False,
is_timeout=False,
)
),
previous_response_id=None,
conversation_id=None,
)
assert calls == 1
@pytest.mark.asyncio
async def test_get_response_with_retry_honors_explicit_none_retry_after_override() -> None:
calls = 0
async def rewind() -> None:
raise AssertionError("Explicit retry_after=None should suppress retry-after retries")
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
request = httpx2.Request("POST", "https://example.com")
response = httpx2.Response(
429,
request=request,
headers={"retry-after-ms": "1250"},
json={"error": {"code": "rate_limit", "message": "rate_limit"}},
)
raise APIStatusError(
"rate_limit",
response=response,
body={"error": {"code": "rate_limit", "message": "rate_limit"}},
)
with pytest.raises(APIStatusError):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(jitter=False),
policy=retry_policies.retry_after(),
),
get_retry_advice=lambda _request: ModelRetryAdvice(
normalized=ModelRetryNormalizedError(retry_after=None),
),
previous_response_id=None,
conversation_id=None,
)
assert calls == 1
@pytest.mark.asyncio
async def test_get_response_with_retry_preserves_conversation_locked_compatibility(
monkeypatch,
) -> None:
calls = 0
rewinds = 0
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
raise _conversation_locked_error()
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1, input_tokens=3, output_tokens=2, total_tokens=5),
response_id="resp_compat",
)
result = await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
assert calls == 2
assert rewinds == 1
assert sleeps == [1.0]
assert result.usage.requests == 2
assert len(result.usage.request_usage_entries) == 2
assert result.usage.request_usage_entries[0].total_tokens == 0
assert result.usage.request_usage_entries[1].total_tokens == 5
@pytest.mark.asyncio
async def test_get_response_with_retry_disables_provider_retries_on_stateful_compat_replay(
monkeypatch,
) -> None:
calls = 0
rewinds = 0
provider_retry_flags: list[bool] = []
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
async def get_response() -> ModelResponse:
nonlocal calls
provider_retry_flags.append(should_disable_provider_managed_retries())
calls += 1
if calls == 1:
raise _conversation_locked_error()
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1),
response_id="resp_stateful_compat_disable_none",
)
result = await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id="resp_prev",
conversation_id=None,
)
assert calls == 2
assert rewinds == 1
assert provider_retry_flags == [False, True]
assert sleeps == [1.0]
assert result.response_id == "resp_stateful_compat_disable_none"
@pytest.mark.asyncio
async def test_get_response_with_retry_respects_explicit_disable_for_conversation_locked(
monkeypatch,
) -> None:
calls = 0
rewinds = 0
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise _conversation_locked_error()
with pytest.raises(BadRequestError):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=0,
policy=retry_policies.never(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
assert calls == 1
assert rewinds == 0
assert sleeps == []
@pytest.mark.asyncio
async def test_get_response_with_retry_keeps_conversation_locked_compatibility_with_retry(
monkeypatch,
) -> None:
calls = 0
rewinds = 0
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
raise _conversation_locked_error()
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1),
response_id="resp_locked_retry_enabled",
)
result = await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
assert calls == 2
assert rewinds == 1
assert sleeps == [1.0]
assert result.response_id == "resp_locked_retry_enabled"
@pytest.mark.asyncio
async def test_get_response_with_retry_allows_stateful_retry_when_provider_marks_safe(
monkeypatch,
) -> None:
calls = 0
rewinds = 0
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
raise _connection_error()
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1),
response_id="resp_stateful",
)
result = await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.provider_suggested(),
),
get_retry_advice=lambda _request: ModelRetryAdvice(
suggested=True,
replay_safety="safe",
),
previous_response_id="resp_prev",
conversation_id=None,
)
assert calls == 2
assert rewinds == 1
assert result.usage.requests == 2
@pytest.mark.asyncio
async def test_get_response_with_retry_allows_stateful_retry_for_http_failure_advice(
monkeypatch,
) -> None:
calls = 0
rewinds = 0
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
raise _status_error_without_code(429, "rate_limit")
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1),
response_id="resp_stateful_http_failure",
)
result = await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.provider_suggested(),
),
get_retry_advice=get_openai_retry_advice,
previous_response_id="resp_prev",
conversation_id=None,
)
assert calls == 2
assert rewinds == 1
assert result.response_id == "resp_stateful_http_failure"
assert result.usage.requests == 2
@pytest.mark.asyncio
async def test_get_response_with_retry_allows_provider_safe_stateful_retry_for_generic_policy(
monkeypatch,
) -> None:
calls = 0
rewinds = 0
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
raise _connection_error()
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1),
response_id="resp_stateful_generic_policy",
)
result = await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: ModelRetryAdvice(
suggested=True,
replay_safety="safe",
),
previous_response_id="resp_prev",
conversation_id=None,
)
assert calls == 2
assert rewinds == 1
assert result.usage.requests == 2
@pytest.mark.asyncio
async def test_get_response_with_retry_rejects_stateful_retry_without_replay_safety() -> None:
calls = 0
async def rewind() -> None:
raise AssertionError("State should not rewind when replay is vetoed")
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise _connection_error()
with pytest.raises(APIConnectionError):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(jitter=False),
policy=retry_policies.provider_suggested(),
),
get_retry_advice=lambda _request: ModelRetryAdvice(suggested=True),
previous_response_id="resp_prev",
conversation_id=None,
)
assert calls == 1
@pytest.mark.asyncio
async def test_get_response_with_retry_exposes_provider_error_code_to_retry_policies(
monkeypatch,
) -> None:
calls = 0
rewinds = 0
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
raise _status_error_without_code(429, "rate_limit")
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1),
response_id="resp_rate_limit_retry",
)
result = await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(jitter=False),
policy=lambda context: context.normalized.error_code == "rate_limit",
),
get_retry_advice=get_openai_retry_advice,
previous_response_id=None,
conversation_id=None,
)
assert calls == 2
assert rewinds == 1
assert result.response_id == "resp_rate_limit_retry"
assert result.usage.requests == 2
@pytest.mark.asyncio
async def test_get_response_with_retry_stops_after_retry_budget_exhausted(monkeypatch) -> None:
calls = 0
rewinds = 0
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise _connection_error()
with pytest.raises(APIConnectionError):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(initial_delay=0.5, jitter=False),
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
assert calls == 2
assert rewinds == 1
assert sleeps == [0.5]
@pytest.mark.asyncio
async def test_get_response_with_retry_caps_conversation_locked_compatibility_retries(
monkeypatch,
) -> None:
calls = 0
rewinds = 0
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise _conversation_locked_error()
with pytest.raises(BadRequestError):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
assert calls == 4
assert rewinds == 3
assert sleeps == [1.0, 2.0, 4.0]
@pytest.mark.asyncio
async def test_get_response_with_retry_prefers_retry_after_over_backoff(monkeypatch) -> None:
calls = 0
rewinds = 0
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
raise _connection_error()
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=0),
response_id="resp_retry_after",
)
result = await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(initial_delay=5.0, jitter=False),
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: ModelRetryAdvice(suggested=True, retry_after=1.75),
previous_response_id=None,
conversation_id=None,
)
assert rewinds == 1
assert sleeps == [1.75]
assert result.usage.requests == 2
@pytest.mark.asyncio
async def test_get_response_with_retry_honors_provider_hard_veto() -> None:
calls = 0
async def rewind() -> None:
raise AssertionError("Provider veto should stop retries before rewinding state")
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise _connection_error()
with pytest.raises(APIConnectionError):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.any(
retry_policies.provider_suggested(),
retry_policies.network_error(),
),
),
get_retry_advice=lambda _request: ModelRetryAdvice(
suggested=False, reason="server veto"
),
previous_response_id=None,
conversation_id=None,
)
assert calls == 1
def _ws_close_invalidated_error() -> RuntimeError:
error = RuntimeError("Responses websocket connection closed while establishing a connection.")
setattr(error, "_openai_agents_ws_close_invalidated", True) # noqa: B010
return error
@pytest.mark.asyncio
async def test_get_response_with_retry_does_not_replay_websocket_close_invalidated_request() -> (
None
):
model = OpenAIResponsesWSModel(model="gpt-4", openai_client=cast(Any, object()))
calls = 0
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise _ws_close_invalidated_error()
async def rewind() -> None:
raise AssertionError("A close-invalidated request must not be rewound for retry")
with pytest.raises(RuntimeError, match="closed while establishing"):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff={"initial_delay": 0},
policy=retry_policies.network_error(),
),
get_retry_advice=model.get_retry_advice,
previous_response_id=None,
conversation_id=None,
)
assert calls == 1
@pytest.mark.asyncio
async def test_stream_response_with_retry_does_not_replay_websocket_close_invalidated_request() -> (
None
):
model = OpenAIResponsesWSModel(model="gpt-4", openai_client=cast(Any, object()))
calls = 0
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal calls
calls += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
raise _ws_close_invalidated_error()
yield # pragma: no cover
return iterator()
async def rewind() -> None:
raise AssertionError("A close-invalidated request must not be rewound for retry")
with pytest.raises(RuntimeError, match="closed while establishing"):
async for _event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff={"initial_delay": 0},
policy=retry_policies.network_error(),
),
get_retry_advice=model.get_retry_advice,
previous_response_id=None,
conversation_id=None,
):
pass
assert calls == 1
@pytest.mark.asyncio
async def test_get_response_with_retry_allows_custom_policy_to_override_provider_veto(
monkeypatch,
) -> None:
calls = 0
rewinds = 0
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
raise _status_error_without_code(429, "rate_limit")
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1),
response_id="resp_custom_policy_override",
)
result = await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.retry_after(),
),
get_retry_advice=lambda _request: ModelRetryAdvice(
suggested=False,
retry_after=1.75,
reason="server veto",
normalized=ModelRetryNormalizedError(
status_code=429,
retry_after=1.75,
),
),
previous_response_id=None,
conversation_id=None,
)
assert calls == 2
assert rewinds == 1
assert sleeps == [1.75]
assert result.usage.requests == 2
@pytest.mark.asyncio
async def test_retry_policies_any_merges_later_positive_metadata() -> None:
raw_decision = retry_policies.any(
retry_policies.network_error(),
retry_policies.retry_after(),
)(
RetryPolicyContext(
error=_connection_error(),
attempt=1,
max_retries=2,
stream=False,
normalized=ModelRetryNormalizedError(
is_network_error=True,
retry_after=1.75,
),
provider_advice=ModelRetryAdvice(retry_after=1.75),
)
)
decision = await raw_decision if asyncio.iscoroutine(raw_decision) else raw_decision
assert isinstance(decision, RetryDecision)
assert decision.retry is True
assert decision.delay == 1.75
@pytest.mark.asyncio
async def test_get_response_with_retry_honors_unsafe_replay_veto() -> None:
calls = 0
async def rewind() -> None:
raise AssertionError("Unsafe replay should not rewind state")
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise _connection_error()
with pytest.raises(APIConnectionError):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: ModelRetryAdvice(
suggested=True,
replay_safety="unsafe",
),
previous_response_id=None,
conversation_id=None,
)
assert calls == 1
@pytest.mark.asyncio
async def test_stream_response_with_retry_retries_before_first_event(monkeypatch) -> None:
attempts = 0
rewinds = 0
failed_attempts: list[int] = []
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
if attempts == 1:
raise _connection_error()
yield cast(TResponseStreamEvent, {"type": "response.created"})
return iterator()
events = [
event
async for event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(initial_delay=0.25, jitter=False),
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
failed_retry_attempts_out=failed_attempts,
)
]
assert attempts == 2
assert rewinds == 1
assert sleeps == [0.25]
assert failed_attempts == [1]
assert events == [cast(TResponseStreamEvent, {"type": "response.created"})]
@pytest.mark.asyncio
async def test_stream_response_with_retry_retries_timeout_before_output() -> None:
attempts = 0
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
if attempts == 1:
await asyncio.Event().wait()
yield cast(TResponseStreamEvent, {"type": "response.created"})
return iterator()
events = [
event
async for event in stream_response_with_retry(
get_stream=get_stream,
rewind=lambda: asyncio.sleep(0),
retry_settings=ModelRetrySettings(
max_retries=1,
backoff={"initial_delay": 0},
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=0.01,
)
]
assert attempts == 2
assert events == [cast(TResponseStreamEvent, {"type": "response.created"})]
@pytest.mark.asyncio
async def test_stream_response_with_retry_keeps_one_context_for_timed_attempt() -> None:
context_value: ContextVar[str | None] = ContextVar("context_value", default=None)
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
token = context_value.set("active")
try:
yield cast(TResponseStreamEvent, {"type": "response.created"})
yield cast(TResponseStreamEvent, {"type": "response.in_progress"})
finally:
context_value.reset(token)
return iterator()
events = [
event
async for event in stream_response_with_retry(
get_stream=get_stream,
rewind=lambda: asyncio.sleep(0),
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=1,
)
]
assert events == [
cast(TResponseStreamEvent, {"type": "response.created"}),
cast(TResponseStreamEvent, {"type": "response.in_progress"}),
]
assert context_value.get() is None
@pytest.mark.asyncio
async def test_timed_stream_constructs_and_closes_iterator_in_one_context() -> None:
context_value: ContextVar[str | None] = ContextVar("context_value", default=None)
class ConstructionScopedStream:
def __init__(self) -> None:
self.token = context_value.set("active")
self.emitted = False
def __aiter__(self) -> ConstructionScopedStream:
return self
async def __anext__(self) -> TResponseStreamEvent:
if self.emitted:
raise StopAsyncIteration
self.emitted = True
return cast(TResponseStreamEvent, {"type": "response.created"})
async def aclose(self) -> None:
context_value.reset(self.token)
events = [
event
async for event in stream_response_with_retry(
get_stream=ConstructionScopedStream,
rewind=lambda: asyncio.sleep(0),
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=1,
)
]
assert events == [cast(TResponseStreamEvent, {"type": "response.created"})]
assert context_value.get() is None
@pytest.mark.asyncio
async def test_timed_stream_early_close_keeps_generator_cleanup_context() -> None:
context_value: ContextVar[str | None] = ContextVar("context_value", default=None)
cleanup_state: list[str] = []
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
token = context_value.set("active")
try:
yield cast(TResponseStreamEvent, {"type": "response.created"})
await asyncio.Event().wait()
finally:
context_value.reset(token)
cleanup_state.append("reset")
return iterator()
stream = stream_response_with_retry(
get_stream=get_stream,
rewind=lambda: asyncio.sleep(0),
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=1,
)
assert await stream.__anext__() == cast(TResponseStreamEvent, {"type": "response.created"})
await stream.aclose()
assert cleanup_state == ["reset"]
assert context_value.get() is None
@pytest.mark.asyncio
async def test_timed_stream_early_close_allows_cooperative_cleanup() -> None:
cleanup_state: list[str] = []
class CooperativeCloseStream:
def __init__(self) -> None:
self.emitted = False
def __aiter__(self) -> CooperativeCloseStream:
return self
async def __anext__(self) -> TResponseStreamEvent:
if not self.emitted:
self.emitted = True
return cast(TResponseStreamEvent, {"type": "response.created"})
await asyncio.Event().wait()
raise AssertionError("unreachable")
async def aclose(self) -> None:
await asyncio.sleep(0)
cleanup_state.append("closed")
stream = stream_response_with_retry(
get_stream=CooperativeCloseStream,
rewind=lambda: asyncio.sleep(0),
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=1,
)
assert await stream.__anext__() == cast(TResponseStreamEvent, {"type": "response.created"})
await stream.aclose()
assert cleanup_state == ["closed"]
@pytest.mark.asyncio
async def test_timed_stream_parent_cancellation_allows_cooperative_cleanup() -> None:
read_started = asyncio.Event()
cleanup_state: list[str] = []
class CooperativeCancelStream:
def __aiter__(self) -> CooperativeCancelStream:
return self
async def __anext__(self) -> TResponseStreamEvent:
read_started.set()
await asyncio.Event().wait()
raise AssertionError("unreachable")
async def aclose(self) -> None:
await asyncio.sleep(0)
cleanup_state.append("closed")
async def consume() -> None:
async for _event in stream_response_with_retry(
get_stream=CooperativeCancelStream,
rewind=lambda: asyncio.sleep(0),
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=1,
):
pass
task = asyncio.create_task(consume())
await read_started.wait()
task.cancel()
with pytest.raises(asyncio.CancelledError):
await task
assert cleanup_state == ["closed"]
@pytest.mark.asyncio
async def test_timed_stream_closes_provider_iterator_once() -> None:
class CloseCountingStream:
def __init__(self) -> None:
self.emitted = False
self.close_calls = 0
def __aiter__(self) -> CloseCountingStream:
return self
async def __anext__(self) -> TResponseStreamEvent:
if self.emitted:
raise StopAsyncIteration
self.emitted = True
return cast(TResponseStreamEvent, {"type": "response.created"})
async def aclose(self) -> None:
self.close_calls += 1
provider_stream = CloseCountingStream()
events = [
event
async for event in stream_response_with_retry(
get_stream=lambda: provider_stream,
rewind=lambda: asyncio.sleep(0),
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=1,
)
]
assert events == [cast(TResponseStreamEvent, {"type": "response.created"})]
assert provider_stream.close_calls == 1
@pytest.mark.asyncio
async def test_stream_response_with_retry_does_not_retry_timeout_after_output() -> None:
attempts = 0
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
yield cast(TResponseStreamEvent, {"type": "response.output_item.added"})
await asyncio.Event().wait()
return iterator()
with pytest.raises(ModelTimeoutError):
async for _event in stream_response_with_retry(
get_stream=get_stream,
rewind=lambda: asyncio.sleep(0),
retry_settings=ModelRetrySettings(
max_retries=1,
backoff={"initial_delay": 0},
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=0.01,
):
pass
assert attempts == 1
@pytest.mark.asyncio
async def test_stream_timeout_reports_configured_attempt_timeout() -> None:
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
yield cast(TResponseStreamEvent, {"type": "response.created"})
await asyncio.Event().wait()
return iterator()
stream = stream_response_with_retry(
get_stream=get_stream,
rewind=lambda: asyncio.sleep(0),
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=0.05,
)
assert await stream.__anext__() == cast(TResponseStreamEvent, {"type": "response.created"})
await asyncio.sleep(0.03)
with pytest.raises(ModelTimeoutError) as exc_info:
await stream.__anext__()
assert exc_info.value.timeout_seconds == 0.05
assert str(exc_info.value) == "Model call timed out after 0.05 seconds."
@pytest.mark.asyncio
async def test_stream_timeout_bounds_owner_cleanup_after_exhaustion() -> None:
class SlowCloseStream:
def __aiter__(self) -> SlowCloseStream:
return self
async def __anext__(self) -> TResponseStreamEvent:
raise StopAsyncIteration
async def aclose(self) -> None:
await asyncio.Event().wait()
with pytest.raises(ModelTimeoutError) as exc_info:
async for _event in stream_response_with_retry(
get_stream=SlowCloseStream,
rewind=lambda: asyncio.sleep(0),
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=0.01,
):
pass
assert exc_info.value.timeout_seconds == 0.01
@pytest.mark.asyncio
async def test_stream_timeout_cancels_blocked_cleanup_after_blocked_read() -> None:
read_started = asyncio.Event()
close_started = asyncio.Event()
release_close = asyncio.Event()
class BlockingReadAndCloseStream:
def __aiter__(self) -> BlockingReadAndCloseStream:
return self
async def __anext__(self) -> TResponseStreamEvent:
read_started.set()
await asyncio.Event().wait()
raise AssertionError("unreachable")
async def aclose(self) -> None:
close_started.set()
await release_close.wait()
async def consume() -> None:
async for _event in stream_response_with_retry(
get_stream=BlockingReadAndCloseStream,
rewind=lambda: asyncio.sleep(0),
retry_settings=None,
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=0.01,
):
pass
task = asyncio.create_task(consume())
await read_started.wait()
done, _ = await asyncio.wait({task}, timeout=0.2)
if task not in done:
release_close.set()
await task
pytest.fail("Timed stream cleanup did not receive a second cancellation.")
with pytest.raises(ModelTimeoutError) as exc_info:
await task
assert close_started.is_set()
assert exc_info.value.timeout_seconds == 0.01
@pytest.mark.asyncio
async def test_stream_response_with_retry_preserves_parent_cancellation_over_cleanup_error() -> (
None
):
started = asyncio.Event()
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
started.set()
try:
await asyncio.Event().wait()
except asyncio.CancelledError as exc:
raise RuntimeError("stream cleanup failed") from exc
yield cast(TResponseStreamEvent, {"type": "response.created"})
return iterator()
async def consume() -> None:
async for _event in stream_response_with_retry(
get_stream=get_stream,
rewind=lambda: asyncio.sleep(0),
retry_settings=ModelRetrySettings(
max_retries=1,
backoff={"initial_delay": 0},
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
timeout=10,
):
pass
task = asyncio.create_task(consume())
await started.wait()
task.cancel()
with pytest.raises(asyncio.CancelledError):
await task
@pytest.mark.asyncio
async def test_stream_response_with_retry_keeps_provider_retries_on_first_attempt(
monkeypatch,
) -> None:
attempts = 0
provider_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
return None
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
provider_retry_flags.append(should_disable_provider_managed_retries())
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
if attempts == 1:
raise _connection_error()
yield cast(TResponseStreamEvent, {"type": "response.created"})
return iterator()
events = [
event
async for event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
]
assert provider_retry_flags == [False, True]
assert events == [cast(TResponseStreamEvent, {"type": "response.created"})]
@pytest.mark.asyncio
async def test_stream_response_with_retry_disables_provider_retries_on_first_stateful_provider_hint(
monkeypatch,
) -> None:
attempts = 0
provider_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
return None
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
provider_retry_flags.append(should_disable_provider_managed_retries())
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
if attempts == 1:
raise _connection_error()
yield cast(TResponseStreamEvent, {"type": "response.created"})
return iterator()
events = [
event
async for event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.provider_suggested(),
),
get_retry_advice=lambda _request: ModelRetryAdvice(
suggested=True,
replay_safety="safe",
),
previous_response_id="resp_prev",
conversation_id=None,
)
]
assert provider_retry_flags == [True, True]
assert events == [cast(TResponseStreamEvent, {"type": "response.created"})]
@pytest.mark.asyncio
async def test_stream_response_with_retry_disables_stateful_provider_retries_with_narrow_policy(
monkeypatch,
) -> None:
attempts = 0
provider_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
raise AssertionError("Unrelated policy should not trigger runner rewind")
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
provider_retry_flags.append(should_disable_provider_managed_retries())
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
raise _connection_error()
yield # pragma: no cover
return iterator()
with pytest.raises(APIConnectionError):
async for _event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.http_status([429]),
),
get_retry_advice=lambda _request: None,
previous_response_id="resp_prev",
conversation_id=None,
):
pass
assert attempts == 1
assert provider_retry_flags == [True]
@pytest.mark.asyncio
async def test_stream_response_with_retry_keeps_provider_retries_without_runner_policy(
monkeypatch,
) -> None:
attempts = 0
provider_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
return None
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
provider_retry_flags.append(should_disable_provider_managed_retries())
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
yield cast(TResponseStreamEvent, {"type": "response.created"})
return iterator()
events = [
event
async for event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=2,
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
]
assert attempts == 1
assert provider_retry_flags == [False]
assert events == [cast(TResponseStreamEvent, {"type": "response.created"})]
@pytest.mark.asyncio
async def test_get_response_with_retry_disables_websocket_pre_event_retries_when_runner_managed(
monkeypatch,
) -> None:
calls = 0
websocket_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
return None
async def get_response() -> ModelResponse:
nonlocal calls
websocket_retry_flags.append(should_disable_websocket_pre_event_retries())
calls += 1
if calls == 1:
raise _connection_error()
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1),
response_id="resp_disable_ws_hidden_retry",
)
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
assert websocket_retry_flags == [True, True]
@pytest.mark.asyncio
async def test_stream_response_with_retry_keeps_websocket_pre_event_retries_with_unrelated_policy(
monkeypatch,
) -> None:
attempts = 0
websocket_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
raise AssertionError("Unrelated policy should not trigger runner rewind")
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
websocket_retry_flags.append(should_disable_websocket_pre_event_retries())
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
raise _connection_error()
yield # pragma: no cover
return iterator()
with pytest.raises(APIConnectionError):
async for _event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.http_status([429]),
),
get_retry_advice=lambda _request: None,
previous_response_id="resp_prev",
conversation_id=None,
):
pass
assert attempts == 1
assert websocket_retry_flags == [False]
@pytest.mark.asyncio
async def test_stream_response_with_retry_keeps_websocket_pre_event_retries_for_partial_all_policy(
monkeypatch,
) -> None:
attempts = 0
websocket_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
raise AssertionError("Partial all() policy should not trigger runner rewind")
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
websocket_retry_flags.append(should_disable_websocket_pre_event_retries())
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
raise _connection_error()
yield # pragma: no cover
return iterator()
with pytest.raises(APIConnectionError):
async for _event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.all(
retry_policies.network_error(),
retry_policies.http_status([500]),
),
),
get_retry_advice=lambda _request: None,
previous_response_id="resp_prev",
conversation_id=None,
):
pass
assert attempts == 1
assert websocket_retry_flags == [False]
@pytest.mark.asyncio
async def test_get_response_with_retry_disables_websocket_pre_event_retries_when_disabled(
monkeypatch,
) -> None:
websocket_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
return None
async def get_response() -> ModelResponse:
websocket_retry_flags.append(should_disable_websocket_pre_event_retries())
return ModelResponse(
output=[get_text_message("ok")],
usage=Usage(requests=1),
response_id="resp_disable_ws_hidden_retry_zero",
)
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=0,
policy=retry_policies.never(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
assert websocket_retry_flags == [True]
@pytest.mark.asyncio
async def test_stream_response_with_retry_does_not_leak_provider_retry_disable_to_consumer(
monkeypatch,
) -> None:
attempts = 0
provider_retry_flags: list[bool] = []
consumer_retry_flags: list[bool] = []
async def fake_sleep(_delay: float) -> None:
return None
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
return None
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
provider_retry_flags.append(should_disable_provider_managed_retries())
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
if attempts == 1:
raise _connection_error()
yield cast(TResponseStreamEvent, {"type": "response.created"})
return iterator()
async for _event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
):
consumer_retry_flags.append(should_disable_provider_managed_retries())
assert provider_retry_flags == [False, True]
assert consumer_retry_flags == [False]
@pytest.mark.asyncio
async def test_stream_response_with_retry_treats_timeout_error_as_retryable(monkeypatch) -> None:
attempts = 0
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
return None
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
if attempts == 1:
raise TimeoutError("Timed out while waiting for websocket receive.")
yield cast(TResponseStreamEvent, {"type": "response.created"})
return iterator()
events = [
event
async for event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(initial_delay=0.25, jitter=False),
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
]
assert attempts == 2
assert sleeps == [0.25]
assert events == [cast(TResponseStreamEvent, {"type": "response.created"})]
@pytest.mark.asyncio
async def test_stream_response_with_retry_allows_stateful_retry_when_provider_marks_safe(
monkeypatch,
) -> None:
attempts = 0
rewinds = 0
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
if attempts == 1:
raise _connection_error()
yield cast(TResponseStreamEvent, {"type": "response.created"})
return iterator()
events = [
event
async for event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(jitter=False),
policy=retry_policies.provider_suggested(),
),
get_retry_advice=lambda _request: ModelRetryAdvice(
suggested=True,
replay_safety="safe",
),
previous_response_id="resp_prev",
conversation_id=None,
)
]
assert attempts == 2
assert rewinds == 1
assert sleeps == [0.25]
assert events == [cast(TResponseStreamEvent, {"type": "response.created"})]
@pytest.mark.asyncio
async def test_stream_response_with_retry_allows_stateful_retry_for_http_failure_advice(
monkeypatch,
) -> None:
attempts = 0
rewinds = 0
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
if attempts == 1:
raise _status_error_without_code(500, "server_error")
yield cast(TResponseStreamEvent, {"type": "response.created"})
return iterator()
events = [
event
async for event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(jitter=False),
policy=retry_policies.provider_suggested(),
),
get_retry_advice=get_openai_retry_advice,
previous_response_id="resp_prev",
conversation_id=None,
)
]
assert attempts == 2
assert rewinds == 1
assert sleeps == [0.25]
assert events == [cast(TResponseStreamEvent, {"type": "response.created"})]
@pytest.mark.asyncio
async def test_stream_response_with_retry_allows_custom_policy_to_override_provider_veto(
monkeypatch,
) -> None:
attempts = 0
rewinds = 0
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
if attempts == 1:
raise _status_error_without_code(429, "rate_limit")
yield cast(TResponseStreamEvent, {"type": "response.created"})
return iterator()
events = [
event
async for event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(jitter=False),
policy=retry_policies.http_status([429]),
),
get_retry_advice=lambda _request: ModelRetryAdvice(
suggested=False,
reason="server veto",
normalized=ModelRetryNormalizedError(status_code=429),
),
previous_response_id=None,
conversation_id=None,
)
]
assert attempts == 2
assert rewinds == 1
assert sleeps == [0.25]
assert events == [cast(TResponseStreamEvent, {"type": "response.created"})]
@pytest.mark.asyncio
async def test_stream_response_with_retry_rejects_stateful_retry_without_replay_safety() -> None:
attempts = 0
async def rewind() -> None:
raise AssertionError("Stateful streaming retry should not rewind when replay is vetoed")
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
raise _connection_error()
yield # pragma: no cover
return iterator()
with pytest.raises(APIConnectionError):
async for _event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.provider_suggested(),
),
get_retry_advice=lambda _request: ModelRetryAdvice(suggested=True),
previous_response_id="resp_prev",
conversation_id=None,
):
pass
assert attempts == 1
@pytest.mark.asyncio
async def test_stream_response_with_retry_stops_after_retry_budget_exhausted(
monkeypatch,
) -> None:
attempts = 0
rewinds = 0
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
raise _connection_error()
yield # pragma: no cover
return iterator()
with pytest.raises(APIConnectionError):
async for _event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(initial_delay=0.25, jitter=False),
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
):
pass
assert attempts == 2
assert rewinds == 1
assert sleeps == [0.25]
@pytest.mark.asyncio
async def test_stream_response_with_retry_retries_after_pre_output_event(monkeypatch) -> None:
attempts = 0
rewinds = 0
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
if attempts == 1:
yield cast(TResponseStreamEvent, {"type": "response.created"})
raise _connection_error()
yield cast(TResponseStreamEvent, {"type": "response.created"})
yield cast(TResponseStreamEvent, {"type": "response.in_progress"})
return iterator()
events = [
event
async for event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(initial_delay=0.25, jitter=False),
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
]
assert attempts == 2
assert rewinds == 1
assert sleeps == [0.25]
assert events == [
cast(TResponseStreamEvent, {"type": "response.created"}),
cast(TResponseStreamEvent, {"type": "response.created"}),
cast(TResponseStreamEvent, {"type": "response.in_progress"}),
]
@pytest.mark.asyncio
async def test_stream_response_with_retry_does_not_retry_after_output_event() -> None:
attempts = 0
async def rewind() -> None:
raise AssertionError("Streaming retries should stop after output has been emitted")
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
yield cast(TResponseStreamEvent, {"type": "response.output_item.added"})
raise _connection_error()
return iterator()
with pytest.raises(APIConnectionError):
async for _event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
):
pass
assert attempts == 1
@pytest.mark.asyncio
async def test_stream_response_with_retry_closes_abandoned_stream_before_retry(
monkeypatch,
) -> None:
rewinds = 0
sleeps: list[float] = []
first_stream = _AcloseTrackingStream(error_before_yield=_connection_error())
second_stream = _AcloseTrackingStream(
events=[cast(TResponseStreamEvent, {"type": "response.created"})]
)
streams = [first_stream, second_stream]
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
return streams.pop(0)
events = [
event
async for event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff=ModelRetryBackoffSettings(initial_delay=0.25, jitter=False),
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
)
]
assert rewinds == 1
assert sleeps == [0.25]
assert first_stream.aclose_calls == 1
assert second_stream.aclose_calls == 1
assert events == [cast(TResponseStreamEvent, {"type": "response.created"})]
@pytest.mark.asyncio
async def test_stream_response_with_retry_preserves_conversation_locked_compatibility(
monkeypatch,
) -> None:
attempts = 0
rewinds = 0
failed_attempts: list[int] = []
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
if attempts == 1:
raise _conversation_locked_error()
yield cast(TResponseStreamEvent, {"type": "response.created"})
return iterator()
events = [
event
async for event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id="resp_prev",
conversation_id=None,
failed_retry_attempts_out=failed_attempts,
)
]
assert attempts == 2
assert rewinds == 1
assert failed_attempts == [1]
assert sleeps == [1.0]
assert events == [cast(TResponseStreamEvent, {"type": "response.created"})]
@pytest.mark.asyncio
async def test_stream_response_with_retry_disables_provider_retries_on_stateful_compat_replay(
monkeypatch,
) -> None:
attempts = 0
rewinds = 0
provider_retry_flags: list[bool] = []
sleeps: list[float] = []
async def fake_sleep(delay: float) -> None:
sleeps.append(delay)
monkeypatch.setattr(asyncio, "sleep", fake_sleep)
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal attempts
provider_retry_flags.append(should_disable_provider_managed_retries())
attempts += 1
async def iterator() -> AsyncIterator[TResponseStreamEvent]:
if attempts == 1:
raise _conversation_locked_error()
yield cast(TResponseStreamEvent, {"type": "response.created"})
return iterator()
events = [
event
async for event in stream_response_with_retry(
get_stream=get_stream,
rewind=rewind,
retry_settings=ModelRetrySettings(max_retries=1),
get_retry_advice=lambda _request: None,
previous_response_id="resp_prev",
conversation_id=None,
)
]
assert attempts == 2
assert rewinds == 1
assert provider_retry_flags == [False, True]
assert sleeps == [1.0]
assert events == [cast(TResponseStreamEvent, {"type": "response.created"})]
@pytest.mark.asyncio
async def test_stream_response_with_retry_closes_current_stream_when_consumer_stops_early() -> None:
stream = _CloseTrackingStream(
events=[
cast(TResponseStreamEvent, {"type": "response.created"}),
cast(TResponseStreamEvent, {"type": "response.in_progress"}),
]
)
async def rewind() -> None:
raise AssertionError("Early consumer exit should not rewind state")
outer_stream = cast(
Any,
stream_response_with_retry(
get_stream=lambda: stream,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
policy=retry_policies.network_error(),
),
get_retry_advice=lambda _request: None,
previous_response_id=None,
conversation_id=None,
),
)
first_event = await outer_stream.__anext__()
assert first_event == cast(TResponseStreamEvent, {"type": "response.created"})
await outer_stream.aclose()
assert stream.close_calls == 1
def _ws_response_started_advice(request: ModelRetryAdviceRequest) -> ModelRetryAdvice:
"""Advice matching the Responses WebSocket adapter after a response-started disconnect."""
return ModelRetryAdvice(
suggested=False,
replay_safety="unsafe",
reason=str(request.error),
response_started=True,
)
def test_retry_policy_context_normalizes_unknown_provider_replay_safety() -> None:
context = RetryPolicyContext(
error=_connection_error(),
attempt=1,
max_retries=1,
stream=False,
normalized=ModelRetryNormalizedError(),
provider_advice=ModelRetryAdvice(replay_safety="conditional"),
)
assert context.replay_safety == "unknown"
def test_provider_suggested_preserves_public_veto_for_unsafe_advice() -> None:
decision = retry_policies.provider_suggested()(
RetryPolicyContext(
error=_connection_error(),
attempt=1,
max_retries=1,
stream=False,
normalized=ModelRetryNormalizedError(is_network_error=True),
provider_advice=ModelRetryAdvice(
suggested=False,
replay_safety="unsafe",
reason="provider veto",
),
)
)
assert isinstance(decision, RetryDecision)
assert decision.retry is False
assert decision.reason == "provider veto"
@pytest.mark.asyncio
async def test_provider_unsafe_replay_retries_when_policy_approves_explicitly() -> None:
calls = 0
seen: list[RetryPolicyContext] = []
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
raise _connection_error("no close frame received or sent")
return ModelResponse(output=[get_text_message("ok")], usage=Usage(), response_id="resp")
def policy(context: RetryPolicyContext) -> RetryDecision:
seen.append(context)
return RetryDecision(
retry=True,
approve_unsafe_replay=True,
reason="Approved one replay of a read-only model turn",
)
result = await get_response_with_retry(
get_response=get_response,
rewind=lambda: asyncio.sleep(0),
retry_settings=ModelRetrySettings(
max_retries=1, backoff={"initial_delay": 0}, policy=policy
),
get_retry_advice=_ws_response_started_advice,
previous_response_id=None,
conversation_id=None,
)
assert result.response_id == "resp"
assert calls == 2
# The policy must be able to scope its approval, so it needs the structured context.
assert len(seen) == 1
assert seen[0].stream is False
assert seen[0].response_started is True
assert seen[0].replay_safety == "unsafe"
assert seen[0].stateful_request is False
@pytest.mark.asyncio
async def test_provider_unsafe_replay_still_blocks_an_ordinary_retry_decision() -> None:
calls = 0
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise _connection_error("no close frame received or sent")
def policy(_context: RetryPolicyContext) -> RetryDecision:
# No `approve_unsafe_replay`, so this must not bypass replay protection.
return RetryDecision(retry=True)
with pytest.raises(APIConnectionError):
await get_response_with_retry(
get_response=get_response,
rewind=lambda: asyncio.sleep(0),
retry_settings=ModelRetrySettings(
max_retries=1, backoff={"initial_delay": 0}, policy=policy
),
get_retry_advice=_ws_response_started_advice,
previous_response_id=None,
conversation_id=None,
)
assert calls == 1
@pytest.mark.asyncio
async def test_provider_unsafe_replay_approval_is_ignored_for_streamed_requests() -> None:
calls = 0
async def get_stream() -> AsyncIterator[TResponseStreamEvent]:
nonlocal calls
calls += 1
raise _connection_error("no close frame received or sent")
yield # pragma: no cover - generator marker
def policy(_context: RetryPolicyContext) -> RetryDecision:
return RetryDecision(retry=True, approve_unsafe_replay=True)
with pytest.raises(APIConnectionError):
async for _event in stream_response_with_retry(
get_stream=get_stream,
rewind=lambda: asyncio.sleep(0),
retry_settings=ModelRetrySettings(
max_retries=1, backoff={"initial_delay": 0}, policy=policy
),
get_retry_advice=_ws_response_started_advice,
previous_response_id=None,
conversation_id=None,
):
pass
assert calls == 1
@pytest.mark.asyncio
async def test_unsafe_replay_approval_does_not_replay_programmatic_tool_calling() -> None:
calls = 0
policy_calls = 0
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise _connection_error()
def policy(_context: RetryPolicyContext) -> RetryDecision:
nonlocal policy_calls
policy_calls += 1
return RetryDecision(retry=True, approve_unsafe_replay=True)
# `replay_unsafe_request` is the request-level veto the runner sets for
# Programmatic Tool Calling. Application approval must not lift it.
with pytest.raises(APIConnectionError):
await get_response_with_retry(
get_response=get_response,
rewind=lambda: asyncio.sleep(0),
retry_settings=ModelRetrySettings(
max_retries=1, backoff={"initial_delay": 0}, policy=policy
),
get_retry_advice=_ws_response_started_advice,
previous_response_id=None,
conversation_id=None,
replay_unsafe_request=True,
)
assert calls == 1
assert policy_calls == 0
@pytest.mark.asyncio
@pytest.mark.parametrize("combinator", ["all", "any"])
@pytest.mark.parametrize("provider_first", [False, True])
async def test_unsafe_replay_approval_resolves_provider_veto_in_policy_combinators(
combinator: str,
provider_first: bool,
) -> None:
calls = 0
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
raise _connection_error("no close frame received or sent")
return ModelResponse(output=[get_text_message("ok")], usage=Usage(), response_id="resp")
def approving(_context: RetryPolicyContext) -> RetryDecision:
return RetryDecision(retry=True, approve_unsafe_replay=True)
provider_policy = retry_policies.provider_suggested()
policies = (provider_policy, approving) if provider_first else (approving, provider_policy)
combined = getattr(retry_policies, combinator)(*policies)
result = await get_response_with_retry(
get_response=get_response,
rewind=lambda: asyncio.sleep(0),
retry_settings=ModelRetrySettings(
max_retries=1, backoff={"initial_delay": 0}, policy=combined
),
get_retry_advice=_ws_response_started_advice,
previous_response_id=None,
conversation_id=None,
)
assert result.response_id == "resp"
assert calls == 2
@pytest.mark.asyncio
async def test_provider_normalization_cannot_clear_raw_abort_veto() -> None:
class AbortError(Exception):
pass
calls = 0
policy_calls = 0
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise AbortError("cancelled")
async def rewind() -> None:
raise AssertionError("An abort must not rewind state")
def policy(_context: RetryPolicyContext) -> RetryDecision:
nonlocal policy_calls
policy_calls += 1
return RetryDecision(retry=True, approve_unsafe_replay=True)
def get_retry_advice(_request: ModelRetryAdviceRequest) -> ModelRetryAdvice:
return ModelRetryAdvice(
suggested=False,
replay_safety="unsafe",
normalized=ModelRetryNormalizedError(is_abort=False),
)
with pytest.raises(AbortError, match="cancelled"):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff={"initial_delay": 0},
policy=policy,
),
get_retry_advice=get_retry_advice,
previous_response_id=None,
conversation_id=None,
)
assert calls == 1
assert policy_calls == 0
@pytest.mark.asyncio
async def test_policy_cannot_promote_unknown_provider_replay_safety() -> None:
calls = 0
policy_calls = 0
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise _connection_error()
async def rewind() -> None:
raise AssertionError("Unknown replay safety must not rewind state")
def policy(context: RetryPolicyContext) -> RetryDecision:
nonlocal policy_calls
policy_calls += 1
assert context.provider_advice is not None
assert context.replay_safety == "unknown"
context.provider_advice.replay_safety = "safe"
return RetryDecision(retry=True)
with pytest.raises(APIConnectionError):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff={"initial_delay": 0},
policy=policy,
),
get_retry_advice=lambda _request: ModelRetryAdvice(
suggested=True,
replay_safety="conditional",
),
previous_response_id="resp_1",
conversation_id=None,
)
assert calls == 1
assert policy_calls == 1
@pytest.mark.asyncio
async def test_policy_cannot_revoke_provider_safe_replay_evidence() -> None:
calls = 0
rewinds = 0
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
raise _connection_error()
return ModelResponse(output=[get_text_message("ok")], usage=Usage(), response_id="resp")
async def rewind() -> None:
nonlocal rewinds
rewinds += 1
def policy(context: RetryPolicyContext) -> RetryDecision:
assert context.provider_advice is not None
assert context.replay_safety == "safe"
context.provider_advice.replay_safety = "conditional"
return RetryDecision(retry=True)
result = await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff={"initial_delay": 0},
policy=policy,
),
get_retry_advice=lambda _request: ModelRetryAdvice(
suggested=True,
replay_safety="safe",
),
previous_response_id="resp_1",
conversation_id=None,
)
assert result.response_id == "resp"
assert calls == 2
assert rewinds == 1
@pytest.mark.asyncio
@pytest.mark.parametrize("combinator", ["all", "any"])
@pytest.mark.parametrize(
("suggested", "initial_safety", "expected_context_safety"),
[
(False, "unsafe", "unsafe"),
(None, "conditional", "unknown"),
],
)
async def test_composed_policy_cannot_mutate_provider_authority(
combinator: str,
suggested: bool | None,
initial_safety: str,
expected_context_safety: str,
) -> None:
calls = 0
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise _connection_error()
async def rewind() -> None:
raise AssertionError("Mutated provider authority must not rewind state")
def mutate_advice(context: RetryPolicyContext) -> RetryDecision:
assert context.provider_advice is not None
assert context.replay_safety == expected_context_safety
assert context.response_started is False
context.provider_advice.suggested = True
context.provider_advice.replay_safety = "safe"
context.provider_advice.response_started = True
assert context.replay_safety == expected_context_safety
assert context.response_started is False
return RetryDecision(retry=True)
policy = getattr(retry_policies, combinator)(
mutate_advice,
retry_policies.provider_suggested(),
)
with pytest.raises(APIConnectionError):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff={"initial_delay": 0},
policy=policy,
),
get_retry_advice=lambda _request: ModelRetryAdvice(
suggested=suggested,
replay_safety=initial_safety,
response_started=False,
),
previous_response_id="resp_1",
conversation_id=None,
)
assert calls == 1
@pytest.mark.asyncio
async def test_composed_policy_cannot_mutate_provider_authority_for_ptc() -> None:
calls = 0
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise _connection_error()
async def rewind() -> None:
raise AssertionError("Mutated provider authority must not rewind PTC state")
def mutate_advice(context: RetryPolicyContext) -> RetryDecision:
assert context.provider_advice is not None
context.provider_advice.suggested = True
context.provider_advice.replay_safety = "safe"
return RetryDecision(retry=True)
with pytest.raises(APIConnectionError):
await get_response_with_retry(
get_response=get_response,
rewind=rewind,
retry_settings=ModelRetrySettings(
max_retries=1,
backoff={"initial_delay": 0},
policy=retry_policies.all(
mutate_advice,
retry_policies.provider_suggested(),
),
),
get_retry_advice=lambda _request: ModelRetryAdvice(
suggested=None,
replay_safety="conditional",
),
previous_response_id=None,
conversation_id=None,
replay_unsafe_request=True,
)
assert calls == 1
@pytest.mark.asyncio
async def test_unsafe_replay_approval_applies_to_a_stateful_request() -> None:
calls = 0
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
if calls == 1:
raise _connection_error("no close frame received or sent")
return ModelResponse(output=[get_text_message("ok")], usage=Usage(), response_id="resp")
def policy(_context: RetryPolicyContext) -> RetryDecision:
return RetryDecision(retry=True, approve_unsafe_replay=True)
# `auto_previous_response_id=True` produces exactly this shape: a stateful request
# that fails closed by default but carries no application-local side effects.
result = await get_response_with_retry(
get_response=get_response,
rewind=lambda: asyncio.sleep(0),
retry_settings=ModelRetrySettings(
max_retries=1, backoff={"initial_delay": 0}, policy=policy
),
get_retry_advice=_ws_response_started_advice,
previous_response_id="resp_1",
conversation_id=None,
)
assert result.response_id == "resp"
assert calls == 2
@pytest.mark.asyncio
async def test_stateful_request_still_fails_closed_without_explicit_approval() -> None:
calls = 0
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise _connection_error("no close frame received or sent")
def policy(_context: RetryPolicyContext) -> RetryDecision:
return RetryDecision(retry=True)
with pytest.raises(APIConnectionError):
await get_response_with_retry(
get_response=get_response,
rewind=lambda: asyncio.sleep(0),
retry_settings=ModelRetrySettings(
max_retries=1, backoff={"initial_delay": 0}, policy=policy
),
get_retry_advice=_ws_response_started_advice,
previous_response_id=None,
conversation_id="conv_1",
)
assert calls == 1
@pytest.mark.asyncio
async def test_unsafe_replay_approval_does_not_lift_a_stateful_request_with_unknown_safety() -> (
None
):
calls = 0
async def get_response() -> ModelResponse:
nonlocal calls
calls += 1
raise _connection_error()
def policy(_context: RetryPolicyContext) -> RetryDecision:
return RetryDecision(retry=True, approve_unsafe_replay=True)
# No provider advice, so replay safety is unknown rather than unsafe. The approval is
# scoped to provider-marked unsafe failures, so the stateful gate must stay closed.
with pytest.raises(APIConnectionError):
await get_response_with_retry(
get_response=get_response,
rewind=lambda: asyncio.sleep(0),
retry_settings=ModelRetrySettings(
max_retries=1, backoff={"initial_delay": 0}, policy=policy
),
get_retry_advice=lambda _request: None,
previous_response_id="resp_1",
conversation_id=None,
)
assert calls == 1