3908 lines
118 KiB
Python
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
|