The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Codex Responses recovery rungs: stale encrypted-reasoning strip and the replay verdict reset."""
from __future__ import annotations
import logging
from typing import Any
from agent.turn_retry_state import TurnRetryState
logger = logging.getLogger(__name__)
def _is_codex_token_expired(agent: Any, api_error: Exception) -> bool:
"""401 ``token_expired`` from the Codex backend (#88510). It rejects a stale replayed
``encrypted_content`` blob with this auth signature, so a persisted session loops on "sign
in again" while a fresh session on the same bearer works. The caller treats it like
``invalid_encrypted_content`` — but only while cached reasoning items remain to strip."""
if getattr(api_error, "status_code", None) != 401:
return False
reason = agent._extract_api_error_context(api_error).get("reason")
return isinstance(reason, str) and reason.strip().lower() == "token_expired"
def reset_codex_reasoning_replay(agent: Any) -> None:
"""The replay verdict belongs to the route that earned it: a ``/model`` switch, fallback
activation or primary restore starts the new route with replay on (#61552)."""
agent._codex_reasoning_replay_enabled = True
agent._codex_reasoning_replay_rejected = False
def _recover_stale_codex_reasoning(
agent: Any, _retry: TurnRetryState, messages: list[dict[str, Any]], api_messages: Any,
) -> bool:
"""Stale ``codex_reasoning_items`` blob rejected by the provider: strip cached items (mutates
persisted ``messages``) and retry once. The first rung drops only the replayed blobs not stamped by
exactly this endpoint+model (it consumes its own precondition, so it cannot loop); a repeat goes on
to strip every item. The first full strip keeps replay on, since blobs the
route mints from now on are sealed with its current key; a repeat rejection means the route
cannot round-trip its own blobs, so replay is disabled for the session."""
if (
_retry.invalid_encrypted_content_retry_attempted
or agent.api_mode != "codex_responses"
or not bool(getattr(agent, "_codex_reasoning_replay_enabled", True))
or not any(
isinstance(_m, dict)
and _m.get("role") == "assistant"
and isinstance(_m.get("codex_reasoning_items"), list)
and _m.get("codex_reasoning_items")
for _m in messages
)
):
return False
from agent.turn_recovery import _vlines # facade owns the verbose printer; late import breaks the cycle
transport = agent._get_transport()
if transport is not None and (removed := transport.drop_unverified_replay(messages, api_messages)):
_vlines(agent, f"⚠️ Encrypted reasoning replay was rejected — dropped {removed} item(s) minted elsewhere, retrying...")
return True
_retry.invalid_encrypted_content_retry_attempted = True
keep_replay = not getattr(agent, "_codex_reasoning_replay_rejected", False)
agent._codex_reasoning_replay_rejected = True
replay_stats = agent._disable_codex_reasoning_replay(messages, keep_replay=keep_replay)
# The retry is rebuilt from the request copy; with replay kept on it would resend the stale blob.
for _m in api_messages if isinstance(api_messages, list) else []:
if isinstance(_m, dict):
_m.pop("codex_reasoning_items", None)
action = "stripped stale" if keep_replay else "disabled replay for this session and stripped"
_vlines(
agent,
f"⚠️ Encrypted reasoning replay was rejected by the provider — "
f"{action} {replay_stats['items']} item(s) from {replay_stats['messages']} message(s), retrying...",
)
logger.warning(
"%sInvalid encrypted reasoning recovery: %s %d items from %d messages",
agent.log_prefix, action, replay_stats["items"], replay_stats["messages"],
)
return True