AXjUddlmZddlZddlZddlZddlmZmZm 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/ddl0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7ddgZ8ejrdZ:de;d<dZedd Z?d!e;d"<ed#d$ Z@d%e;d&<Gd'de*ZAGd(d)eZBGd*d+eZCGd,d-eZDGd.d/eZEGd0d1ZFdTd2ZGdUd3ZHGd4d5ZIdVd6ZJdWd7ZKGd8d9ZLdXd:ZMdYd;ZNdZd<ZOd[d=ZPd\d>ZQd\d?ZRd]d@ZSd^dAZTd_dBZUd`dCZVdadDZWdbdEZXdcdFZYdddGZZdedHZ[dedIZ\dfdJZ]dgdKZ^dhdLZ_ didMZ`djdNZa dkdOZbGdPdQejZdGdRdSejZfy)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_BETASc6eZdZUdZded< 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)r-selfs i/var/www/html/content_generation/venv/lib/python3.12/site-packages/anthropic/lib/middleware/_fallbacks.py__init__zBetaFallbackState.__init__Ds  ctj|}tjgtj||Sr/)_fallback_stateset_fallback_state_tokensget)r1tokens r2 __enter__zBetaFallbackState.__enter__Gs:##D)""#I%;%?%?%A#I5#IJ r4ctj}tj|ddtj |dy)N)r8r9r7r6reset)r1exc_infotokenss r2__exit__zBetaFallbackState.__exit__Ls6'++-""6#2;/fRj)r4NreturnNone)rCr')r?objectrCrD)__name__ __module__ __qualname____doc____annotations__r3r;rAr4r2r'r'4s#   *r4anthropic_beta_fallback_state)defaultz$ContextVar[BetaFallbackState | None]r6$anthropic_beta_fallback_state_tokensrKz7ContextVar[tuple[Token[BetaFallbackState | None], ...]]r8ceZdZdZdd ddZeddZeddZddZddZ dd Z dd Z dd Z dd Z dd Zy)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)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-06-01",)`; pass `()` to send none. NF)tuple _fallbacksr+_betas_warned_missing_state)r1 fallbacksrPs r2r3z&BetaRefusalFallbackMiddleware.__init__s)  *',}m%, %*"r4c ||j|}|||Stj}|j|}|j |}t ||j }t|}|dk(r|ni||j|}|j|}||} | jjs| S|jr6|dz} | t|jk\r| S|j||| || |S|} | } t|jdxsd} g}| t|jdz kr"| jjr | j!}t#|t$t&fr|j(dk7rn| dz } || t+|}t-|}||jt/||j| |} | jjr9t|j| d}|j1t3| |||} | t|jdz kr| jjr |rW| jjrA| j!}t#|t$t&fr|j(dk7r t5| |S| SNr=bodyrequestrZresponse call_next first_hoppinmodelrefusal)_applicable_bodyr6r9 _start_index _make_pin_with_middleware_headersrT_strip_seam_blocksrScopy http_response is_successstreamlen_splice_fallback_streamstrparse isinstancer!r$ stop_reason _credit_token_refusal_category _merged_bodyappend _seam_block_prepend_seam_blocksr1r]r_rZstate start_indexra initial_bodyinitial_requestr^r`r-res from_modelseamsmessager:categoryto_modelserveds r2handlez$BetaRefusalFallbackMiddleware.handles$$W- <W% %##%''. nnU#+7DKK@ "$'*b0t6^6^Q\A]6^ !,,L,9_-%%00O >>#aIC00//'!!## 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 K|j|}|||d{Stj}|j|}|j |}t ||j }t|}|dk(r|ni||j|}|j|}||d{} | jjs| S|jr6|dz} | t|jk\r| S|j||| || |S|} | } t|jdxsd} g}| t|jdz kr2| jjr| j!d{}t#|t$t&fr|j(dk7rn| dz } || t+|}t-|}||jt/||j| |d{} | jjr9t|j| d}|j1t3| |||} | t|jdz kr| jjr|r_| jjrI| j!d{}t#|t$t&fr|j(dk7r t5| |S| S7777q77BwrX)rer6r9rfrgrhrTrirSrjrkrlrmrn_splice_fallback_stream_asyncrprqrrr!r$rsrtrurvrwrx_prepend_seam_blocks_asyncrzs r2 handle_asyncz*BetaRefusalFallbackMiddleware.handle_asyncs$$W- <"7++ +##%''. nnU#+7DKK@ "$'*b0t6^6^Q\A]6^ !,,L,9"?33%%00O >>#aIC0055'!!## 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== },"40(h'saK5K(BK54K+5CK5=K.>BK5>K1?BK5+K50K318K5+K5.K51K53K5c`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.postbetatrueNrVazSending 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_dictjsonhttpxURLurlrSmethodlowerpath_MESSAGES_PATHparamsr9r)r1r]rZrs r2rez.BetaRefusalFallbackMiddleware._applicable_body5s %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. r=zBetaFallbackState.index z! is out of bounds for a chain of z? fallback(s); was the state shared with a different middleware?)r-rnrSr)r1r{r|s r2rfz*BetaRefusalFallbackMiddleware._start_indexOsk =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.)r-rUr)warning)r-r1r{s r2raz4BetaRefusalFallbackMiddleware._make_pin..pinbs7 # //-1* &0r4)r-intrCrDrK)r1r{ras`` r2rgz'BetaRefusalFallbackMiddleware._make_pin_s  r4c |j||||||}tt|jt ||j |j d|j|j|jS)aHWrap 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. r\Trawcast_toclientrm stream_clsoptions retries_taken) _spliced_framesr_spliced_http_responserk_FrameByteStream_cast_to_client _stream_cls_optionsrr1r]rZr^r_r`raframess r2roz5BetaRefusalFallbackMiddleware._splice_fallback_streamps %% & &x'='=?OPV?WX%%##++%%"00  r4c |j||||||}tt|jt ||j |j d|j|j|jS)Nr\Tr) _spliced_frames_asyncrrrk_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_framesrbr[r"rYzOanthropic-sdk: BetaRefusalFallbackMiddleware: fallback request to %s failed: %s)rbstatusizanthropic-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) iterationsrb)#rSrk _HopReader _drive_hoprefusedclose _ChainStatebeginrangernrp continuationrjhop_body Exceptionr)error _HopFailurerl _read_json status_coder _json_dumpsbaseterminal_failure_frames queue_seam next_index _SpliceInforrrpending_seam_framesopened mark_openedabsorb_refusal)r1r]rZr^r_r`rarVcurrentstream_areaderoutcomechainhopentryrbrrres_bfailureattempt hop_requesterrerr_bodyframe hop_responses r2rz-BetaRefusalFallbackMiddleware._spliced_framessOO )1)?)?k --HF",Hf!==G&x" #w NN G %%dG4EYI7!#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>>%%'??*" #""$ $$We\Bg8j" #}>8% m! #.E$"GjF" #sN,M<L; M<N.B2M<!L>)C=M<&N:BM<<M:=-M<*N>(M<'N;M<> M7$M2+M<2M77M<<NNc @K|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)$rSrkr_drive_hop_asyncfinishracloserrrrnrprrjrrr)rrrl_read_json_asyncrrrrrrrrrrrrrrr)r1r]rZr^r_r`rarVrrrrrrrrrbrrrrrrrrrs r2rz3BetaRefusalFallbackMiddleware._spliced_frames_asyncEsOO )1)?)?b '--HF 0&A e  AmmoG&b"nn&&&#a//# # #G%%dG4EYI7!#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"P)O=A A A O=AO=4P B  PO=$B'%B'O= EEEO= F($F O=F?O=G"O=9G<:B1O=+PKPA?O=M M MAO=P&N)'P.O=OO= P5O86P=PPPP)rVzIterable[BetaFallbackParam]rPz#Iterable[AnthropicBetaParam] | NonerCrD)r]rr_rrCAPIResponse[Any])r]rr_rrCAsyncAPIResponse[Any])r]rrCdict[str, Any] | None)r{BetaFallbackState | NonerCr)r{rrCCallable[[int], None])r]rrZdict[str, Any]r^rr_rr`rrarrCr)r]rrZrr^rr_rr`rrarrCr)r]rrZrr^rr_rr`rrarrCGenerator[bytes, None, None])r]rrZrr^rr_rr`rrarrCAsyncGenerator[bytes, None])rFrGrHrIr3rrrrerfrgrorrrrKr4r2r(r(^s8|6: +.+3 +  +(AAFAAF4 "      #      #     D    (  !   #   py y  y # y  y y #y  &y vp'p' p' ( p' ! p'p'#p' %p'r4cDeZdZUded< ded< ded<ded<ded<y ) _Refusal Optional[str]r:rboolhas_prefill_claimDict[str, Any]usageeventN)rFrGrHrJrKr4r2rrs+ SS  (r4rc&eZdZUdZded<ded<y)rz6Splice context for fallback hops; `None` for stream A.List[Dict[str, Any]]rrprbNrFrGrHrIrJrKr4r2rrs@$$ Jr4rc&eZdZUdZded<ded<y)rz[A fallback hop whose request failed; stamps `recommended_model` when it ends the chain.rprbz Optional[int]rNrrKr4r2rrs J Rr4rcdeZdZUdZded< ded< ded< ded < d ed < d ed < ded<y) _HopOutcomez*The outcome of consuming one hop's stream.zOptional[_Refusal]rrrbzOptional[Dict[str, Any]] start_eventrblocksrrrrlast_fallback_toNrrKr4r2rrsD4 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)r1rrrrrrs r2r3z_HopReader.__init__sq&j1 ! #%'"& 373737,.  -1 r4c|jSr/)rr0s r2rz_HopReader.opened' ||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_startrrbrcontent_block_start content_blockfallbacktocontent_block_deltacontent_block_stop message_deltadeltarsrd stop_detailsfallback_credit_tokenrfallback_has_prefill_claimT)r:rrrrrrbrrrrrzvanthropic-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_jsondatar9rrrrpr r r r _openrrstart_emit_passthrough_sserstoprcontent_blocksr _backfilllistclose_open_blocksrclearrrrrr)r setdefaultr_serving_iteration_entryrbrw)r1sser event_typerrrbrrrrrrdetailsr: pre_streamrs r2feedz_HopReader.feed+sCHH-.*/*;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|ywr/)r().0helds r2 z#_HopReader._open..sD&t,)rrr rwr(rr _copydeepcopyrr9rr'extendr rr.)r1rrrs 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%r0s 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!) rrr r rr*rrrr0s r2rz_HopReader.finishsc << #<< ++))==//1}}//<<!33  r4N)rrrrrz_SpliceInfo | Nonerrr str | Noner list[bytes]rCrD)rCr)r1rrCrDrCrD)rCr) rFrGrHrIrJr3propertyrr5r%rArrKr4r2rrs. 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_eventsr5rrArr^rr1rs r2rrsf  *[[%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)rrHr5rrArIs r2rrsc !++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.rrrrrCrrp primary_modelr: List[Any]rpartialrr last_refusalzDict[str, Any] | Nonelast_start_eventrrc ||_g|_yr/)_body_pending_seams)r1rZs r2r3z_ChainState.__init__s +-r4c|jJ||}t|jdxsd|_|j|_|j |_t|jxsijd}||jdnd}t|tr|nd|_ |jj|_ g|_ |jjrt|jng|_|j"xs |j|_|j|_|j|_t+|j|j|_|S)z3The chain state after stream A's chainable refusal.Nrbrcrr7)rrpr9rLrrrrrrrrr:rr_to_prefill_blocksrrNrrrOrP_declined_iteration_entriesr)clsrZrr start_messagestart_ids r2rz_ChainState.begin s&***D !$((7"3"9r:"--!.. '"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)rr-rrrr-N)rrSr?r'rxrrOr)r1r seam_indexs r2rz_ChainState.queue_seam#s__  1 "") 5!+)4T__hPTPaPaPjPj)k*5IT^,_`  #r4c,t|jSr/)r,rSr0s r2rz_ChainState.pending_seam_frames;sD''((r4cFd|_|jjy)NT)rrSr.r0s r2rz_ChainState.mark_opened>s !!#r4c6g|j|jSr/)rrNr0s r2rz_ChainState.continuationBs**T\\**r4ci|j|jDcic]\}}|dk7s ||}}}|j|j|d<|r/|jd}gt |t r|ngd|d|d<|Scc}}w)uzThe 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. rVrmessages assistant)rolecontent)rRitemsr:r9rrr,)r1rrkeyvaluerZras r2rz_ChainState.hop_bodyEs>U =Te=T=Z=Z=\s=\zsE`cgr`rU =\s :: !,0JJD( ) xx +H (48(b $> D   ts 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:rrrUrrNrr?rVrOrrPr)r1rrbrs r2rz_ChainState.absorb_refusalXs***__**   =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. Nrr7rrr)iir"rrr message_stopr)rrPr=r>rr9rrwr'r?rSrOrrrbr) r1rrrrrrr3rs r2rz#_ChainState.terminal_failure_framesdsU!~~$"7"7"C..)>)>?K{y9:G"t'B $ MM%= > d))*t006677+,  uyy89G"@GR\@\w}}bf+,7+,2#nnT__=lg eOU34 eNV^,DEF r4N)rZrrCrD)rZrrrrCr)rrprCrDrErB)rC list[Any])rr&rrkrCr)rrrbrprrkrCrD)rrrCrD)rFrGrHrIrJr3 classmethodrrrrrrrrrKr4r2rrsCO;O=2;  O O++$$I.,#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|ywr/)r)r9rs r2r;z._declined_iteration_entries..sQ5PE5Pr<rMrrr[rrb)rr9rrr,rrnrp_to_iteration_usage)rd model_labelreported dict_entriesrentriess r2rVrVs}}  .H(D!hQT+x5PQ S_(uS_%chct)EE)E69)ES_(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.rrMr=fallback_messagerb)rrb)r9rrr,rrro) delta_usagerbrqlasts r2r0r0sl|,H(D!h[(3B78  \d\$6'ARA[V[\ \ 15+ FFr4cPeZdZUdZded< d d dZd dZddZddZddZ dd Z y )ra/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|_yr/) _index_baser_blocksr%)r1rs r2r3z_BlockTracker.__init__s%$9; " r4cL|jDcgc]\}}| c}}Scc}}w)z/The accumulated content blocks, in start order.)r{)r1_blocks r2r*z_BlockTracker.content_blockss"&*ll3l(!Ul333s cj|jd}t|tsyt|jd}|jj || t |nif||jz}||d<|jj |t|j|dz|_ y)z7Track a content_block_start, shifting `event["index"]`.r-Nrr[) r9rrrrr{rwdictrzr%maxr)r1rr-rshifteds 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"]`.r-Nr)r9rrrr _apply_deltar{rz)r1rr-rs r2rz_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"]`.r-Nr[)r9rrrrzr%removerr)r1rr-rs r2r)z_BlockTracker.stopsj '"%% $*** g djj JJ  g &doow{;r4c#K|jD]}tdd|d|jjyw)z4content_block_stop events for any blocks still open.rr[N)r%r'r.)r1r-s r2r-z_BlockTracker.close_open_blockss9ZZE,7KV[.\] ]  s>AN)r)rrrCrD)rClist[dict[str, Any]])rrrCrDrCzIterator[bytes]) rFrGrHrIrJr3r*r&rr)r-rKr4r2rrs/ O8#4 <2 <r4rctfd|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 |ywr/rK)r9 block_indexr~r-s r2r;z_apply_delta..sQ&.KK5.Cs!WEDSYh=Vc$iEs&&z, Nzfallback-refusal-middleware)headers)rHeadersrrerrrpr9splitstriprfromkeysrjoinfilterrjr r#) r]rPkvrrg additionsrrs @r2rhrh:smmgoo.C.C.E\.EdaTUWZI[QT.E\]aabrtvwG+2==+=>+=% +=>H WEWWI ' 5 5 7Y 711779HX;Xq!t 7GY)$(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)rrr$rrrs r2rtrtJs,';'G,@,@,L##999 r4cht|tr"|j|jjSy)zOThe policy category that caused the refusal; only the beta surface carries one.N)rrr$rrrs r2ruruQs,';'G,@,@,L##,,, r4cdd|id|id|ddS)zBThe synthetic `fallback` content block marking one model boundary.rrbrd)rr)rfromrtriggerrK)rrrs r2rxrxXs)*%!%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-8NrdrMzcontent-encodingzcontent-length)rrrdr])rr#rddecoderrr9r,rrencoderrjrResponserr])originalrrrZrheaders r2_seamed_http_responserbs z("2"2"9"9'"BCDGjY)?F _'_9.^.^['R[J\8].^_ ` g gho pD##%G8 W 9 >>((   r4c t|j|}||St||j|jd|j |j |jSNFr)rrkrrrrrrr^rrs r2ryryxs^  6 6 >C {  !!''!!,, r4c t|j|}||St||j|jd|j |j |jSr)rrkrrrrrrrs r2rrs^  6 6 >C {  !!''!!,, r4c i||}|r||d<|S)zThe non-streaming retry body: the fallback entry merged whole over the original params, plus the refusal's credit token when it minted one.rrK)rZr credit_tokenmergeds r2rvrvs&211F*6&' Mr4cL tj|S#t$rYywxYwr/)rloadsr)rs r2r#r#s(zz$ s  ##c0tj|dS)N)r:) separators)rdumpsrgs r2rrs ::e 33r4c4t|r td|SdS)Nr)rrrs r2rrs,3EN4 % (DDr4ch tj|jS#t$rYywxYwr/)rrreadrr^s r2rrs.zz(--/** s "% 11cK tj|jd{S7#t$rYywxYwwr/)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$)r1s 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`. rczevent: rzdata: )r)rr$rlines r2rrsR C  r"" 4  vR  ! :r4c |xsi}|||jdxsd|jdxsd|jdxsd|jdxsd|jddS)N input_tokensr output_tokenscache_read_input_tokenscache_creation_input_tokenscache_creation)rrbrrrrr)r9)rrbrus r2rorosp  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`.)rer9)primaryrrrfrgs r2r+r+sY~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)rrrmr])rrjrrrr])rrmrrs r2rrs\##%G8 W 9 >>((   r4c8eZdZddZeddZeddZy)rc||_yr/_framesr1rs r2r3z_FrameByteStream.__init__  r4c|jSr/rr0s r2__iter__z_FrameByteStream.__iter__ rr4c8|jjyr/)rrr0s r2rz_FrameByteStream.close s r4N)rrrCrDrrB)rFrGrHr3rrrrKr4r2rrs/r4rc8eZdZddZeddZeddZy)rc||_yr/rrs r2r3z_AsyncFrameByteStream.__init__rr4c|jSr/rr0s r2 __aiter__z_AsyncFrameByteStream.__aiter__rr4cTK|jjd{y7wr/)rrr0s r2rz_AsyncFrameByteStream.aclosesll!!###s (&(N)rrrCrD)rCAsyncIterator[bytes]rB)rFrGrHr3rrrrKr4r2rrs/$$r4r)r^httpx.ResponserrrCz#Generator[bytes, None, _HopOutcome])r^rrrrCr)rdrrprprCr)rvrrbrprCr)rz list[tuple[int, dict[str, Any]]]r-rrrrCrD)rrrCrk)rZrrCr)r]rrPr*rCr)rzMessage | BetaMessagerCrC)rrprrprrCrCr)rrrrrCzhttpx.Response | None)r^rrrrCr)r^rrrrCr)rZrrr&rrCrCr)rrprCr)rgrrCrp)rgrErCr)r^rrCr)rrprrrCbytes)r1rrCr)rrCr$rprCrp)rz&Literal['message', 'fallback_message']rbrprrrCr)rrrrrCr)rrrmz,httpx.SyncByteStream | httpx.AsyncByteStreamrCr)g __future__rrjr=rloggingtypingrrrrrr 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)rJrr+r'r6r8r(rrrrrrrrrVr0rrrUrirhrtrurxrryrrvr#rrrrr'r(rror+rSyncByteStreamrAsyncByteStreamrrKr4r2rs""     */  "6>>)>>)$.2<?#  (g''(BC^C0O -O>**<9CCblp8q5qS]*BSO W 'JW 'z (y ()S)S3)34[ [ |  SSlH,G;;B4,B3> f ,  4ERJ   0 9< EZ  &R( u++  $E11 $r4