b\j%SSKJr SSKrSSKrSSKrSSKJrJrJ r J r J r J r J r JrJrJrJr SSKJrJr SSKJrJr SSKrSSKJr SSKJr SS KJr SS KJ r J!r! SS K"J#r#J$r$J%r% SS K&J'r' SS K(J)r)J*r*J+r+ SSK,J-r- SSK.J/r/ SSK0J1r1 SSK2J3r3 SSK4J5r5 SSK6J7r7 SS/r8\Rr"S5r:S\;S'Sr\"SSS 9r?S!\;S"'\"S#S$S 9r@S%\;S&'"S'S\*5rA"S(S)\5rB"S*S+\5rC"S,S-\5rD"S.S/\5rE"S0S15rFSTS2jrGSUS3jrH"S4S55rISVS6jrJSWS7jrK"S8S95rLSXS:jrMSYS;jrNSZS<jrOS[S=jrPS\S>jrQS\S?jrRS]S@jrSS^SAjrTS_SBjrUS`SCjrVSaSDjrWSbSEjrXScSFjrYSdSGjrZSeSHjr[SeSIjr\SfSJjr]SgSKjr^ShSLjr_SiSMjr`SjSNjraSkSOjrb"SPSQ\R5rd"SRSS\R5rfg)l) annotationsN) AnyDictListCallableIterableIteratorOptional Generator AsyncIteratorAsyncGeneratorcast)Token ContextVar)Literaloverride)is_dict) BaseModel) APIRequest) APIResponseAsyncAPIResponse)Stream AsyncStreamServerSentEvent)AnthropicError)CallNext Middleware AsyncCallNext) merge_headers)Message) helper_header) BetaMessage)AnthropicBetaParam)BetaFallbackParamBetaFallbackStateBetaRefusalFallbackMiddlewarezanthropic.lib.middlewarezlogging.Loggerlogz /v1/messages)zfallback-credit-2026-06-01tuple[AnthropicBetaParam, ...] DEFAULT_BETAScD\rSrSr%SrS\S'S SjrS SjrS SjrSr g ) r'4ugTracks which fallback a sequence of requests is pinned to. Create one and enter it (`with state:` — the same context manager works for both clients) around every request that should share the pin — the turns of one conversation, or any wider scope the stickiness should apply to; `BetaRefusalFallbackMiddleware` mutates it in place when a model refuses. z int | NoneindexcSUlgNr.selfs Y/var/www/website/venv/lib/python3.13/site-packages/anthropic/lib/middleware/_fallbacks.py__init__BetaFallbackState.__init__Ds  c[RU5n[R/[R5QUP75 U$r0)_fallback_stateset_fallback_state_tokensget)r3tokens r4 __enter__BetaFallbackState.__enter__Gs:##D)""#I%;%?%?%A#I5#IJ r7c[R5n[RUSS5 [R US5 g)N)r;r<r:r9reset)r3exc_infotokenss r4__exit__BetaFallbackState.__exit__Ls6'++-""6#2;/fRj)r7r1NreturnNone)rHr')rCobjectrHrI) __name__ __module__ __qualname____firstlineno____doc____annotations__r5r>rE__static_attributes__r7r4r'r'4s#   *r7anthropic_beta_fallback_state)defaultz$ContextVar[BetaFallbackState | None]r9$anthropic_beta_fallback_state_tokensrRz7ContextVar[tuple[Token[BetaFallbackState | None], ...]]r;c\rSrSrSrSS.SSjjr\SSj5r\SSj5rSSjr SS jr SS jr SS jr SS jr SS jrSSjrSrg)r(^u Middleware that retries refused beta `/v1/messages` requests down a fallback chain, reproducing the server-side `fallbacks` wire shape client-side. Only `client.beta.messages` requests are handled — refusals minted by the first-party `client.messages` surface carry no `fallback_credit_token`, so those requests pass through untouched. Non-streaming: when a response comes back with `stop_reason: "refusal"`, the request is retried with each entry of `fallbacks` merged over the original params — passing along the refusal's `fallback_credit_token` when it minted one — until a model accepts or the chain is exhausted. A `fallback` seam block per model boundary is prepended to the served message's content — the same block shape the streaming splice emits. The served hop's `usage` is left verbatim (streaming rewrites it to per-hop `usage.iterations`). Streaming: when the stream ends in `stop_reason: "refusal"`, a second request is issued to the fallback model. It carries the refusal's `fallback_credit_token`, plus the refused model's partial output as a trailing assistant prefill when the refusal grants one (`fallback_has_prefill_claim`). The fallback's events are then spliced onto the still-open stream, so the client sees one continuous message in the server-side `fallbacks` wire shape: a `fallback` content block at each model boundary, monotonic block indices, and per-hop `usage.iterations` on the final `message_delta`. A refusal before any output streamed retries even without a credit token, and the serving hop's `message_start` opens the wire carrying the primary's message id. The fallback-credit beta the credit tokens require is sent by default on every request the middleware handles; the `betas` option controls this. In both modes a fallback that itself refuses with a fresh credit token continues down the chain. A streaming fallback whose appended prefill the server rejects (HTTP 400 body mismatch) is retried once without it; a fallback whose request fails outright is skipped — its token was never redeemed, so it carries to the next entry. When every remaining entry fails over HTTP, the suppressed refusal is replayed to the client with `recommended_model` stamped from the final failure (the failed model for capacity errors, `null` otherwise). A refusal surfaced to the client rather than retried is reported through the `anthropic.lib.middleware` logger. To keep later requests on the model that accepted, run them inside a shared `BetaFallbackState` context; requests sharing that state start directly at the pinned fallback. Reuse one state across whatever scope the pin should apply to — typically a conversation. The state is the only pin: `fallback` seam blocks replayed in the request history are stripped from the outgoing request (an assistant turn left empty by the strip is dropped whole), never read back as a pin. ```py client = Anthropic(middleware=[BetaRefusalFallbackMiddleware([{"model": "claude-opus-4-8"}])]) state = BetaFallbackState() with state: message = client.beta.messages.create(**params) ``` N)betascd[U5UlUc[O [U5UlSUlg)u Args: fallbacks: The fallback chain, tried in order. An empty chain disables the middleware. betas: Betas added to the `anthropic-beta` header of every `/v1/messages` request this middleware handles — the original request included, since refusals only carry a `fallback_credit_token` when the beta is enabled. Defaults to `("fallback-credit-2026-06-01",)`; pass `()` to send none. NF)tuple _fallbacksr+_betas_warned_missing_state)r3 fallbacksrXs r4r5&BetaRefusalFallbackMiddleware.__init__s)  *',}m%, %*"r7c URU5nUcU"U5$[R5nURU5nUR U5n[ XR 5n[U5nUS:XaUO0UEURUEnURUS9nU"U5n U RR(dU $UR(a4US-n U [UR5:aU $URUUU UU US9$Un U n [URS5=(d S5n /nU [UR5S- :Ga5U RR(GaU R!5n[#U[$[&45(aUR(S:waOU S- n U"U 5 [+U5n[-U5nU"UR[/X0RU U5S95n U RR(a9[URU S5nUR1[3U UU55 Un U [UR5S- :aU RR(aGMU(aaU RR(aFU R!5n[#U[$[&45(aUR(S:wa [5X5$U $NrAbodyrequestrcresponse call_next first_hoppinmodelrefusal)_applicable_bodyr9r< _start_index _make_pin_with_middleware_headersr\_strip_seam_blocksr[copy http_response is_successstreamlen_splice_fallback_streamstrparse isinstancer!r$ stop_reason _credit_token_refusal_category _merged_bodyappend _seam_block_prepend_seam_blocksr3rfrhrcstate start_indexrj initial_bodyinitial_requestrgrir.res from_modelseamsmessager=categoryto_modelserveds r4handle$BetaRefusalFallbackMiddleware.handles$$W- <W% %##%''. nnU#+7KK@ "$'*b0t6^6^Q\A]6^ !,,L,9_-%%00O >>#aIC00//'!!## 0 ))'28b9 &(c$//*Q..33D3D3O3O3OiikGg'=>>'BUBUYbBb QJE J!'*E(1HGLLl4QVAWY^._L`aC  ++tu5g>? [XxHI% c$//*Q..33D3D3O3O3O S&&11YY[F&7K"899f>P>PT]>],C77 r7c L# URU5nUcU"U5IShvN $[R5nURU5nUR U5n[ XR 5n[U5nUS:XaUO0UEURUEnURUS9nU"U5IShvN n U RR(dU $UR(a4US-n U [UR5:aU $URUUU UU US9$Un U n [URS5=(d S5n /nU [UR5S- :GaEU RR(Ga)U R!5IShvN n[#U[$[&45(aUR(S:waOU S- n U"U 5 [+U5n[-U5nU"UR[/X0RU U5S95IShvN n U RR(a9[URU S5nUR1[3U UU55 Un U [UR5S- :aU RR(aGM)U(aiU RR(aNU R!5IShvN n[#U[$[&45(aUR(S:wa [5X5$U $GNGNgGNGNNH7fra)rnr9r<rorprqr\rrr[rsrtrurvrw_splice_fallback_stream_asyncryrzr{r!r$r|r}r~rrr_prepend_seam_blocks_asyncrs r4 handle_async*BetaRefusalFallbackMiddleware.handle_asyncs$$W- <"7++ +##%''. nnU#+7KK@ "$'*b0t6^6^Q\A]6^ !,,L,9"?33%%00O >>#aIC0055'!!## 6 ))'28b9 &(c$//*Q..33D3D3O3O3OIIK'Gg'=>>'BUBUYbBb QJE J!'*E(1H!',,LW\G]_d4e,"fggC  ++tu5g>? [XxHI% c$//*Q..33D3D3O3O3O S&&1199;&F&7K"899f>P>PT]>]2#== },"40(h'sa L$LBL$2L3CL$LBL$LBL$$5L$L"=L$L$L$L$"L$cv[UR5n[R"UR5nUR (aTUR R5S:wd6UR[:wd"URRS5S:wdUcgURS5b [S5eU$)zMThe request's JSON body when this middleware applies to it, `None` otherwise.postbetatrueNr^azSending the `fallbacks:` request param is not supported when using the `BetaRefusalFallbackMiddleware`. You should either remove the middleware and send `fallbacks:` with the `server-side-fallback-2026-06-01` beta header to let the API handle refusal fallbacks, or omit the `fallbacks:` param if you'd like `BetaRefusalFallbackMiddleware` to handle fallbacks on the client side.) _as_dictjsonhttpxURLurlr[methodlowerpath_MESSAGES_PATHparamsr<r)r3rfrcrs r4rn.BetaRefusalFallbackMiddleware._applicable_body5s %ii $~~##%/xx>)zz~~f%/| 88K , 0  r7cUb URcgURnSUs=::a[UR5:d'O [SUS[UR5S35eU$)zThe chain entry this request starts at (-1 = the original params). Only an explicit `BetaFallbackState` pin moves the start; without one the request starts at the original params. rAzBetaFallbackState.index z! is out of bounds for a chain of z? fallback(s); was the state shared with a different middleware?)r.rwr[r)r3rrs r4ro*BetaRefusalFallbackMiddleware._start_indexOsk =EKK/kk [73t#77 *;-7Xt'((gi r7c^^SUU4SjjnU$)zUPin requests sharing the state to the entry being tried (or warn that there is none).cx>TbUTlgTR(dSTl[RS5 gg)NTzanthropic-sdk: BetaRefusalFallbackMiddleware fell back without an active BetaFallbackState; follow-up requests will retry models that already refused. Run them inside a shared `with BetaFallbackState():` block to pin them to the accepted model.)r.r]r)warning)r.r3rs r4rj4BetaRefusalFallbackMiddleware._make_pin..pinbs7 # //-1* &0r7)r.intrHrIrR)r3rrjs`` r4rp'BetaRefusalFallbackMiddleware._make_pin_s   r7c URUUUUUUS9n[[UR[ U55UR UR SURURURS9$)a(Wrap the refusable stream in a response whose body passes events through until a retryable refusal, then splices the fallback chain's events on. Closing the returned response (or the `Stream` parsed from it) tears down whichever stream is being read and abandons any in-flight fallback request. reTrawcast_toclientrv stream_clsoptions retries_taken) _spliced_framesr_spliced_http_responsert_FrameByteStream_cast_to_client _stream_cls_optionsrr3rfrcrgrhrirjframess r4rx5BetaRefusalFallbackMiddleware._splice_fallback_streamps %% & &x'='=?OPV?WX%%##++%%"00  r7c URUUUUUUS9n[[UR[ U55UR UR SURURURS9$)NreTr) _spliced_frames_asyncrrrt_AsyncFrameByteStreamrrrrrrs r4r;BetaRefusalFallbackMiddleware._splice_fallback_stream_asyncs++ ,  &x'='=?TU[?\]%%##++%%"00  r7c #N# URnURnURn [SSSSS/S9n [X5ShvN n U RcUbUR 5 ggU R 5 Sn[ RX+5n [U[U55GHn X}n[US5nU S-[U5:nU"U 5 U R5nSnSn[S5GHnURU RUU5S9nU"U5nURR$(aURn O['UR5nURR 5 US:XaFUR(S :Xa6U(a/[R+S [-U55 U R.nSnM[R!S UUR([-U55 [#UUR(S 9n O Ub<U(aGMnU R1U5HnUv M UbUR 5 ggUceURnU R3U5 [U R4U[7U R8US9U R:U R<U R?5S9n [UU 5ShvN n U R@(aU RC5 U Rc UbUR 5 ggUR 5 SnU REXU5 GM UbUR 5 ggGN![a.n[R!S UU5 [#USS 9nSnA GMySnAff=fN!UbUR 5 ff=f7fNrTF) index_basehas_nextsplice wire_open primary_id seam_framesrkrdr"rbzOanthropic-sdk: BetaRefusalFallbackMiddleware: fallback request to %s failed: %s)rkstatusizanthropic-sdk: BetaRefusalFallbackMiddleware: fallback request with the partial output appended was rejected (HTTP 400: %s); retrying without itzXanthropic-sdk: BetaRefusalFallbackMiddleware: fallback request to %s failed: HTTP %s: %s) iterationsrk)#r[rt _HopReader _drive_hoprefusedclose _ChainStatebeginrangerwry continuationrshop_body Exceptionr)error _HopFailureru _read_json status_coder _json_dumpsbaseterminal_failure_frames queue_seam next_index _SpliceInforrrpending_seam_framesopened mark_openedabsorb_refusal)r3rfrcrgrhrirjr^currentstream_areaderoutcomechainhopentryrkrrres_bfailureattempt hop_requesterrerr_bodyframe hop_responses r4r-BetaRefusalFallbackMiddleware._spliced_framessOO )1)?)?k --HF",H!==G&x" #w NN G %%d4EYI7!E'N+7S^3C %113 15.2$QxG"),,ENN5,4W,"XK  )+ 6**55"'"5"5)%*=*=>H''--/!|(9(9S(@\ g'1 (-zz $ IIr))#H-  *e>O>OPGC (F& "'!>!>w!G# "H6" #1((($22   '#$//%&%2B2B%P#oo$// % 9 9 ; &0 f%EE>>%%'??*" #""$ $$W\Bg8j" #}>8% m! #.E$"GjF" #sN%(N M N N%,B-N M"DN 3N%A=N N 3N 9N%)N 7N% N  N!N:N NN N""N%c h# URnURnURn [SSSSS/S9n [X5ShvN n U 7v MN U R 5n U R cUbUR 5IShvN ggU R 5IShvN Sn[RX,5n [U[U55GHnX~n[US5nUS-[U5:nU"U5 U R5nSnSn[S5GHenURU RUU5S9nU"U5IShvN nO:![a-n[ R#S UU5 [%USS 9nSnA GOSnAff=fURR&(aURn O[)UR5IShvN nURR 5IShvN US:XaGUR*S :Xa7U(a0[ R-S [/U55 U R0nSnGM'[ R#S UUR*[/U55 [%UUR*S 9n O UbFU(aGMU R3U5Hn U 7v M UbUR 5IShvN ggUceURnU R5U5 [U R6U[9U R:US9U R<U R>U RA5S9n [UU 5ShvN n U 7v M U R 5n U RB(aU RE5 U R c UbUR 5IShvN ggUR 5IShvN SnU RGU UU5 GM UbUR 5IShvN gg!UbUR 5IShvN ff=f7fr)$r[rtr_drive_hop_asyncfinishracloserrrrwryrrsrrr)rrru_read_json_asyncrrrrrrrrrrrrrrr)r3rfrcrgrhrirjr^rrrrrrrrrkrrrrrrrrrs r4r3BetaRefusalFallbackMiddleware._spliced_frames_asyncEsOO )1)?)?b '--HF 0A e  AmmoG&b"nn&&&#a//# # #G%%d4EYI7!E'N+7S^3C$113 6:.2$QxG"),,ENN5,4W,"XK &/ &< < <$ m! #.E$"G**55"'"5"5%5e6I6I%JJJH--44666!|(9(9S(@\ g'1 (-zz $ IIr))#H-  *e>O>OPGC (F& !&!>!>w!G# "H2"nn&&&#/((($22   '#$//%&%2B2B%P#oo$// % 9 9 ; $4L&#I  %K$J --/>>%%'??* "nn&&&# #))+++$$We\BS8V"nn&&&#w"nn&&&#s#P2%PAAA PAP2P2B  P2P#B&$B"P EEEP F#!F P FAPG"P7G:8CP8P2KP2A:PM!MM!AP!P27N:8P2?POP2P2P  P2P/'P*(P//P2)r\r[r])r^zIterable[BetaFallbackParam]rXz#Iterable[AnthropicBetaParam] | NonerHrI)rfrrhrrHAPIResponse[Any])rfrrhrrHAsyncAPIResponse[Any])rfrrHdict[str, Any] | None)rBetaFallbackState | NonerHr)rrrHCallable[[int], None])rfrrcdict[str, Any]rgrrhrrirrjrrHr)rfrrcrrgrrhrrirrjrrHr)rfrrcrrgrrhrrirrjrrHGenerator[bytes, None, None])rfrrcrrgrrhrrirrjrrHAsyncGenerator[bytes, None])rKrLrMrNrOr5rrrrnrorprxrrrrQrRr7r4r(r(^s8|6: +.+3 +  +(AAFAAF4 "      #      #     D    (  !   #   py y  y # y  y y #y  &y vp'p' p' ( p' ! p'p'#p' %p'r7cL\rSrSr%S\S'S\S'S\S'S\S'S\S 'S rg ) _Refusali Optional[str]r=rboolhas_prefill_claimDict[str, Any]usageeventrRN)rKrLrMrNrPrQrRr7r4rrs+ SS  (r7rc.\rSrSr%SrS\S'S\S'Srg) riz6Splice context for fallback hops; `None` for stream A.List[Dict[str, Any]]rryrkrRNrKrLrMrNrOrPrQrRr7r4rrs@$$ Jr7rc.\rSrSr%SrS\S'S\S'Srg) rizWA fallback hop whose request failed; stamps `recommended_model` when it ends the chain.ryrkz Optional[int]rrRNr rRr7r4rrs J Rr7rcl\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S'S\S'Srg) _HopOutcomeiz*The outcome of consuming one hop's stream.zOptional[_Refusal]rrrkzOptional[Dict[str, Any]] start_eventr blocksrrrrlast_fallback_torRNr rRr7r4rrsD4 E :))0  \O^ LT##3r7rc\rSrSr%SrS\S'S Sjr\SSj5rSSjr SSjr SS jr SS jr S r g )riu~Consumes one hop's SSE events, producing the frames to forward to the client while accumulating its content blocks. Events are held until the hop produces output (a content block or a terminal event), so a refusal that arrives before any output — a pre-stream decline — leaves no trace on the wire and chains silently. On open, stream A's held `message_start` is flushed in its original wire bytes; a spliced hop's is suppressed when the wire is already open, or emitted with its `id` rewritten to the primary's when this hop's start opens the wire. Queued seam frames for every hop reached so far are flushed right after. A spliced hop has its block indices shifted by `index_base` and its terminal message_delta's usage rewritten to the `usage.iterations` chain shape. A refusal that can be chained — an entry remains, and either a `fallback_credit_token` was minted or nothing has streamed yet — ends the hop early: open blocks are closed, the terminal message_delta + message_stop are suppressed, and the refusal is set on the outcome so the caller can issue the next hop. Any other refusal is logged and passes through to the client. z_HopOutcome | Nonerc[U5UlX lX0lX@lXPlX`lSUlSUlSUl SUl /Ul SUl SUl SUlg)NF) _BlockTracker_tracker _has_next_splice _wire_open _primary_id _seam_frames_model _start_usage _start_event _held_start_held_opened_last_fallback_tor)r3rrrrrrs r4r5_HopReader.__init__sg&j1 ! #%'"& 373737,.  -1 r7cUR$r0)r"r2s r4r_HopReader.opened' ||r7c  [[UR55nUbURS5OSnURnUS:Xa|Uby[URS55nUbNURS5n[ U[ 5(aUOSUl[URS55UlX l Xl /$US:XaUbUR5n[URS55nUb`URS5S :XaK[URS 55n U bU RS5OSn [ U [ 5(aXl URRU5 Ub/UQ[SU5P$/UQ[!U5P$US :XaPUbMUR5nURR#U5 Ub/UQ[S U5P$/UQ[!U5P$US :XaPUbMUR5nURR%U5 Ub/UQ[S U5P$/UQ[!U5P$US :XGa UGb[URS55=(d 0n U RS5S:XGa [U RS55n U bU RS5S:XaU OSn U bU RS5OSn[ U[ 5(a U(aUOSnUR&(+=(a URR)5(+nUR*(Ga"UcU(Ga[-[URS55UR5n[/URR155nSUl UR2R55 [7[9UU bU RS5OSU SL=(a U RS5SLUUS9URURURR)5URR:UR&URS9UlU$U(d[>RAS5 O[>RAS5 UR5nUbU RS5S:Xa/[U RS55n U bU RCSS5 [URS55=(d 0n/URDQ[GUURH5PUS'UUS'/UQ[S U5P$/UQ[!U5P$UR&(dUR2RKU5 /$[!U5/$)z:Process one event, returning the frames to forward for it.Ntype message_startrrkr content_block_start content_blockfallbacktocontent_block_deltacontent_block_stop message_deltadeltar|rm stop_detailsfallback_credit_tokenrfallback_has_prefill_claimT)r=rrr r rrkrrrrrzvanthropic-sdk: BetaRefusalFallbackMiddleware: refusal stop_details has no fallback_credit_token; surfacing the refusalzkanthropic-sdk: BetaRefusalFallbackMiddleware: refusal but no fallback entries remain; surfacing the refusalrecommended_modelr)&r _safe_jsondatar<rr{ryrrrr _openr#rstart_emit_passthrough_sser2stopr"content_blocksr _backfilllistclose_open_blocksr!clearrrrrr)r setdefaultr_serving_iteration_entryrkr)r3sser  event_typerrrkrr,r.rr2r3detailsr= pre_streamr s r4feed_HopReader.feed+sCHH-.*/*;UYYv&   (U->uyy34G" G,'1%'='=e4 $,W[[-A$B! % " I 0 0U5FZZ\F$UYY%?@M(]->->v-F*-Tm//56.0n266'?$h,,-5* MM   &%?&>% 5u=> 6v5/45  0 0U5FZZ\F MM   &%?&>% 5u=> 6v5/45  / /E4EZZ\F MM  u %%>&=% 4e<= 6v5/45  ? *u/@UYYw/06BEyy'94' .(AB *6*B|GWGWX^G_clGl,rv@G@S $;>>u'8J%huyy/A&BDDUDUVE!$--"A"A"CDF(,D$JJ$$&#. ("'@G@SW[[%??3V3-c23 3|| JJ  c "I!%&&r7cUR(a/$SUl/nURc2URb$UR[ UR55 OUR (dUR bt[R"UR 5n[URS55nUbURbURUS'UR[SU55 URUR5 URSUR55 SUlURR!5 U$)zOpen the wire for this hop: its message_start (raw for stream A; suppressed or id-rewritten for a spliced hop), the queued seam frames, then anything else held.TNridr*c38# UHn[U5v M g7fr0)r=).0helds r4 #_HopReader._open..sD&t,,)r"rr rr=rr_copydeepcopyrr<rr<extendrr!rC)r3rrrs r4r:_HopReader._opens <<I   << + .t/?/?@AT%6%6%B..):):;K{y9:G"t'7'7'C $ 0 0 MM%= > d''( DDD  r7cbURcUR(a/$UR5$)zCFrames still owed when the stream ends without a chainable refusal.)rr"r:r2s r4 finish_frames_HopReader.finish_framess# << #t||Izz|r7c URb UR$[SURURURR 5URR URURS9$)zCThe outcome once the hop's stream is fully consumed (or cut early).Nr6) rrrrrr?rr"r#r2s r4r_HopReader.finishsc << #<< ++))==//1}}//<<!33  r7)rr!r r#rr"rrrrrrrrN)rrrrrz_SpliceInfo | Nonerrr str | Noner list[bytes]rHrI)rHr)rFrrHr^rHr^)rHr)rKrLrMrNrOrPr5propertyrrJr:rYrrQrRr7r4rrs. U  #   ! 2x't.  r7rc## [R"U5H.nURU5HnUv M URcM. O UR 5HnUv M UR 5$7f)zKFeed one hop's SSE events through `reader`, yielding the frames to forward.)r raw_eventsrJrrYrrgrrFrs r4rrse  *[[%EK& >> %  + %%' ( ==?s AA6/A6c# [R"U5ShvN nURU5HnU7v M URcM5 UR 5HnU7v M gNN N!7f)uFeed one hop's SSE events through `reader`, yielding the frames to forward. The outcome is read from `reader.finish()` afterwards — async generators cannot return a value. N)rrbrJrrYrcs r4rrsa !++H5c[[%EK& >> % %%' ( 5s+A0A.A,A.)A0A0,A..A0c\rSrSr%SrS\S'S\S'S\S'S \S 'S\S 'S \S 'S \S'S \S'S\S'S\S'S\S'S!Sjr\S"Sj5rS#Sjr S$Sjr S%Sjr S&Sjr S'Sjr S(SjrS)SjrSrg )*riz9Bookkeeping shared across the hops of one spliced stream.rrrrr]rry primary_modelr= List[Any]rpartialrr last_refusalzDict[str, Any] | Nonelast_start_eventr rcXl/Ulgr0)_body_pending_seams)r3rcs r4r5_ChainState.__init__s +-r7cURceU"U5n[URS5=(d S5UlURUlUR Ul[UR=(d 0RS55nUbURS5OSn[U[5(aUOSUl URRUl /Ul URR(a[UR5O/UlUR"=(d URUlURUlURUl[+URUR5UlU$)z3The chain state after stream A's chainable refusal.NrkrlrrM)rryr<rfrrrrrr{rr=rr_to_prefill_blocksrrhrrrirj_declined_iteration_entriesr)clsrcrr start_messagestart_ids r4r_ChainState.begin s)***D !$((7"3"9r:"--!.. '"5"5";!@!@!KL .;.G=$$T*T'1(C'@'@8doo++  >Eoo>_>_*7>>:eg #33Ju7J7J$__!(!4!46wH[H[\ r7c URnU=RS- slURR[SSU[ UR XR R5S.5[SSUS.5/5 Xlg)zQueue the reached hop's `fallback` seam block at the next monotonic index. Queued seams are flushed by the hop reader once output reaches the wire, so a chain of pre-stream declines lines its seams up after the serving hop's message_start. rdr+)r)r.r,r0r)r.N)rrmrVr<rrrir)r3r seam_indexs r4r_ChainState.queue_seam#s__  1 "") 5!+)4T__hPaPaPjPj)k*5IT^,_`  #r7c,[UR5$r0)rArmr2s r4r_ChainState.pending_seam_frames;sD''((r7cFSUlURR5 g)NT)rrmrCr2s r4r_ChainState.mark_opened>s !!#r7c6/URQURQ$r0)rrhr2s r4r_ChainState.continuationBs**T\\**r7c40UREUER5VVs0sHup4US:wdM X4_M nnnURbURUS'U(a4URS5n/[ U[ 5(aUO/QSUS.PUS'U$s snnf)uRThe hop's request body: the refused request's, with the entry's overrides merged over it and extended by the continuation. The server-side `fallbacks` param is stripped — it is mutually exclusive with a credit-token retry. When the refusal granted no prefill claim the appended turn is omitted entirely and the same-body form is sent. r^r4messages assistant)rolecontent)rlitemsr=r<r{rA)r3rrkeyvaluercrs r4r_ChainState.hop_bodyEs>U =Te=T=Z=Z=\s=\zs`cgr`r  =\s :: !,0JJD( ) xx +H (488(b $> D   ts BBcURceURRUlX0lURR(a[ UR 5O/UlURR[URU55 URUl URbURUl URUl g)z7Fold a refused hop's outcome in, readying the next hop.N)rr=rrrprrhrrVrqrirrjr)r3rrkrs r4r_ChainState.absorb_refusalXs***__**  =D__=^=^)'..9df  :7??ERS#OO    *$+$7$7D !!,,r7cr/nUR(dURbt[R"UR5n[ UR S55nUbUR bUR US'UR[SU55 URUR5 [R"URR5n[ UR S55nUb>[ UR S55nUb!URS;a UROSUS'[ UR S 55=(d 0n[R"UR5US 'XS 'UR[S U55 UR[S S S 055 U$)u+Degrade to the suppressed refusal when every remaining entry failed over HTTP: replay its message_delta verbatim — `recommended_model` stamped from the final failure (the failed model for capacity errors, `null` otherwise) and `usage.iterations` carrying the recorded chain — then message_stop. NrrMr*r2r3)iir7r rr1 message_stopr))rrjrTrUrr<rrr<rVrmrir rrkr) r3rrrrr r2rHr s r4r#_ChainState.terminal_failure_framesdsS!~~$"7"7"C..)>)>?K{y9:G"t'B $ MM%= > d))*t006677+,  uyy89G"@GR\@\w}}bf+,7+,2#nnT__=lg eOU34 eNV^,DEF r7) rlrmrrrirjrrhr=rN)rcrrHrI)rcrrrrHr)rryrHrIr_rG)rH list[Any])rr&rrrHr)rrrkryrrrHrI)rrrHr^)rKrLrMrNrOrPr5 classmethodrrrrrrrrrQrRr7r4rrsCO;O=2;  O O++$$I.,#0)$+& -r7rcURRS5n[U[5(a|U(auS[ SU55nUVs/sHoDcM0UESS0EPM nnU(a?[ U5S:Xa.[USRS5[ 5(dXSS'U$[SXR5/$s snf) u3The `usage.iterations` entries a declined hop contributes to the chain. The hop's refusal self-reports its iterations: adopt them, retyped to `message` (every one of them declined — a server-stitched envelope labels its last hop `fallback_message`). A single-entry self-report describes the hop itself and gains its model — `model_label`, the caller-spelled primary or the chain entry's id — when the wire didn't name one; a multi-entry self-report (a server-tool loop) is kept verbatim. Without a self-report, one entry is built from the refusal's usage. rc38# UHn[U5v M g7fr0)r)rOrs r4rQ._declined_iteration_entries..sQ5PE5PrSrgr)rrdrrk)r r<r{rArrwry_to_iteration_usage)rm model_labelreported dict_entriesrentriess r4rqrqs}}  .H(D!!hQT+x5PQ S_(uS_%)EE)E69)ES_(u 7|q GAJNN74KS)Q)Q&1 7#N  ; F GG )vs C CcURS5n[U[5(aCU(a<[[ SU5S5nUb!0UESURS5=(d US.E$[ SX5$)zThe serving hop's `fallback_message` completer entry: its own self-reported iteration relabeled, or one built from its delta usage.rrgrAfallback_messagerk)r)rk)r<r{rArrr) delta_usagerkrlasts r4rErEsm|,H(D!!h[(3B78  \d\$6'ARA[V[\ \ 15 FFr7cf\rSrSr%SrS\S'S SSjjrSSjrSSjrSSjr SS jr SS jr S r g )riaBlock bookkeeping for one stream of the splice: accumulates each content block from its deltas (for the continuation prefill), shifts wire indices by `index_base` so they stay monotonic across hops, and tracks which blocks are still open so a refusal that cuts mid-block can close them. rrc8XlXl/Ul/Ulgr0) _index_baser_blocksr:)r3rs r4r5_BlockTracker.__init__s%$9; " r7cPURVVs/sHupUPM snn$s snnf)z/The accumulated content blocks, in start order.)r)r3_blocks r4r?_BlockTracker.content_blockss &*ll3l(!l333s"cpURS5n[U[5(dg[URS55nURR X#b [ U5O045 X R-nXAS'URR U5 [URUS-5Ul g)z7Track a content_block_start, shifting `event["index"]`.r.Nr,rd) r<r{rrrrdictrr:maxr)r3r r.r,shifteds r4r;_BlockTracker.starts '"%%%  ?!;<  U;TD$7Z\]^*** g '"doow{;r7cURS5n[U[5(dg[URS55nUb[ UR X#5 X R -US'g)zQApply a content_block_delta to its accumulating block, shifting `event["index"]`.r.Nr2)r<r{rr _apply_deltarr)r3r r.r2s r4r2_BlockTracker.deltasY '"%%% 7+,   u 4!1!11gr7cURS5n[U[5(dgX R-nX1S'X0R;aURR U5 [ URUS-5Ulg)z6Track a content_block_stop, shifting `event["index"]`.r.Nrd)r<r{rrr:removerr)r3r r.rs r4r>_BlockTracker.stopsg '"%%% *** g jj JJ  g &doow{;r7c## URHn[SSUS.5v M URR5 g7f)z4content_block_stop events for any blocks still open.r0rwN)r:r<rC)r3r.s r4rB_BlockTracker.close_open_blockss8ZZE,7KV[.\] ]  sAA)rrr:rN)r)rrrHrI)rHlist[dict[str, Any]])r rrHrIrHzIterator[bytes]) rKrLrMrNrOrPr5r?r;r2r>rBrQrRr7r4rrs/ O8#4 <2 <r7rc2^[U4SjU5S5nUcgURS5nUS:XaK[URS5=(d S5[URS5=(d S5-US'gUS:XaK[URS5=(d S5[URS 5=(d S5-US'gUS :XaWURS 5n[U[5(d/nXSS '[ S U5R URS 55 gUS:XaK[URS5=(d S5[URS5=(d S5-US'gUS:XaURS5US'gg)zAApply a content_block_delta to the accumulating block at `index`.c3<># UHupUT:XdM Uv M g7fr0rR)rO block_indexrr.s r4rQ_apply_delta..sQ&.KK5# UH!n[U5T;dM[U5v M# g7fr0)ry)rOrexistings r4rQ+_with_middleware_headers..Cs$WEDSYh=Vic$iiEs,,z, Nzfallback-refusal-middleware)headers)rHeadersrrr{ryr<splitstriprfromkeysrjoinfilterrsr r#) rfrXkvrr additionsrrs @r4rqrq:smmgoo.C.C.E\.EdaTUWZI[TQT.E\]aabrtvwG+2==+=>+=% +=>H WEWWI ' 5 5 7Y 71779HX;Xtqt 7GY)$(IIfTG;Pi;P.Q$R ! << g}Eb7c d< ee ]>YsE E ?EE5Ect[U[5(a#URbURR$g)zEThe refusal's minted credit token; only the beta surface carries one.N)r{r$r3r4rs r4r}r}Js/';''G,@,@,L##999 r7ct[U[5(a#URbURR$g)zOThe policy category that caused the refusal; only the beta surface carries one.N)r{r$r3rrs r4r~r~Qs/';''G,@,@,L##,,, r7cSSU0SU0SUS.S.$)zBThe synthetic `fallback` content block marking one model boundary.r-rkrm)r)r)r)fromr.triggerrR)rrrs r4rrXs)*%!%8<  r7c [[URRS555nUb$[ UR S5[ 5(dg[0UES/UQ[SUS5Q0E5RS5nURR5nSH nXT;dM XE M [R"URUUURS9$)zA copy of the served hop's response with `seams` prepended to its `content`, or `None` when the body isn't the expected message shape. The caller has already parsed the response, so its body is buffered. utf-8Nrrgzcontent-encodingzcontent-length)rrrrf)rr8rdecoder{r<rArrencoderrsrResponserrf)originalrrrcrheaders r4_seamed_http_responserbs z("2"2"9"9'"BCDGjY)?FF _'_9.^.^['R[J\8].^_ ` g gho pD##%G8  9 >>((   r7c [URU5nUcU$[UURURSUR UR URS9$NFr)rrtrrrrrrrgrrs r4rrxs^  6 6 >C {  !!''!!,, r7c [URU5nUcU$[UURURSUR UR URS9$r)rrtrrrrrrrs r4rrs^  6 6 >C {  !!''!!,, r7c(0UEUEnU(aX#S'U$)zThe non-streaming retry body: the fallback entry merged whole over the original params, plus the refusal's credit token when it minted one.r4rR)rcr- credit_tokenmergeds r4rrs$211F*6&' Mr7cP[R"U5$![a gf=fr0)rloadsr)rs r4r8r8s(zz$ s  %%c,[R"USS9$)N)r:) separators)rdumpsrs r4rrs ::e 33r7c>[U5(a [SU5$S$)Nr)rrrs r4rrs,3ENN4 % (DDr7cl[R"UR55$![a gf=fr0)rrreadrrgs r4rrs.zz(--/** s #& 33c# [R"UR5IShvN 5$N![a gf=f7fr0)rrareadrrs r4rrs7zz 00110 s,A#202A2 ?A?AcF[U[U5S9RS5$)Nr r9r)_serialize_sserr)r payloads r4r<r<s K,@ A H H QQr7cUR(a-SRUR5S-RS5$[URUR S9RS5$)zForward a decoded event in its original wire bytes, preserving SSE fields beyond `event:`/`data:` (`id:`, `retry:`, comment lines). Falls back to re-serializing for events with no raw lines.  z rr)rrrrr r9)rFs r4r=r=sN  ww #''"V+33G<<   9 @ @ IIr7cjSnUb USUS3- nURS5H nUSUS3- nM US-$)zSerialize an event back to its SSE wire form (`event: ...\ndata: ...\n\n`). Multi-line `data` is emitted as one `data:` line per line, matching the spec. The inverse of the decoder behind `Stream.raw_events`. rlzevent: r zdata: )r)r r9rlines r4rrsR C  r"" 4  vR  ! :r7c  U=(d 0nUUURS5=(d SURS5=(d SURS5=(d SURS5=(d SURS5S.$)N input_tokensr output_tokenscache_read_input_tokenscache_creation_input_tokenscache_creation)r)rkrrrrr)r<)r)rkr us r4rrsp  An-2/41#$55)B#C#Hq'(uu-J'K'Pq%% 01 r7cU=(d 0n0UEU=(d 0EnUR5H$up4UbM URU5cMXX#'M& U$)z0Fill `None` fields on `primary` from `fallback`.)rr<)primaryr-rrrs r4r@r@sS~2H9X9'-R9Ciik  =X\\#.:}CH" Jr7cURR5nSH nX2;dM X# M [R"URUUUR S9$)zA synthetic response standing in for `original`, with `stream` as its body. The spliced frames are emitted post-decode, so the original's content-encoding/length headers no longer describe the body. r)rrrvrf)rrsrrrrf)rrvrrs r4rrsX##%G8  9 >>((   r7cF\rSrSrSSjr\SSj5r\S Sj5rSrg) ricXlgr0_framesr3rs r4r5_FrameByteStream.__init__ r7cUR$r0rr2s r4__iter___FrameByteStream.__iter__ r'r7c8URR5 gr0)rrr2s r4r_FrameByteStream.close s r7rN)rrrHrIrrG) rKrLrMrNr5rrrrQrRr7r4rrs/r7rcF\rSrSrSSjr\SSj5r\S Sj5rSrg) ricXlgr0rrs r4r5_AsyncFrameByteStream.__init__rr7cUR$r0rr2s r4 __aiter___AsyncFrameByteStream.__aiter__r'r7cT# URR5IShvN gN7fr0)rrr2s r4r_AsyncFrameByteStream.aclosesll!!###s (&(rN)rrrHrI)rHAsyncIterator[bytes]rG) rKrLrMrNr5rr'rrQrRr7r4rrs/$$r7r)rghttpx.ResponserrrHz#Generator[bytes, None, _HopOutcome])rgr,rrrHr+)rmrrryrHr)rrrkryrHr)rz list[tuple[int, dict[str, Any]]]r.rr2rrHrI)rrrHr)rcrrHr)rfrrXr*rHr)rzMessage | BetaMessagerHr])rryrryrr]rHr)rr,rrrHzhttpx.Response | None)rgrrrrHr)rgrrrrHr)rcrr-r&rr]rHr)rryrHr)rrrHry)rrJrHr)rgr,rHr)r ryrrrHbytes)rFrrHr-)r r]r9ryrHry)r)z&Literal['message', 'fallback_message']rkryr rrHr)rrr-rrHr)rr,rvz,httpx.SyncByteStream | httpx.AsyncByteStreamrHr,)g __future__rrsrTrloggingtypingrrrrrr r r r r r contextvarsrrtyping_extensionsrrr_utilsr_modelsr_requestr _responserr _streamingrrr _exceptionsr _middlewarerrr _base_clientr types.messager!_stainless_helpersr#types.beta.beta_messager$types.anthropic_beta_paramr%types.beta.beta_fallback_paramr&__all__ getLoggerr)rPrr+r'r9r;r(rrrrrrrrrqrErrrprrrqr}r~rrrrrr8rrrrr<r=rrr@rSyncByteStreamrAsyncByteStreamrrRr7r4rDs "     */  "6>>)>>)$.2<?#  ''(BC^C0O -O>**<9CCblp8q5qS]*BSO W 'JW 'z (y ()S)S3)34[ [ |  SSlH,G;;B4,B3> f ,  4ERJ   0 9< EZ  &R( u++  $E11 $r7