+ iHj0hRt^RIHt^RIt^RIt^RIt^RIHt^RIH t H t H t H t H t ^RIHtHtHtHtHtHt^RIHt^RIHt^RIHtHtHtHt^R IHtH t ^R I!H"t"^R I#H$t$]PJ!R 4t&R t'Rt(Rt)R t*]!RR44t+]!RR7!RR]+44t,RRlt-RRlt.RRlt/RRlt0RRlt1R#)!aOverflow recovery for the conversation turn loop: 413 payload-too-large and context-length errors after ``classify_api_error``. Each path either compresses and signals a restart, defers softly (compression lock / transient block), or ends the turn with a typed result. Nothing here imports ``agent.conversation_loop`` at module level (cycle); loop-internal helpers and the token estimators that tests patch on the loop module are imported lazily inside the handlers. ) annotationsN) dataclass)AnyDictListOptionalTuple)*COMPRESSION_RETRY_MESSAGES_STATUS_TEMPLATE(COMPRESSION_RETRY_TOKENS_STATUS_TEMPLATE+COMPRESSION_RETRY_TOO_LARGE_STATUS_TEMPLATEcompression_blocked_transientlycompression_skipped_due_to_lockcontext_compression_timed_out)FailoverReason)serialized_messages_bytes)&get_context_length_from_provider_erroris_local_endpointis_output_cap_error(parse_available_output_tokens_from_error) site_copy stamp_failure)TurnRetryState)base_url_host_matcheszagent.conversation_loopuR 💡 Try /new to start a fresh conversation, or /compress to retry compression.g?cv]tRt^5t$RtR]R&R]R&R]R&R]R &R]R &R ]R &R ]R &R]R&R]R&RtR#)OverflowVerdictuOutcome of ``recover_from_overflow``. ``action`` is one of ``"return"`` (end the turn with ``result``), ``"break"`` (restart the API call — a ``_retry.restart_with_*`` flag is set), ``"continue"`` (retry the call immediately) or ``"fallthrough"`` (not an overflow error, or overflow recovery declined — continue generic error handling). The remaining fields are the loop locals the handler may have rebound.stractionOptional[dict[str, Any]]resultlist[dict[str, Any]]messagesractive_system_promptconversation_historyint approx_tokenscompression_attemptsbool"provider_overflow_recovery_pendingis_context_length_errorN)__name__ __module__ __qualname____firstlineno____doc____annotations____static_attributes__r)8/home/ubuntu/.hermes/hermes-agent/agent/turn_overflow.pyrr5s?@ K $$""(,,!!r1rT)kw_onlyc ]tRt^Jt$RtR]R&R]R&R]R&R]R&R]R&R]R &R tR ]R &R tR]R&R tR]R&Rt R]R&Rt R]R&R,RRllt RR-RR RRRRRR/RR llt R!R/R"R#llt R$R/R%R&lltR$R/R'R(lltR)R*ltR+tR #). _RecoveryuWorking state shared by the overflow sub-handlers — the verdict itself, plus the read-only call context; handlers mutate the loop-local fields and ``done()`` stamps the action.ragent api_messagessystem_messageeffective_task_idr#api_call_countmax_compression_attemptsNz Optional[str]overflow_reason fallthroughrrrrFr&r'r(c$V^8dQhRRRRRR/#)rrrrreturnrr))formats"r2 __annotate___Recovery.__annotate__\s"3(@Or1c "WuVnVnV#N)rr)selfrrs&&&r2done_Recovery.done\s#)  T[ r1noticeslogcompression_exhaustedTreasoncontext_overflow retryablec8V^8dQhRRRRRRRRR RR RR R R R/#)r?final_responserrItuplerJzOptional[tuple]rKr&rLrNextrarr@rr))rAs"r2rBrC`sR++!+/4+@O+#+47+++.+  +r1c VPpV'd<VP4VF%p VPVP V 2RRR7K' V'd\P !V!VP VPVP4\RVRVPRRRVPRVR RR R/WV4p V'dRV R &V PV4VPR V 4#) zEnd the turn as failed/partial. ``notices`` flush the buffered retry trace first so the user sees what compression attempts were made.Tforce diagnosticrPr completedF api_callserrorpartialfailedrKr@) r6_flush_status_buffer_vprint log_prefixloggerrY_persist_sessionr r"rr:updaterG) rFrPrIrJrKrLrNrRr6liners &&$$$$$, r2 fail_turn_Recovery.fail_turn`s    & & ( !1!1 24&9RV W  LL#  t}}d.G.GH n   ,, ^ t d   !/3F* + eyy6**r1payload_too_largec V^8dQhRRRR/#)r?rer&r@Optional[OverflowVerdict]r))rAs"r2rBrCs  $ C\ r1c V;P^, unVPpVPV8:dR#V'dUVP\RVPP R7RV R2\ 3RVPPV3R7#VP\RVPP R7RV R 2\ 3R VPPV3R7#) zMBump ``compression_attempts``; the terminal verdict once the cap is exceeded.Nremodelu❌ Max compression attempts (z&) reached for payload-too-large error.z+%s413 compression failed after %d attempts.rIrJrMz ) reached.z/%sContext compression failed after %d attempts.)r%r;rcrr6rj _RETRY_HINTr^)rFrecaps&$ r2 count_attempt_Recovery.count_attempts !!Q&!++  $ $ + >>-TZZ5E5EF4SE9_`CDJJDYDY[^_ " ~~ ( 0@0@ A5cU*E{SBDJJDYDY[^_  r1fail_on_timeoutc$V^8dQhRRRRRR/#)r?request_tokensr#rpr&r@rgr))rAs"r2rBrCs"&&s&&Qj&r1c  ^RIHp^RIHpHpVP pVP pVPWpPVVPRRVPR7wVnVn VP VJdRp\V4'dV!W`P VP4pM0\V4'd V!W`P VPRR7pVeRV;P^,unVP!VP VP"4VP%R V4#V'd%\'V4'dVP)VR R 7#V!W`P VP"4VnR#) a+One compression pass with the summary-failure cooldown bypassed (the provider proved the request doesn't fit). Returns ``None`` when history was compressed, or a soft-defer verdict when another path holds the compression lock or a timed guard no-oped the pass: the attempt is refunded and the turn ends WITHOUT ``compression_exhausted`` so the gateway does not auto-reset. With ``fail_on_timeout`` a host timeout (recovery spent its wait budget with no committed summary) ends the turn via the typed contract, since re-sending would hit the same overflow.)&conversation_history_after_compression)#_COMPRESSION_TIMEOUT_FINAL_RESPONSE_compression_deferred_resultToverflow)r$task_idbypass_cooldowntriggerr<Ntransient_block)rLr@context_compression_timeout)turn_exit_reason)agent.conversation_compressionrtagent.conversation_looprurvr6r _compress_contextr8r9r<r!r r:r r%r`r"rGrrc) rFrrrprtrurvr6beforedeferreds &&$ r2compress_Recovery.compresssK Zm 383J3J ''~**D* 004K4 0 t0 ==F "H.u557}}dNaNab0777==$*=*=FW#))Q.)&&t}}d6O6OPyy844 >3Fc" %K ==$";";% !r1c$V^8dQhRRRRRR/#)r?rrr#rpr&r@z+tuple[Optional[OverflowVerdict], bool, int]r))rAs"r2rBrCs)OO!O7;O 4Or1c &^RIHp\VP4pV!VP4pVP WR7pVeVRV3#VPpV!V4pV^8;'d WR,8p \V4V8d<VP P \P!V\V4R74M8V 'd1VP P \P!WXR74R\V4V8;'gT V3#)a,``compress`` scored in message count / tokens (context-overflow errors ARE token-budget errors). Same-message-count compression (tool-result pruning, in-place summarization) can shrink the request, so re-estimate rather than trust the array length. Returns ``(deferred_verdict, shrank, new_tokens)``.estimate_messages_tokens_roughrpNFffffff?rafter) agent.model_metadatarlenr rr6_buffer_diagnostic_statusr rAr ) rFrrrpr original_lenoriginal_tokensrr new_tokens shrank_tokenss &&$ r2compress_scored_by_tokens#_Recovery.compress_scored_by_tokenss H4==) 8G===Q  UO3 3==4H= "QNN:$8N+N x=< ' JJ 0 01[1b1bjvBCKL2M N  JJ 0 01Y1`1`hw2K LS]\1BB]JNNr1cV^8dQhRR/#)r?r@r#r))rAs"r2rBrCs```r1c r^RIHpT!VPVPP;'gRR7#)zOverhead-aware request size (msgs + tools + system) so LCM forced-overflow recovery arms on the TRUE request, not the tool-blind message count.)estimate_request_tokens_roughN)tools)rrr7r6r)rFrs& r2rr_Recovery.request_tokenss. G,T->->djjFVFVF^F^Z^__r1)rr!r"r rrEr))r*r+r,r-r.r/r<rrr'r(rGrcrnrrrrr0r)r1r2r5r5Js J!!%)O])FC'+F $+/4&4$)T)+79+RV+&*+:L+ +@  *&u&PO>CO>``r1r5c$V^8dQhRRRRRR/#)r?str5_retryrr@rr))rAs"r2rBrBs!8898n88r1c^RIHpVPpVPRR7pVeV#VP RVP RVP R24VPp\V4p\V4pVPVP44pVeV#VPpV!V4Vn \V4p \V4V8gV ^8dWR,8d\V4V8d2VP \P!V\V4R74MVP R VR R V R R 24\P !^4RVnVP%R 4#VP'VP(RR7'd#VP R4VP%R4#VP+\-RVP.R7R\03RVP23R7#)u413: compress and retry. A 413 is a BYTE-size error, so progress is scored in payload bytes — never the token estimate, which is deliberately byte-blind to images and wedged sessions on "no progress".rT)reu@⚠️ Request payload too large (413) — compression attempt /z...rru🗜️ Compressed , → z payload bytes, retrying...breakF)remember_modeluj📐 Compression could not reduce the request further — removed retained vision payloads and retrying...continuereriu2❌ Payload too large and cannot compress further.z1%s413 payload too large. Cannot compress further.rk)rrr6rnrr%r;r rrrrrr$r rAtimesleep restart_with_compressed_messagesrG)_try_strip_image_parts_from_tool_messagesr7rcrrjrlr^) rrrr6 exhaustedr roriginal_bytesr new_bytess && r2_recover_payload_too_largersD HHE  4 8I ## J " " #1R%@%@$A F {{Hx=L/x8N{{2,,./H{{H5h?B)(3I 8}|# A )W[F[:[ x=< '  + +,V,],]eqy|~FzG-H I  + +%nQ%7uYqMIhi  1 26/www 66rW\6]] '' ? wwz"" <<%U[[9E{S @%BRBR S  r1c ,V^8dQhRRRRRRRRRR /#) r?rr5rr available_outr#old_ctxr@rr))rAs"r2rBrBs1"")"^"C"Z]"bq"r1c VPpVP4pW5, pV^8d\^\W&4^@, 4pM\^V^@, 4pWtnVP RVR RVR RVR RVR R2 4VP 4pVeV#VPV4wrp V eV #RVn VPR 4# \d$\PRTP4LEi;i) zOutput-cap error ("max_tokens too large": input fits but input + max_tokens > window). The provider's available_tokens is the authoritative bound; also estimate the real request shape (API-only content) and use the smaller minus a margin.uM⚠️ Output cap too large for current prompt — retrying with max_tokens=rz (provider_available=z, estimated_request_tokens=z; context_length unchanged at )zC%sOutput-cap compression hit an error; retrying on max_tokens only.Tr)r6rrmaxmin_ephemeral_max_output_tokens_buffer_vprintrnr Exceptionr_warningr^rrG) rrrrr6request_input_estimatelocal_available_outsafe_outrr_shrank _new_tokenss &&&& r2_clamp_output_caprs- HHE..0!:Qq#mABFGq-",-)1&  WX`abWcd,Q//JKabcJde''.qk 4   "I )+)E)EF\)]&;  O /3F+ 777    QSXScSc  sC+C<;C<c(V^8dQhRRRRRRRR/#) r?rr5 error_msgrrr#r@ Optional[int]r))rAs"r2rBrBDs)))i)C)#)R_)r1c V^RIHpVPpVPp\ W4pVeVP RVR RVR R24VP VPWdP\VRR4VPVPR 7V!VPVPWdP4\VR 4'dR Vn R VnVP R VR R VR R24V#\VRR4;'gRP4R9;'gH\VRR4;'gRP!R4P4P#\$4pV'd RV9dVP RVR R24R#VP RVR R24R#)zShrink context_length only when the provider reports the real limit; else keep the window and compress. Guessed probe tiers can turn a configured 1M window into 256K/128K/64K. Returns the provider-reported limit, or ``None``.)save_provider_context_lengthNz!Context limit detected from API: rz tokens (was rapi_key)rjcontext_lengthbase_urlrproviderapi_mode_context_probedTu:⚠️ Context length exceeded — using provider limit: rz tokensrrrzcontext window exceeds limit (zBProvider reported overflow amount only; keeping context_length at z tokens.um⚠️ Context length exceeded, but provider did not report a max context length; keeping context_length at >minimax minimax-cn)rrr6context_compressorrr update_modelrjrgetattrrrhasattrr_context_probe_persistablelowerrstrip startswith_MINIMAX_ANTHROPIC_URLS)rrrrr6 compressornew_ctxis_minimax_providers&&& r2_adopt_provider_context_limitrDsB HHE))J4YHG @ =Y`abXccdef++gE9b1ENNUZUcUc   %U[[%..'>>Z :0 1 1)-J &48J 1 YZabcYddijqrsitt{|}  B ' - -2446:SS j j E:r * 0 0b 8 8 = C C E P PQh i?9L ))0 8 =   ))0 8 =  r1c(V^8dQhRRRRRRRR/#) r?rr5rrrrr@rr))rAs"r2rBrBps/\\ \>\c\Ve\r1c VPpVPPp\V4pVe \ WWT4#\ V4'd-VP RRVP RVR, 23RR7#\WV4pVPPpVP4\^\\VR^4;'g^44,p\VP4'd\P !RV4'g\#V\4'dV^8d|W\$,8dkVP \'RVP(WR 7R VR R VR R 2R3RVPVR VR VR,3R\*P,P.RR7#VP14p V eV #VP3\4P6!VP8VP:VP<R74VP?VP4RR7wrp V eV #WnV 'gV'd<Wd8d6\@PB!^4RVn"RVn#VPIR4#VP \'RVP(R7RV R R2\J3RVPV R 3R7#)zContext-length error. Two shapes: "prompt too long" = INPUT overflows the window (shrink context_length + compress); "max_tokens too large" = input fits but input + max_tokens > window (shrink the OUTPUT cap only).z|The requested output length exceeds the provider's output cap for this model, and the error did not state the allowed limit.zMOutput-cap error not routed into compression (max_tokens over provider cap): :NNF)rIrJrK max_tokensz\d{4,}server_context_rejection)rjtokenswindowuB❌ The server rejected the request as too large, but it is only ~rz tokens against a u"-token window — not compressing.u 💡 Wait a moment and /retry; another request on the same server (e.g. a background review) may have been holding its context.zg%sProvider context rejection not explained by request size (~%s of %s tokens); skipping compression: %sT)rIrJrKrLrN)rattemptrmrrrMriu0❌ The conversation is too long for the model (z& tokens) and cannot be shrunk further.z>%sContext length exceeded: %s tokens. Cannot compress further.rk)u❌ The provider rejected the request because the requested output length exceeds its output cap for this model, and the error did not state the allowed limit.u 💡 Hermes has no user setting for the output cap — check the endpoint's default max output (completion) tokens for this model on the server or proxy. (This is an output-cap error, not a context overflow — compression cannot fix it.))&r6rrrrrrcr^rrrrr#rrrresearch isinstance_UNEXPLAINED_REJECTION_FRACTIONrrjr server_errorvaluernrr rAr$r%r;rrrr'rrGrl) rrrr6rrrrrrrrshrankrs &&& r2_recover_context_lengthrps HHE&&55Gz!nLr s  NuO_O_dnopcq s  r1c$`V^8dQhRRRRRRRRRR R R R R R RRRRRRRRRRRRRRRRRRRRR/#)r?r6r api_errorr classifiedrr status_coderrrwrapped_output_cap_budgetr rr7r8r!r"r$r#r%r;r:r9r@rr))rAs"r2rBrBs0"0" 0"$0"250"?M0"0"+.0"KX0"#0"360"HK0" 0"69 0"JM 0"  0" := 0" OR 0"  0"0"r1c F\WV VVWWW\VPRR4R7 pVR8Xdl\VP\ 4'dL\ VPR4'd0\F%pVPVP V 2RRR7K' VP\P8Xd \VV4#VP\P8H;'gVRJVnVP'd \VW54#VP!R4#) a413 payload-too-large and context-length recovery (compress + retry, output-cap clamp, provider-reported context limit, GitHub Models free-tier hint). Order is load-bearing: 413 is checked BEFORE the generic 4xx handler, and context-length errors (incl. relay-wrapped output-cap 429s) BEFORE non-retryable client errors. Compression progress is scored in payload BYTES for 413 (never the byte-blind token estimate) and in tokens/message count for context overflow.rN) r6r7r8r9r:r;r r!r"r$r%r<izmodels.inference.ai.azure.comTrTr=)r5rrLrrrr_GITHUB_MODELS_HINTr]r^rrerrMr(rrG)r6rrrrrrr r7r8r!r"r$r%r;r:r9rrbs&&&&$$$$$$$$$$$$$ r2recover_from_overflowrs  ~+N!91# 1 17DA  B s u~~s + + !%..2Q R R'D MMU--.tf5TdM S(N<<<)"f55 ^<<< 1 1 $D 0  !!!&r6== 77= !!r1)uJ 💡 GitHub Models free tier (models.inference.ai.azure.com) caps everyzJ request at ~8K tokens. Hermes' system prompt + tool schemas baselinezF exceeds that floor, so this endpoint cannot run an agentic loop.zK Use the `copilot` provider with a Copilot subscription token (`hermesu= setup` → GitHub Copilot), or pick any other provider.)z https://api.minimax.io/anthropicz"https://api.minimaxi.com/anthropic)2r. __future__rloggingrr dataclassesrtypingrrrrrr~r r r r r ragent.error_classifierragent.message_sanitizationrrrrrragent.turn_failure_copyrragent.turn_retry_staterutilsr getLoggerr_rlrrrrr5rrrrrr)r1r2rs# !33 2@=1'   4 5b #&e "" "( 4V`V`V`r8v"J)X\~0"r1