`gj&dZddlmZddlZddlZddlmZmZmZm Z eje Z dZ d dZddZddZdd  dd Zdd  dd Zgd Zy)uStream diagnostics — per-attempt counters, exception chains, retry logging. When a streaming chat-completions request dies mid-response, we want to know why: which Cloudflare edge served the request, which OpenRouter downstream provider answered, how many bytes/chunks we got before the drop, the HTTP status, the underlying httpx error class. These helpers collect that info and emit it both to ``agent.log`` (full detail) and to the user-facing status line (compact). All helpers are extracted from :class:`AIAgent` for cleanliness. ``run_agent`` keeps thin forwarder methods so existing call sites and tests that patch ``run_agent.`` keep working. ) annotationsN)AnyDictListOptional) zcf-rayzcf-cache-statuszx-openrouter-providerzx-openrouter-modelzx-openrouter-idz x-request-idz x-vercel-idviaserverzx-forwarded-forc8tjdddiddS)zReturn a fresh per-attempt diagnostic dict. Mutated in-place by the streaming functions and read from the retry block when a stream dies. Lives on ``request_client_holder`` so it survives across the closure boundary. Nr) started_atfirst_chunk_atchunksbytesheaders http_status)timeD/root/.hermes/venv/lib/python3.12/site-packages/agent/stream_diag.pystream_diag_initr)s&iik  rcR|t|tsy t|dd|d< t|ddxsi}i}t|dt}|D]'} |j |}|rt |dd||<)||d<y#t$rYbwxYw#t$rYJwxYw#t$rYywxYw)uSnapshot interesting headers + HTTP status from the live stream. Called once at stream open (before iterating chunks) so the metadata survives even if the stream dies before any chunk arrives. Failures are swallowed — diag is best-effort. N status_coderr_STREAM_DIAG_HEADERSx) isinstancedictgetattr ExceptionSTREAM_DIAG_HEADERSgetstr)agentdiag http_responsercapturedtarget_headersnamevals rstream_diag_capture_responser(:sJtT$: %m]DI] -D9?R#% (>@ST" D kk$'%(Xds^HTN  #Y          sFA<)B$B 4B< BB BBBB B&%B&c$g}|}|Zt|dkrL||vrnG|j|t|ddxs t|dd}|||urn|}|t|dkrLg}|D]}t|j j dd}t|dkDr|dddz}|j|rt |jd |d nt |j|rd j|St |jS) uReturn a compact ``Outer(msg) <- Inner(msg) <- ...`` rendering. OpenAI SDK wraps httpx errors as ``APIConnectionError`` / ``APIError`` and only the wrapper's class is visible at the catch site — but the underlying ``RemoteProtocolError`` / ``ConnectError`` / ``ReadError`` is what tells us WHY the stream died. Walks ``__cause__`` then ``__context__`` (deduped, max 4 deep) to surface the chain in one line. N __cause__ __context__  …()z <- ) lenappendrr stripreplacetype__name__join)errorseenlinknxtpartsemsgs rflatten_exception_chainrAYs!#D$)D  s4y1} 4<  DdK. ' -3  ;#+   s4y1}E P!flln$$T3/ s8c>ds)e#C SQ(()3%q1d1g>N>NO P "'6;;u @DK,@,@@r)r"c |j|}|rt|dkDr|dddz} t |}tj} d} d} d} d} d}d}t|tr t|jdxsd} t|jdxsd} t|jd xs| }td| |z } |jd }|tdt||z } |jd xsi}t|tr(|r&d jd |jD}|jdt|jd}t j#d|||t%|ddxsdt%|dd|j&xsd|j(xsdt |j |||| | | | | ddnd|d|iy#t$rt|}YwxYw#t$rt |j }YwxYw#t$rYwxYw#t$rt j+ddYywxYw)uRecord a transient stream-drop and retry to ``agent.log``. Always logs a structured WARNING so users have a breadcrumb regardless of UI verbosity. Subagents in particular benefit because their retries no longer spam the parent's terminal — but the file log keeps full detail (provider, error class, attempt, base_url, subagent_id). When *diag* is provided (the per-attempt stream-diagnostic dict from :func:`stream_diag_init`), the WARNING also captures upstream headers (cf-ray, x-openrouter-provider, x-openrouter-id), HTTP status, bytes streamed before the drop, and elapsed time on the dying attempt. These are the breadcrumbs needed to answer "is one CF edge / one downstream provider responsible, or is it random across runs?" Nr0r-rr r r rr.c30K|]\}}|d|yw)=Nr).0kvs r z#log_stream_retry..s#-'+q!1#Qqc -sruStream %s on attempt %s/%s — retrying. subagent_id=%s depth=%s provider=%s base_url=%s error_type=%s error=%s chain=%s http_status=%s bytes=%d chunks=%d elapsed=%.2fs ttfb=%s upstream=[%s] _subagent_id_delegate_depthz.2fs mid_tool_call)extrazstream-retry log emit failedT)exc_info)_summarize_api_errorrr r3rAr7r8rrrintrfloatmaxr9itemsloggerwarningrproviderbase_urldebug)r!kindr:attempt max_attemptsrOr"_summary_chain_now_bytes_chunks_elapsed_ttfb _headers_repr _http_status_started_firstrs rlog_stream_retryrjxsr0CD "11%8H H +~-H *,U3F yy{  dD ! TXXg.3!4dhhx05A6 ,!7!?4@sD8O4"23%U6]X%=>E((9-3gt,$'HH-/6}}-%M88M*6#&txx '>#?L      E>4 0 7C E,a 0 NN !c NN !c K      $0uSkOc "M2/  M "5zH " *%[))F *6  8 D 3d CDsvG1I H 1I*D H16A:I1H IH  I H.*I-H..I1 H=:I<H==I I#"I#c|rdnd}t||||||||jxsd}d}t|trC |j d} | /dt d t j t| z d d } |jd |d |dt|jd|d|d| |jd|d|dt|jy#t$rYpwxYw#t$rYywxYw)uEmit a single user-visible line for a stream drop+retry. Both top-level agents and subagents announce drops in the UI — the parent prefixes subagent lines with ``[subagent-N]`` via ``log_prefix`` so they're easy to attribute. All cases also write a structured WARNING to ``agent.log`` via :func:`log_stream_retry` with the full diagnostic detail (subagent_id, provider, base_url, error_type, cf-ray, x-openrouter-provider, bytes/chunks, elapsed) for post-hoc analysis. The user-visible status line is intentionally compact: provider, error class, attempt N/M, plus ``after Xs`` when the stream dropped mid-flight. Full diagnostic detail goes to ``agent.log`` only — ``hermes logs --level WARNING | grep "Stream drop"`` to inspect. zdrop mid tool-calldrop)r\r:r]r^rOr"rYr Nz after rDz.1frNu⚠️ z stream z (r2u — reconnecting, retry /z stream retry ) rjrYrrrrUrrTr_buffer_statusr7r8_touch_activity) r!r:r]r^rOr"r\rY_suffixstarteds remit_stream_droprss80$1 fD !# ~~+HG$ hh|,G"#CTYY[5>-I$J3#OqQ   hZxvRU 0D0D/EQwiP''.iq @  G9Al^4%[))* ,        s%AC#?A#C2# C/.C/2 C>=C>)rrr(rArjrs)returnDict[str, Any])r!rr"rur#rrtNone)r: BaseExceptionrtr )r!rr\r r:rwr]rSr^rSrOboolr"Optional[Dict[str, Any]]rtrv)r!rr:rwr]rSr^rSrOrxr"ryrtrv)__doc__ __future__rloggingrtypingrrrr getLoggerr8rWrrr(rArjrs__all__rrrrs # ,,   8 $ " >AN&*[D [D [D  [D  [D  [D[D #[D [DJ&*8 8  8  8  8  8  #8  8 v r