ÁjUddlmZddlZddlZddlZddlmZmZm Z m Z m Z m Z m Z mZmZmZmZddlmZmZddlmZmZddlZddlmZddlmZdd lmZdd lm Z m!Z!dd l"m#Z#m$Z$m%Z%dd l&m'Z'dd l(m)Z)m*Z*m+Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9ddgZ:ejvdZdZ?de=d< dXdZ@Gd dZAed!d"ZBd#e=d$<ed%d&"ZCd'e=d(<Gd)de*ZDGd*d+eZEGd,d-eZFGd.d/eZGGd0d1eZHGd2d3ZIdYd4ZJdZd5ZKGd6d7ZLd[d8ZMd\d9ZNGd:d;ZOd]d<ZPd^d=ZQd_d>ZRd`d?ZSdad@ZTdadAZUdbdBZVdcdCZWdddDZXdedEZYdfdFZZdgdGZ[dhdHZ\didIZ]djdJZ^dkdKZ_dldLZ`dldMZadmdNZbdndOZcdodPZd dpdQZedqdRZf drdSZgGdTdUejZiGdVdWejZky)s) 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)BetaFallbackParam)BetaFallbackCreditTokenParamBetaFallbackStateBetaRefusalFallbackMiddlewarezanthropic.lib.middlewarezlogging.Loggerlogz /v1/messages)zfallback-credit-2026-07-01tuple[AnthropicBetaParam, ...] DEFAULT_BETASc |ddS)uThe retry's `fallback_credit_token`, in the object form. `best_effort` keeps the retry serving even when redemption fails — a bare string would 400 the hop on any token-layer failure. best_effort)tokenmode)r/s J/tmp/pip-target-k_scjv0h/lib/python/anthropic/lib/middleware/_fallbacks.py_credit_token_paramr35s M 22c6eZdZUdZded< ddZd dZd dZy) r(u{Tracks 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 | Noneindexcd|_yN)r6selfs r2__init__zBetaFallbackState.__init__Ns  r4ctj|}tjgtj||Sr8)_fallback_stateset_fallback_state_tokensget)r:r/s r2 __enter__zBetaFallbackState.__enter__Qs:##D)""#I%;%?%?%A#I5#IJ r4ctj}tj|ddtj |dy)N)r?r@r>r=reset)r:exc_infotokenss r2__exit__zBetaFallbackState.__exit__Vs6'++-""6#2;/fRj)r4NreturnNone)rIr()rEobjectrIrJ)__name__ __module__ __qualname____doc____annotations__r;rArGr1r4r2r(r(>s#   *r4anthropic_beta_fallback_state)defaultz$ContextVar[BetaFallbackState | None]r=$anthropic_beta_fallback_state_tokensr1z7ContextVar[tuple[Token[BetaFallbackState | None], ...]]r?ceZdZdZdd ddZeddZeddZddZddZ dd Z dd Z dd Z dd Z dd Zy)r)uMiddleware 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. Each `fallbacks` entry is a patch against the ORIGINAL request params: a field set to a value overrides it, a field explicitly `None` unsets it, an absent field keeps the original value; `output_config` patches its subfields the same way one level deep. Hops never compound — every hop patches the original params, never the previous hop's patched request. Non-streaming: when a response comes back with `stop_reason: "refusal"`, the request is retried with each entry of `fallbacks` applied as a patch to the original params — passing along the refusal's `fallback_credit_token` (in the object form, with `mode: "best_effort"`) 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)betascbt||_|tn t||_d|_y)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-07-01",)`; pass `()` to send none. NF)tuple _fallbacksr,_betas_warned_missing_state)r: fallbacksrUs r2r;z&BetaRefusalFallbackMiddleware.__init__s)  *',}m%, %*"r4c |j|}|||Stj}|j|}|j |}t ||j }t|}|dk(r|nt||j|}|j|}||} | jjs| S|jrS|dz} | t|jk\r| S|j||t!|jdxsd| || |S|} | } t!|jdxsd} g}| t|jdz kr"| jjr | j#}t%|t&t(fr|j*dk7rn| dz } || t-|}t/|}||jt1||j| |} | jjr9t!|j| d}|j3t5| |||} | t|jdz kr| jjr |rW| jjrA| j#}t%|t&t(fr|j*dk7r t7| |S| SNrCbodymodelrequestr_ initial_modelresponse call_next first_hoppinrefusal)_applicable_bodyr=r@ _start_index _make_pin_with_middleware_headersrY_strip_seam_blocks _apply_hoprXcopy http_response is_successstreamlen_splice_fallback_streamstrparse isinstancer!r$ stop_reason _credit_token_refusal_category _merged_bodyappend _seam_block_prepend_seam_blocksr:rdrgr_state start_indexri initial_bodyinitial_requestrfrhr6res from_modelseamsmessager/categoryto_modelserveds r2handlez$BetaRefusalFallbackMiddleware.handles$$W- <W% %##%''. nnU#+7DKK@ "$'*b0tjtWbGc6d !,,L,9_-%%00O >>#aIC00//'!,"2"27";"ArB!##0 ))'28b9 &(c$//*Q..33D3D3O3OiikGg'=>'BUBUYbBb QJE J!'*E(1HGLLl4QVAWY^._L`aC  ++tu5g>? [XxHI% c$//*Q..33D3D3O3O S&&11YY[F&7K"89f>P>PT]>],C77 r4c 4K|j|}|||d{Stj}|j|}|j |}t ||j }t|}|dk(r|nt||j|}|j|}||d{} | jjs| S|jrS|dz} | t|jk\r| S|j||t!|jdxsd| || |S|} | } t!|jdxsd} g}| t|jdz kr2| jjr| j#d{}t%|t&t(fr|j*dk7rn| dz } || t-|}t/|}||jt1||j| |d{} | jjr9t!|j| d}|j3t5| |||} | t|jdz kr| jjr|r_| jjrI| j#d{}t%|t&t(fr|j*dk7r t7| |S| S77T7q77Bwr])rkr=r@rlrmrnrYrorprXrqrrrsrtru_splice_fallback_stream_asyncrwrxryr!r$rzr{r|r}r~r_prepend_seam_blocks_asyncrs r2 handle_asyncz*BetaRefusalFallbackMiddleware.handle_asyncs$$W- <"7++ +##%''. nnU#+7DKK@ "$'*b0tjtWbGc6d !,,L,9"?33%%00O >>#aIC0055'!,"2"27";"ArB!##6 ))'28b9 &(c$//*Q..33D3D3O3OIIK'Gg'=>'BUBUYbBb QJE J!'*E(1H!',,LtW\G]_d4e,"fggC  ++tu5g>? [XxHI% c$//*Q..33D3D3O3O S&&1199;&F&7K"89f>P>PT]>]2#u== ,"42(h'saLL BL:L;C%L L!BL!L"BL(+LL8LLLLLc`t|j}tj|j}|j rP|j jdk7s3|jtk7s |jjddk7s|y|jd td|S)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-07-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_dictjsonhttpxURLurlrXmethodlowerpath_MESSAGES_PATHparamsr@r)r:rdr_rs r2rkz.BetaRefusalFallbackMiddleware._applicable_bodyHs %ii $~~##%/xx>)zz~~f%/| 88K , 0  r4c| |jy|j}d|cxkrt|jks'ntd|dt|jd|S)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. rCzBetaFallbackState.index z! is out of bounds for a chain of z? fallback(s); was the state shared with a different middleware?)r6rurXr)r:rrs r2rlz*BetaRefusalFallbackMiddleware._start_indexbsk =EKK/kk [73t#77 *;-7Xt'((gi r4cdfd }|S)zUPin requests sharing the state to the entry being tried (or warn that there is none).cl|_yjsd_tjdyy)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.)r6rZr*warning)r6r:rs r2riz4BetaRefusalFallbackMiddleware._make_pin..pinus7 # //-1* &0r4)r6intrIrJr1)r:rris`` r2rmz'BetaRefusalFallbackMiddleware._make_pinrs  r4c |j|||||||}tt|jt ||j |j d|j|j|jS)u9Wrap the refusable stream in a response whose body passes events through until a retryable refusal, then splices the fallback chain's events on. `body` is the original request params — every hop patches it, never the previous hop's patched body; `initial_model` is the model the initial request actually queried (the pinned entry's when a state pin applied). Closing the returned response (or the `Stream` parsed from it) tears down whichever stream is being read and abandons any in-flight fallback request. rcTrawcast_toclientrt stream_clsoptions retries_taken) _spliced_framesr_spliced_http_responserr_FrameByteStream_cast_to_client _stream_cls_optionsr r:rdr_rerfrgrhriframess r2rvz5BetaRefusalFallbackMiddleware._splice_fallback_streams*%%'& &x'='=?OPV?WX%%##++%%"00  r4c |j|||||||}tt|jt ||j |j d|j|j|jS)NrcTr) _spliced_frames_asyncrrrr_AsyncFrameByteStreamrrrrrrs r2rz;BetaRefusalFallbackMiddleware._splice_fallback_stream_asyncs++',  &x'='=?TU[?\]%%##++%%"00  r4c #.K|j}|j} |j} tdddddg} t| | Ed{} | j | | j yy| j d} t j||| } t|t|D]w}||}t|d}|dzt|k}||| j}d}d}tdD]}|j| j||} ||}|jj$r|j} nt'|j}|jj |dk(r?|j(d k(r0|r.tj+d t-|| j.}d}tj!d ||j(t-|t#||j( }n|3|r`| j1|D]}|| | j yy|J|j}| j3|t| j4|t7| j8|| j:| j<| j?} t|| Ed{} | j@r| jC| j| | j yy|j d} | jE| ||z | | j yy7#t$r0}tj!d ||t#|d }Yd}~md}~wwxYw7#| | j wwxYwwNrTF) index_basehas_nextsplice wire_open primary_id seam_framesrar`r"r^zOanthropic-sdk: BetaRefusalFallbackMiddleware: fallback request to %s failed: %s)rastatusizanthropic-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) iterationsra)#rXrr _HopReader _drive_hoprefusedclose _ChainStatebeginrangerurw continuationrqhop_body Exceptionr*error _HopFailurers _read_json status_coder _json_dumpsbaseterminal_failure_frames queue_seam next_index _SpliceInforrrpending_seam_framesopened mark_openedabsorb_refusal)r:rdr_rerfrgrhrir[currentstream_areaderoutcomechainhopentryrarrres_bfailureattempt hop_requesterrerr_bodyframe hop_responses r2rz-BetaRefusalFallbackMiddleware._spliced_framessOO )1)?)?k --HF",Hf!==G&x" #w NN G %%dM7CEYI7S C!#E'N+7S^3C %113 15.2$Qx!G"),,ENN5,4W,"XK  )+ 6**55"'"5"5)%*=*=>H''--/!|(9(9S(@\ g'1 (-zz $ IIr))#H-  *e>O>OPGC!F& "'!>!>w!G$# $6" #1((($22   '#$//%&%2B2B%P#oo$// % 9 9 ; &0 f%EE>>%%'??*" #""$ $$We\BgS Cj" #}>8% m! #.E$"GjF" #sN,M=L< M=N.B3M="L?*C=M='N;BM==M;>-M=+N?(M=(N<M=? M8$M3,M=3M88M==NNc BK|j}|j} |j} tdddddg} t| | 23d{} | 7 6| j } | j  | | j d{7yy| j d{7d} tj||| }t|t|D]}||}t|d}|dzt|k}|||j}d}d}tdD]_}|j|j||} ||d{7}n;#t$r/}t j#d ||t%|d }Yd}~nd}~wwxYw|jj&r|j} nt)|jd{7}|jj d{7|dk(r@|j*d k(r1|r/t j-d t/||j0}d}t j#d ||j*t/|t%||j* }n|=|r|j3|D]} |  | | j d{7yy|J|j}|j5|t|j6|t9|j:||j<|j>|jA} t|| 23d{7} | 6| j } | jBr|jE| j | | j d{7yy|j d{7d} |jG| || | | j d{7yy#| | j d{7wwxYwwr)$rXrrr_drive_hop_asyncfinishracloserrrrurwrrqrrr*rrrs_read_json_asyncrrrrrrrrrrrrrrr)r:rdr_rerfrgrhrir[rrrrrrrrrarrrrrrrrrs r2rz3BetaRefusalFallbackMiddleware._spliced_frames_asyncasOO )1)?)?b '--HF 0&A  e  AmmoG&b"nn&&&#a//# # #G%%dM7CEYI7I C!#E'N+7S^3C$113 6:.2$Qx!G"),,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$# $2"nn&&&#/((($22   '#$//%&%2B2B%P#oo$// % 9 9 ; $4L&#I  %K$J --/>>%%'??* "nn&&&# #))+++$$We\BSI CV"nn&&&#w"nn&&&#s"P)O>A A A O>AO>4P B  PO>$B'%B(O> E EE O> F)$F O>F?O>G"O>:G=;B1O>,PKP A?O>M M MAO>P'N*(P/O>OO>!P6O97P>PPPP)r[zIterable[BetaFallbackParam]rUz#Iterable[AnthropicBetaParam] | NonerIrJ)rdrrgrrIAPIResponse[Any])rdrrgrrIAsyncAPIResponse[Any])rdrrIdict[str, Any] | None)rBetaFallbackState | NonerIr)rrrICallable[[int], None])rdrr_dict[str, Any]rerwrfrrgrrhrrirrIr)rdrr_rrerwrfrrgrrhrrirrIr)rdrr_rrerwrfrrgrrhrrirrIGenerator[bytes, None, None])rdrr_rrerwrfrrgrrhrrirrIAsyncGenerator[bytes, None])rLrMrNrOr;rrrrkrlrmrvrrrr1r4r2r)r)hs?J6: +.+3 +  +(BBHBBH4 "& &  &  & # & & & #&  & P      (  !  #   tz z  z  z # z z z #z  &z xq'q' q'  q' ( q'!q'q'#q' %q'r4cDeZdZUded< ded< ded<ded<ded<y ) _Refusal Optional[str]r/rboolhas_prefill_claimDict[str, Any]usageeventN)rLrMrNrPr1r4r2rrs+ SS  (r4rc&eZdZUdZded<ded<y)rz6Splice context for fallback hops; `None` for stream A.List[Dict[str, Any]]rrwraNrLrMrNrOrPr1r4r2rrs@$$ Jr4rc&eZdZUdZded<ded<y)rz[A fallback hop whose request failed; stamps `recommended_model` when it ends the chain.rwraz Optional[int]rNrr1r4r2rrs J Rr4rcdeZdZUdZded< ded< ded< ded < d ed < d ed < ded<y) _HopOutcomez*The outcome of consuming one hop's stream.zOptional[_Refusal]rrrazOptional[Dict[str, Any]] start_eventrblocksrrrrlast_fallback_toNrr1r4r2rrsD4 E :))0  \O^ LT##3r4rcteZdZUdZded< d dZed dZd dZddZ ddZ dd Z y )ruConsumes 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 | Nonerct||_||_||_||_||_||_d|_d|_d|_ d|_ g|_ d|_ d|_ d|_y)NF) _BlockTracker_tracker _has_next_splice _wire_open _primary_id _seam_frames_model _start_usage _start_event _held_start_held_opened_last_fallback_tor)r:rrrrrrs r2r;z_HopReader.__init__+sq&j1 ! #%'"& 373737,.  -1 r4c|jSr8)rr9s r2rz_HopReader.openedD ||r4c p tt|j}||jdnd}|j}|dk(rw|ut|jd}|I|jd}t |t r|nd|_t|jd|_||_ ||_ gS|dk(r||j}t|jd}|Z|jdd k(rFt|jd } | | jdnd} t | t r| |_ |jj||g|td|Sg|t!|S|d k(rN|L|j}|jj#||g|td |Sg|t!|S|d k(rN|L|j}|jj%||g|td |Sg|t!|S|d k(r|t|jdxsi} | jddk(rt| jd} | | jddk(r| nd} | | jdnd}t |t r|r|nd}|j& xr|jj) }|j*r||rt-t|jd|j}t/|jj1}d|_ |j2j5t7t9|| | jdnd| duxr| jddu|||j|j|jj)|jj:|j&|j|_|S|st>jAdnt>jAd|j}|| jddk(r.t| jd} | | jCddt|jdxsi}g|jDtG||jH|d<||d<g|td |Sg|t!|S|j&s|j2jK|gSt!|gS)z:Process one event, returning the frames to forward for it.Ntype message_startrrarcontent_block_start content_blockfallbacktocontent_block_deltacontent_block_stop message_deltadeltarzrj stop_detailsfallback_credit_tokenrfallback_has_prefill_claimT)r/rrrrrrarrrrrzvanthropic-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@r ryrwrrrr_openrr start_emit_passthrough_sser$stoprcontent_blocksr  _backfilllistclose_open_blocksrclearrrrrr*r setdefaultr_serving_iteration_entryrar~)r:sser event_typerrrarrr rr$r%detailsr/ pre_streamrs r2feedz_HopReader.feedHsCHH-.*/*;UYYv&   (U->uyy34G" G,'1%'=e4 $,W[[-A$B! %D "D I 0 0U5FZZ\F$UYY%?@M(]->->v-F*-Tm//56.0n266'?$h,-5D* 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!%&&r4c||jrgSd|_g}|j1|j|jt |jn|j s}|j qtj|j }t|jd}||j|j|d<|jtd||j|j|jd|jDd|_|jj!|S)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.TNridrc32K|]}t|ywr8)r/).0helds r2 z#_HopReader._open..sD&t,D)rr rr~r/rr_copydeepcopyrr@rr.extendrrr5)r:rrrs r2r,z_HopReader._opens <<I   << + .t/?/?@AT%6%6%B..):):;K{y9:G"t'7'7'C $ 0 0 MM%= > d''( DDD  r4cV|j |jrgS|jS)zCFrames still owed when the stream ends without a chainable refusal.)rrr,r9s r2 finish_framesz_HopReader.finish_framess# << #t||Izz|r4c |j |jStd|j|j|jj |jj |j|jS)zCThe outcome once the hop's stream is fully consumed (or cut early).Nr() rrrrr r1rrrr9s r2rz_HopReader.finishsc << #<< ++))==//1}}//<<!33  r4N)rrrrrz_SpliceInfo | Nonerrr str | Noner list[bytes]rIrJ)rIr)r8rrIrKrIrK)rIr) rLrMrNrOrPr;propertyrr<r,rHrr1r4r2rrs. U  #   ! 2x't.  r4rc#Ktj|D]*}|j|D]}||j*n|j D]}||j Sw)zKFeed one hop's SSE events through `reader`, yielding the frames to forward.)r raw_eventsr<rrHrrfrr8rs r2rrsu  *[[% EK  >> %   %%'  ==?s ?A.,A.cKtj|23d{}|j|D]}| |j1|j D]}| y7H6w)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)rrOr<rrHrPs r2rrsr !++H5c[[% EK  >> % %%'  5s+A)A'A%A'(A) A)%A''A)ceZdZUdZded< ded< ded< ded < ded <d ed <d ed <ded<ded<ded<ded< ddZed dZd!dZd"dZ d#dZ d$dZ d%dZ d&dZ d'dZy)(rz9Bookkeeping shared across the hops of one spliced stream.rrrrrJrrw primary_modelr/ List[Any]rpartialrr last_refusalzDict[str, Any] | Nonelast_start_eventrrc ||_g|_yr8)_body_pending_seams)r:r_s r2r;z_ChainState.__init__&s +-r4c|jJ||}||_|j|_|j|_t |j xsijd}||jdnd}t|tr|nd|_ |jj|_ g|_ |jjrt|jng|_|j"xs |j|_|j|_|j |_t+|j|j|_|S)uThe chain state after stream A's chainable refusal. `body` is the original request params (pre-pin) — the base every hop patches; `initial_model` is the model the initial request queried. Nrr>)rrSrrrrrr@ryrwrr/rr_to_prefill_blocksrrUrrrVrW_declined_iteration_entriesr)clsr_rerr start_messagestart_ids r2rz_ChainState.begin*s***D +"--!.. '"5"5";!@!@!KL .;.G=$$T*T'1(C'@8doo++  >Eoo>_>_*7>>:eg #33Ju7J7J$__!(!4!46wH[H[\ r4c |j}|xjdz c_|jjtdd|t |j ||j jdtdd|dg||_y)aQueue 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. r`r)rr6rr"rr6N)rrZrFr.rrrVr)r:r seam_indexs r2rz_ChainState.queue_seamEs__  1 "") 5!+)4T__hPTPaPaPjPj)k*5IT^,_`  #r4c,t|jSr8)r3rZr9s r2rz_ChainState.pending_seam_frames]sD''((r4cFd|_|jjy)NT)rrZr5r9s r2rz_ChainState.mark_opened`s !!#r4c6g|j|jSr8)rrUr9s r2rz_ChainState.continuationds**T\\**r4c6t|j|jDcic]\}}|dk7s ||}}}|jt |j|d<|r/|j d}gt |tr|ngd|d|d<|Scc}}w)uThe hop's request body: the entry applied as a patch against the ORIGINAL request params (never a previous hop's patched body), 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[r&messages assistant)rolecontent)rprYitemsr/r3r@ryr3)r:rrkeyvaluer_rhs r2rz_ChainState.hop_bodygs*4DJJ)F)L)L)N %3RUYdRdCJ   :: !,? ,KD( ) xx +H (48(b $> D   s BBc|jJ|jj|_||_|jjrt |j ng|_|jjt|j||j|_ |j|j|_ |j|_ y)z7Fold a refused hop's outcome in, readying the next hop.N)rr/rrr\rrUrrFr]rVrrWr)r:rrars r2rz_ChainState.absorb_refusal}s***__**   =D__=^=^)'..9df  :7??ERS#OO    *$+$7$7D !!,,r4cLg}|js}|jqtj|j}t |j d}||j |j |d<|jtd||j|jtj|jj}t |j d}|;t |j d}||jdvr |jnd|d<t |j d xsi}tj|j|d <||d <|jtd ||jtd d d i|S)uSDegrade 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. Nrr>rr$r%)iir)rrr# message_stopr)rrWrDrErr@rr~r.rFrZrVrrrar) r:rrrrrr$r:rs r2rz#_ChainState.terminal_failure_framessU!~~$"7"7"C..)>)>?K{y9:G"t'B $ MM%= > d))*t006677+,  uyy89G"@GR\@\w}}bf+,7+,2#nnT__=lg eOU34 eNV^,DEF r4N)r_rrIrJ)r_rrerwrrrIr)rrwrIrJrLrH)rI list[Any])rr&rrrrIr)rrrarwrrrrIrJ)rrrIrK)rLrMrNrOrPr; classmethodrrrrrrrrr1r4r2rr sCO;O=24  O O++$$I.4#0)$+, -r4rcd|jjd}t|tri|rgdt d|D}|Dcgc] }|i|ddi}}|r:t |dk(r*t|djdt s||dd<|Std||jgScc}w) uSThe `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. rc32K|]}t|ywr8)r)r@rs r2rBz._declined_iteration_entries..sQEQrCrTrrr`rra)rr@ryr3rrurw_to_iteration_usage)rj model_labelreported dict_entriesrentriess r2r]r]s}}  .H(D!hQT+x5PQ S_(u%chct)EE)E69)E(u(u 7|q GAJNN74KS)Q&1 7#N  ; F GG )vs B- B-c|jd}t|tr8|r6tt d|d}|i|d|jdxs|dSt d||S)zThe serving hop's `fallback_message` completer entry: its own self-reported iteration relabeled, or one built from its delta usage.rrTrCfallback_messagera)rra)r@ryr3rrrv) delta_usagerarxlasts r2r7r7sl|,H(D!h[(3B78  \d\$6'ARA[V[\ \ 15+ FFr4cPeZdZUdZded< d d dZd dZddZddZddZ dd Z y )r a/Block 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. rrc<||_||_g|_g|_yr8) _index_baser_blocksr,)r:rs r2r;z_BlockTracker.__init__s%$9; " r4cL|jDcgc]\}}| c}}Scc}}w)z/The accumulated content blocks, in start order.)r)r:_blocks r2r1z_BlockTracker.content_blockss&*ll3(!U333s cj|jd}t|tsyt|jd}|jj || t |nif||jz}||d<|jj |t|j|dz|_ y)z7Track a content_block_start, shifting `event["index"]`.r6Nrr`) r@ryrrrr~dictrr,maxr)r:rr6rshifteds r2r-z_BlockTracker.starts '"%%  ?!;<  U=;TD$7Z\]^$*** g '"doow{;r4c|jd}t|tsyt|jd}|t |j ||||j z|d<y)zQApply a content_block_delta to its accumulating block, shifting `event["index"]`.r6Nr$)r@ryrr _apply_deltarr)r:rr6r$s r2r$z_BlockTracker.deltasZ '"%% 7+,   ue 4!1!11gr4c|jd}t|tsy||jz}||d<||jvr|jj |t |j|dz|_y)z6Track a content_block_stop, shifting `event["index"]`.r6Nr`)r@ryrrr,removerr)r:rr6rs r2r0z_BlockTracker.stopsj '"%% $*** g djj JJ  g &doow{;r4c#K|jD]}tdd|d|jjyw)z4content_block_stop events for any blocks still open.r"rbN)r,r.r5)r:r6s r2r4z_BlockTracker.close_open_blockss@ZZ ^E,7KV[.\] ] ^ s>AN)r)rrrIrJ)rIlist[dict[str, Any]])rrrIrJrIzIterator[bytes]) rLrMrNrOrPr;r1r-r$r0r4r1r4r2r r s/ O8#4 <2 <r4r ctfd|Dd}|y|jd}|dk(rAt|jdxsdt|jdxsdz|d<y|dk(rAt|jdxsdt|jd xsdz|d<y|d k(rS|jd }t|tsg}||d <t d |j |jd y|dk(rAt|jdxsdt|jdxsdz|d<y|dk(r|jd|d<yy)zAApply a content_block_delta to the accumulating block at `index`.c34K|]\}}|k(s |ywr8r1)r@ block_indexrr6s r2rBz_apply_delta.. sQ.KK5.hs WDSYh=Vc$iWs&&z, Nzfallback-refusal-middleware)headers)rHeadersrrlryrwr@splitstriprfromkeysrjoinfilterrqr r#) rdrUkvrrn additionsrrs @r2rnrn_smmgoo.C.C.E\daTUWZI[QT\]aabrtvwG+2==+=>% >H WEWWI ' 5 5 7Y11779HX;Xq!tYGY)$(IIfTG;Pi;P.Q$R ! << g}Eb7c d< ee ]>YsD: D: 7E E(Echt|tr"|j|jjSy)zEThe refusal's minted credit token; only the beta surface carries one.N)ryr$r%r&rs r2r{r{os,';'G,@,@,L##999 r4cht|tr"|j|jjSy)zOThe policy category that caused the refusal; only the beta surface carries one.N)ryr$r%rrs r2r|r|vs,';'G,@,@,L##,,, r4cdd|id|id|ddS)zBThe synthetic `fallback` content block marking one model boundary.rrarj)rr)rfromr triggerr1)rrrs r2rr}s)*%!%8<  r4c tt|jjd}|t |j dt syti|dg|td|dijd}|jj}dD] }||vs||= tj|j|||jS)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-8NrkrTzcontent-encodingzcontent-length)rrrkrd)rr*rkdecoderyr@r3rrencoderrqrResponserrd)originalrrr_rheaders r2_seamed_http_responsers z("2"2"9"9'"BCDGjY)?F _'_9.^.^['R[J\8].^_ ` g gho pD##%G8  W   >>((   r4c t|j|}||St||j|jd|j |j |jSNFr)rrrrrrrrrrfrrs r2rrs^  6 6 >C {  !!''!!,, r4c t|j|}||St||j|jd|j |j |jSr)rrrrrrrrrrs r2rrs^  6 6 >C {  !!''!!,, r4ct|td|}t|jd}|Ctt|jdxsi|}|r||d<|S|j dd|S)u`entry` applied as a patch against `body`: a field set to a value overrides it, a field explicitly `None` unsets it (absent from the retried request — not sent as `null`), an absent field keeps the original value. `output_config` patches one level deep: its subfields follow the same set / `None`-unsets / absent-keeps rule against the original request's `output_config`; the whole object is dropped when nothing is left. Always a fresh dict; `body` is never mutated.r output_configN)_patchrrr@r)r_rpatchedrmergeds r2rprpsyT4 0%89GUYY78M /!:;Ar=Q '-GO $ N KK . Nr4ct|}|jD]\}}||j|d|||<!|S)z`overrides` applied flat against `base`: a key set to a value overrides it, a key explicitly `None` unsets it, an absent key keeps the base value. Always a fresh dict.N)rrlr)r overridesrrmrns r2rrsJ4jGoo'! U = KKT " GCL ! Nr4c>t||}|rt||d<|S)zThe non-streaming retry body: the fallback entry applied as a patch against the original params, plus the refusal's credit token when it minted one.r&)rpr3)r_r credit_tokenrs r2r}r}s(h 'F*=l*K&' Mr4cL tj|S#t$rYywxYwr8)rloadsr)rs r2r*r*s(zz$ s  ##c0tj|dS)N)r:) separators)rdumpsrns r2rrs ::e 33r4c4t|r td|SdS)Nr)rrrs r2rrs,3EN4 % (DDr4ch tj|jS#t$rYywxYwr8)rrreadrrfs r2rrs.zz(--/** s "% 11cK tj|jd{S7#t$rYywxYwwr8)rrareadrrs r2rrs8zz 00110 s,A"1/1A1 =A=AcLt|t|jdS)Nrr+r)_serialize_sserr)rpayloads r2r.r.s K,@ A H H QQr4c|jr-dj|jdzjdSt|j|j jdS)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)rrrrrr+)r8s r2r/r/sN  ww #''"V+33G<<   9 @ @ IIr4cdd}| |d|dz }|jdD] }|d|dz } |dzS)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`. rbzevent: rzdata: )r)rr+rlines r2rrsW C  r"" 4 ! vR  ! :r4c |xsi}|||jdxsd|jdxsd|jdxsd|jdxsd|jddS)N input_tokensr output_tokenscache_read_input_tokenscache_creation_input_tokenscache_creation)rrarrrrr)r@)rrarus r2rvrvsp  An-2/41#$55)B#C#Hq'(uu-J'K'Pq%% 01 r4c|xsi}i||xsi}|jD]"\}}| |j|||||<$|S)z0Fill `None` fields on `primary` from `fallback`.)rlr@)primaryrrrmrns r2r2r2.s^~2H9X9'-R9Ciik% U =X\\#.:}CH% Jr4c|jj}dD] }||vs||= tj|j|||j S)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)rrrtrd)rrqrrrrd)rrtrrs r2rr8sa##%G8  W   >>((   r4c8eZdZddZeddZeddZy)rc||_yr8_framesr:rs r2r;z_FrameByteStream.__init__M  r4c|jSr8rr9s r2__iter__z_FrameByteStream.__iter__Prr4c8|jjyr8)rrr9s r2rz_FrameByteStream.closeTs r4N)rrrIrJrrH)rLrMrNr;rrrr1r4r2rrLs/r4rc8eZdZddZeddZeddZy)rc||_yr8rrs r2r;z_AsyncFrameByteStream.__init__Zrr4c|jSr8rr9s r2 __aiter__z_AsyncFrameByteStream.__aiter__]rr4cTK|jjd{y7wr8)rrr9s r2rz_AsyncFrameByteStream.acloseasll!!###s (&(N)rrrIrJ)rIAsyncIterator[bytes]rH)rLrMrNr;rrrr1r4r2rrYs/$$r4r)r/rwrIr')rfhttpx.ResponserrrIz#Generator[bytes, None, _HopOutcome])rfrrrrIr)rjrrwrwrIr)r}rrarwrIr)rz list[tuple[int, dict[str, Any]]]r6rr$rrIrJ)rrrIrr)r_rrIr)rdrrUr+rIr)rzMessage | BetaMessagerIrJ)rrwrrwrrJrIr)rrrrrIzhttpx.Response | None)rfrrrrIr)rfrrrrIr)r_rrr&rIr)rrrrrIr)r_rrr&rrJrIr)rrwrIr)rnrrIrw)rnrKrIr)rfrrIr)rrwrrrIbytes)r8rrIr)rrJr+rwrIrw)rz&Literal['message', 'fallback_message']rarwrrrIr)rrrrrIr)rrrtz,httpx.SyncByteStream | httpx.AsyncByteStreamrIr)l __future__rrqrDrloggingtypingrrrrrr 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&+types.beta.beta_fallback_credit_token_paramr'__all__ getLoggerr*rPrr,r3r(r=r?r)rrrrrrrrr]r7r rr\rornr{r|rrrrrprr}r*rrrrr.r/rrvr2rSyncByteStreamrAsyncByteStreamrr1r4r2r s4"     */  "6>>)>>)$.2<?W#  (g''(BC^C0O -O>3**<9CCblp8q5qS]*BSO j 'Jj '` (y ()S)S3)34[ [ |  [[|H,G;;B4,B3> f ,  * 4ERJ   0 9< EZ  &R( u++  $E11 $r4