nSjFUdZddlmZddlmZdZded<ddZ dddZdS)uThinking-timeout detection and user-facing guidance for reasoning models. When a known reasoning model (NVIDIA Nemotron 3 Ultra, OpenAI o1/o3, Anthropic Opus 4.x thinking, DeepSeek R1, Qwen QwQ, xAI Grok reasoning) hits a transport-layer error before the first content token arrives, the upstream proxy has almost certainly idle-killed a long thinking stream — not a true context overflow or a configuration error. The user needs distinct guidance for this case: "The model's thinking phase exceeded the upstream proxy's idle timeout before the first content token arrived. This is a known issue with reasoning models behind cloud gateways (NVIDIA NIM, OpenAI, Anthropic, DeepSeek). Workarounds in priority order: 1. Set `providers..models..stale_timeout_seconds: 900` in `~/.hermes/config.yaml` to extend the per-call timeout... 2. Lower `reasoning_budget` or set `reasoning_effort: medium`... 3. Use a smaller / faster reasoning model..." The existing `_is_stream_drop` guidance at ``agent/conversation_loop.py:3464-3486`` fires for large-file-write stream drops ("try execute_code with Python's open() for large files") which is the WRONG advice for the thinking-timeout case. This module provides the detection and the message as standalone helpers so the detection logic is unit-testable without driving the full retry loop, and the message text can be regression-tested for spelling and accuracy. Part 2 of Fixes #52310. ) annotations)Optional)z broken pipezerrno 32zremote protocolzconnection resetzconnection lostz peer closedzserver disconnectedztuple[str, ...]_THINKING_TIMEOUT_SUBSTRINGS classifiedobjectmodelstr error_msgreturnboolcddlm}t|dd}t|dd}|dkrdS||dS|pdt fd t DS) aReturn True when a reasoning model's thinking phase hit a transport kill. Args: classified: a :class:`agent.error_classifier.ClassifiedError` instance (duck-typed here to avoid an import cycle in unit tests). model: the model slug at failure time (e.g. ``"nvidia/nemotron-3-ultra-550b-a55b"``). error_msg: lowercased string representation of the underlying exception (typically ``str(api_error).lower()``). Returns True when ALL conditions hold: 1. ``classified.reason == FailoverReason.timeout`` (the classifier override at ``agent/error_classifier.py:720-738`` ensures this is the case for reasoning models even on large sessions). 2. ``api_error`` has no ``.status_code`` attribute set (transport disconnect, not an HTTP error). 3. ``model`` is in the reasoning-model allowlist (reuses ``agent.reasoning_timeouts.get_reasoning_stale_timeout_floor``). 4. ``error_msg`` contains one of the transport-kill substrings. Non-reasoning models always return False. Non-transport errors (billing / rate_limit / auth / context_overflow / format_error) always return False. HTTP-status errors always return False. r)!get_reasoning_stale_timeout_floorreasonNvaluetimeoutFc3 K|]}|vV dSN).0perror_msg_lowers A/home/ice/.hermes/hermes-agent/agent/thinking_timeout_guidance.py z&is_thinking_timeout..es(JJqO#JJJJJJ)agent.reasoning_timeoutsrgetattrloweranyr)rrr rr reason_valuers @ris_thinking_timeoutr!4s8KJJJJJ Z4 0 0F67D11Ly  u)(//7u!B--//O JJJJ-IJJJ J JJrNprovider model_label Optional[str]c"|p|}d|d|d|dS)aReturn the user-facing guidance string appended to ``_final_response``. Args: provider: provider slug (e.g. ``"nvidia"``, ``"openai"``). model: bare model slug the user would put in their config (e.g. ``"nemotron-3-ultra-550b-a55b"`` if the user uses NVIDIA direct, or the full ``"nvidia/nemotron-3-ultra-550b-a55b"`` if they go through an aggregator). Used verbatim in the config snippet so the user can copy-paste. model_label: optional short label for the model name in the prose (e.g. ``"Nemotron 3 Ultra"``). Falls back to the slug if not provided. z The model's thinking phase exceeded the upstream proxy's idle timeout before the first content token arrived. This is a known issue with reasoning models (like zt) behind cloud gateways (NVIDIA NIM, OpenAI, Anthropic, DeepSeek). Workarounds in priority order: 1. Set `providers.z.models.u.stale_timeout_seconds: 900` in `~/.hermes/config.yaml` to extend the per-call timeout. (Hermes's built-in floor is 600s for known reasoning models — if you still see this after raising, the upstream cap is even shorter.) 2. Lower `reasoning_budget` or set `reasoning_effort: medium` on this model if the provider supports it. 3. Use a smaller / faster reasoning model if the task doesn't require deep thinking.r)r"rr#labels rbuild_thinking_timeout_guidancer'hsH  5E !38 ! ! & ! ! 05 ! ! !r)rrrr r r r r r)r"r rr r#r$r r ) __doc__ __future__rtypingrr__annotations__r!r'rrrr,s:#"""""11K1K1K1Kj=A       r