ó
    °"³jò ã                  ó  • % S SK Jr  S SKrS SKrS SKrS SKJrJrJ	r	J
r
JrJrJrJrJrJrJr  S SKJrJr  S SKJrJr  S SKrSSKJr  SSKJr  SS	KJr  SS
KJ r J!r!  SSK"J#r#J$r$J%r%  SSK&J'r'  SSK(J)r)J*r*J+r+  SSK,J-r-J.r.  SSK/J0r0  SSK1J2r2  SSK3J4r4  SSK5J6r6  SSK7J8r8  SSK9J:r:  SS/r;\Rx                  " S5      r=S\>S'   Sr?Sr@S\>S'    SYS jrA " S  S5      rB\" S!SS"9rCS#\>S$'   \" S%S&S"9rDS'\>S('    " S) S\*5      rE " S* S+\5      rF " S, S-\5      rG " S. S/\5      rH " S0 S1\5      rI " S2 S35      rJSZS4 jrKS[S5 jrL " S6 S75      rMS\S8 jrNS]S9 jrOS^S: jrP " S; S<5      rQS_S= jrRS`S> jrSSaS? jrTSbS@ jrUScSA jrVScSB jrWSdSC jrXSeSD jrYSfSE jrZSgSF jr[ShSG jr\SiSH jr]SjSI jr^SkSJ jr_SlSK jr`SmSL jraSnSM jrbSnSN jrcSoSO jrdSpSP jreSqSQ jrf        SrSR jrgSsSS jrh      StST jri " SU SV\RÔ                  5      rk " SW SX\RØ                  5      rmg)ué    )ÚannotationsN)ÚAnyÚDictÚListÚCallableÚIterableÚIteratorÚOptionalÚ	GeneratorÚAsyncIteratorÚAsyncGeneratorÚcast)ÚTokenÚ
ContextVar)ÚLiteralÚoverrideé   )Úis_dict)Ú	BaseModel)Ú
APIRequest)ÚAPIResponseÚAsyncAPIResponse)ÚStreamÚAsyncStreamÚServerSentEvent)ÚAnthropicError)ÚCallNextÚ
MiddlewareÚAsyncCallNext)Úbuild_headersÚmerge_headers)ÚMessageé   )Úhelper_header)ÚBetaMessage)ÚAnthropicBetaParam)ÚBetaFallbackParam)ÚBetaFallbackCreditTokenParamÚBetaFallbackStateÚBetaRefusalFallbackMiddlewarezanthropic.lib.middlewarezlogging.LoggerÚlogz/v1/messages)zfallback-credit-2026-07-01útuple[AnthropicBetaParam, ...]ÚDEFAULT_BETASc                ó   • U SS.$ )u»   The 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)ÚtokenÚmode© )r0   s    Ú`/home/mande/repo/quber/.venv/lib/python3.13/site-packages/anthropic/lib/middleware/_fallbacks.pyÚ_credit_token_paramr4   5   s   € ð  MÑ2Ð2ó    c                  óD   • \ rS rSr% SrS\S'    S
S jrSS jrSS jrSr	g	)r)   é>   ug  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 | NoneÚindexc                ó   • S U l         g ©N©r8   ©Úselfs    r3   Ú__init__ÚBetaFallbackState.__init__N   s	   € Øˆ�
r5   c                óˆ   • [         R                  U 5      n[        R                  / [        R                  5       QUP75        U $ r:   )Ú_fallback_stateÚsetÚ_fallback_state_tokensÚget)r=   r0   s     r3   Ú	__enter__ÚBetaFallbackState.__enter__Q   s:   € Ü×#Ñ# DÓ)ˆÜ×"Ñ"Ð#IÔ%;×%?Ñ%?Ó%AÐ#IÀ5Ñ#IÔJØˆr5   c                óŒ   • [         R                  5       n[         R                  US S 5        [        R	                  US   5        g )Néÿÿÿÿ)rC   rD   rB   rA   Úreset)r=   Úexc_infoÚtokenss      r3   Ú__exit__ÚBetaFallbackState.__exit__V   s6   € Ü'×+Ñ+Ó-ˆÜ×"Ñ" 6¨#¨2 ;Ô/Ü×Ñ˜f R™jÕ)r5   r;   N©ÚreturnÚNone)rO   r)   )rJ   ÚobjectrO   rP   )
Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__Ú__annotations__r>   rE   rL   Ú__static_attributes__r2   r5   r3   r)   r)   >   s#   ‡ ñð Óðôô÷
*r5   Úanthropic_beta_fallback_state)Údefaultz$ContextVar[BetaFallbackState | None]rA   Ú$anthropic_beta_fallback_state_tokensr2   z7ContextVar[tuple[Token[BetaFallbackState | None], ...]]rC   c                  ó"  • \ rS rSrSrSS.     SS jjr\SS j5       r\SS j5       rSS jr	SS	 jr
SS
 jr                SS jr                SS jr                SS jr                SS jrSrg)r*   éh   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.

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)Úbetasc               ód   • [        U5      U l        Uc  [        O
[        U5      U l        SU l        g)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=   Ú	fallbacksr^   s      r3   r>   Ú&BetaRefusalFallbackMiddleware.__init__ª   s)   € ô    	Ó*ˆŒØ',¡}•m¼%À»,ˆŒØ%*ˆÕ"r5   c           
     ó&  • U R                  U5      nUc  U" U5      $ [        R                  5       nU R                  U5      nU R	                  U5      n[        XR                  5      n[        U5      nUS:X  a  UO[        X0R                  U   5      nUR                  US9nU" U5      n	U	R                  R                  (       d  U	$ UR                  (       aV  US-   n
U
[        U R                  5      :¼  a  U	$ U R                  UU[!        UR                  S5      =(       d    S5      U	UU
US9$ UnU	n[!        UR                  S5      =(       d    S5      n/ nU[        U R                  5      S-
  :  Ga5  UR                  R                  (       Ga  UR#                  5       n[%        U[&        [(        45      (       a  UR*                  S:w  a  OÝUS-  nU" U5        [-        U5      n[/        U5      nU" UR                  [1        X0R                  U   U5      S95      nUR                  R                  (       a9  [!        U R                  U   S   5      nUR3                  [5        UUU5      5        UnU[        U R                  5      S-
  :  a  UR                  R                  (       a  GM  U(       aa  UR                  R                  (       aF  UR#                  5       n[%        U[&        [(        45      (       a  UR*                  S:w  a  [7        XÎ5      $ U$ ©NrH   ©Úbodyé   ÚmodelÚ ©Úrequestri   Úinitial_modelÚresponseÚ	call_nextÚ	first_hopÚpinÚrefusal)Ú_applicable_bodyrA   rD   Ú_start_indexÚ	_make_pinÚ_with_middleware_headersrb   Ú_strip_seam_blocksÚ
_apply_hopra   ÚcopyÚhttp_responseÚ
is_successÚstreamÚlenÚ_splice_fallback_streamÚstrÚparseÚ
isinstancer"   r%   Ústop_reasonÚ_credit_tokenÚ_refusal_categoryÚ_merged_bodyÚappendÚ_seam_blockÚ_prepend_seam_blocks©r=   rn   rq   ri   ÚstateÚstart_indexrs   Úinitial_bodyÚinitial_requestrp   rr   r8   ÚresÚ
from_modelÚseamsÚmessager0   ÚcategoryÚto_modelÚserveds                       r3   ÚhandleÚ$BetaRefusalFallbackMiddleware.handle¾   s¤  € à×$Ñ$ WÓ-ˆØ‰<Ù˜WÓ%Ð%ä×#Ñ#Ó%ˆØ×'Ñ'¨Ó.ˆØ�n‰n˜UÓ#ˆô +¨7·K±KÓ@ˆô
 " $Ó'ˆØ*¨bÓ0‘t´jÀÇÁÐWbÑGcÓ6dˆØ!Ÿ,™,¨L˜,Ð9ˆá˜_Ó-ˆØ×%Ñ%×0×0ØˆOà�>�>Ø# a™ˆIð œC §¡Ó0Ó0Ø�Ø×/Ñ/Ø'ØÜ! ,×"2Ñ"2°7Ó";×"A¸rÓBØ!Ø#Ø#Øð 0ð ð ð ˆØˆÜ˜×)Ñ)¨'Ó2×8°bÓ9ˆ
Ø&(ˆØ”c˜$Ÿ/™/Ó*¨QÑ.Ô.°3×3DÑ3D×3O×3OÐ3OØ—i‘i“kˆGÜ˜g¬´Ð'=×>Ñ>À'×BUÑBUÐYbÓBbØà�Q‰JˆEÙ�ŒJÜ! 'Ó*ˆEÜ(¨Ó1ˆHÙ˜GŸL™L¬l¸4ÇÁÐQVÑAWÐY^Ó._˜LÐ`ÓaˆCØ× Ñ ×+×+Ü˜tŸ™¨uÑ5°gÑ>Ó?�Ø—‘œ[¨°X¸xÓHÔIØ%�
ð ”c˜$Ÿ/™/Ó*¨QÑ.Ó.°3×3DÑ3D×3O×3OÒ3Oö �S×&Ñ&×1×1Ø—Y‘Y“[ˆFÜ˜&¤7¬KÐ"8×9Ñ9¸f×>PÑ>PÐT]Ó>]ô ,¨CÓ7Ð7Øˆ
r5   c           
   ƒ  óš  #   • U R                  U5      nUc  U" U5      I S h  v•N $ [        R                  5       nU R                  U5      nU R	                  U5      n[        XR                  5      n[        U5      nUS:X  a  UO[        X0R                  U   5      nUR                  US9nU" U5      I S h  v•N n	U	R                  R                  (       d  U	$ UR                  (       aV  US-   n
U
[        U R                  5      :¼  a  U	$ U R                  UU[!        UR                  S5      =(       d    S5      U	UU
US9$ UnU	n[!        UR                  S5      =(       d    S5      n/ nU[        U R                  5      S-
  :  GaE  UR                  R                  (       Ga)  UR#                  5       I S h  v•N n[%        U[&        [(        45      (       a  UR*                  S:w  a  OåUS-  nU" U5        [-        U5      n[/        U5      nU" UR                  [1        X0R                  U   U5      S95      I S h  v•N nUR                  R                  (       a9  [!        U R                  U   S   5      nUR3                  [5        UUU5      5        UnU[        U R                  5      S-
  :  a  UR                  R                  (       a  GM)  U(       ai  UR                  R                  (       aN  UR#                  5       I S h  v•N n[%        U[&        [(        45      (       a  UR*                  S:w  a  [7        XÎ5      $ U$  GN GN‰ GNŽ GN NH7frg   )ru   rA   rD   rv   rw   rx   rb   ry   rz   ra   r{   r|   r}   r~   r   Ú_splice_fallback_stream_asyncr�   r‚   rƒ   r"   r%   r„   r…   r†   r‡   rˆ   r‰   Ú_prepend_seam_blocks_asyncr‹   s                       r3   Úhandle_asyncÚ*BetaRefusalFallbackMiddleware.handle_async  sÑ  é € à×$Ñ$ WÓ-ˆØ‰<Ù" 7Ó+×+Ð+ä×#Ñ#Ó%ˆØ×'Ñ'¨Ó.ˆØ�n‰n˜UÓ#ˆô +¨7·K±KÓ@ˆô
 " $Ó'ˆØ*¨bÓ0‘t´jÀÇÁÐWbÑGcÓ6dˆØ!Ÿ,™,¨L˜,Ð9ˆá" ?Ó3×3ˆØ×%Ñ%×0×0ØˆOà�>�>Ø# a™ˆIð œC §¡Ó0Ó0Ø�Ø×5Ñ5Ø'ØÜ! ,×"2Ñ"2°7Ó";×"A¸rÓBØ!Ø#Ø#Øð 6ð ð ð ˆØˆÜ˜×)Ñ)¨'Ó2×8°bÓ9ˆ
Ø&(ˆØ”c˜$Ÿ/™/Ó*¨QÑ.Ô.°3×3DÑ3D×3O×3OÐ3OØŸI™I›K×'ˆGÜ˜g¬´Ð'=×>Ñ>À'×BUÑBUÐYbÓBbØà�Q‰JˆEÙ�ŒJÜ! 'Ó*ˆEÜ(¨Ó1ˆHÙ! '§,¡,´LÀÇÁÐW\ÑG]Ð_dÓ4e ,Ð"fÓg×gˆCØ× Ñ ×+×+Ü˜tŸ™¨uÑ5°gÑ>Ó?�Ø—‘œ[¨°X¸xÓHÔIØ%�
ð ”c˜$Ÿ/™/Ó*¨QÑ.Ó.°3×3DÑ3D×3O×3OÒ3Oö �S×&Ñ&×1×1ØŸ9™9›;×&ˆFÜ˜&¤7¬KÐ"8×9Ñ9¸f×>PÑ>PÐT]Ó>]ô 2°#Ó=Ð=Øˆ
ò ,ò" 4ò2 (ò hñ 'ùsa   ‚ M¢L=£BMÂ7M Â8C=MÆ5MÆ6BMÈ8MÈ9BMË5MÌ M	Ì=MÍ MÍMÍMÍ	Mc                óv  • [        UR                  5      n[        R                  " UR                  5      nU R
                  (       aT  UR                  R                  5       S:w  d6  UR                  [        :w  d"  UR                  R                  S5      S:w  d  Uc  gUR                  S5      b  [        S5      eU$ )zMThe request's JSON body when this middleware applies to it, `None` otherwise.ÚpostÚbetaÚtrueNrd   az  Sending 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_dictÚjsonÚhttpx2ÚURLÚurlra   ÚmethodÚlowerÚpathÚ_MESSAGES_PATHÚparamsrD   r   )r=   rn   ri   r¦   s       r3   ru   Ú.BetaRefusalFallbackMiddleware._applicable_bodyH  s“   € ä˜Ÿ™Ó%ˆÜ�jŠj˜Ÿ™Ó%ˆð ——ð �~‰~×#Ñ#Ó%¨Ó/Ø�x‰xœ>Ó)Ø�z‰z�~‰~˜fÓ%¨Ó/Ø‰|àØ�8‰8�KÓ Ñ,Ü ð0óð ð ˆr5   c                óÎ   • Ub  UR                   c  gUR                   nSUs=::  a  [        U R                  5      :  d'  O  [        SU S[        U R                  5       S35      eU$ )zµThe 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.
rH   zBetaFallbackState.index z! is out of bounds for a chain of z? fallback(s); was the state shared with a different middleware?)r8   r   ra   r   )r=   rŒ   r�   s      r3   rv   Ú*BetaRefusalFallbackMiddleware._start_indexb  sk   € ð ‰=˜EŸK™KÑ/ØØ—k‘kˆØ�[Õ7¤3 t§¡Ó#7Õ7Ü Ø*¨;¨-Ð7XÜ�t—‘Ó'Ð(Ð(gðióð ð Ðr5   c                ó   ^ ^• SU U4S jjnU$ )zUPin requests sharing the state to the entry being tried (or warn that there is none).c                óx   >• Tb  U Tl         g TR                  (       d  STl        [        R                  S5        g g )NTzôanthropic-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.)r8   rc   r+   Úwarning)r8   r=   rŒ   s    €€r3   rs   Ú4BetaRefusalFallbackMiddleware._make_pin.<locals>.pinu  s7   ø€ ØÑ Ø#�•Ø×/×/Ø-1�Ô*Ü—‘ð&õð 0r5   )r8   ÚintrO   rP   r2   )r=   rŒ   rs   s   `` r3   rw   Ú'BetaRefusalFallbackMiddleware._make_pinr  s   ù€ ÷
	ð 
	ð ˆ
r5   c          
     óè   • U R                  UUUUUUUS9n[        [        UR                  [	        U5      5      UR
                  UR                  SUR                  UR                  UR                  S9$ )u  Wrap 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.
rm   T©ÚrawÚcast_toÚclientr~   Ú
stream_clsÚoptionsÚretries_taken)
Ú_spliced_framesr   Ú_spliced_http_responser|   Ú_FrameByteStreamÚ_cast_toÚ_clientÚ_stream_clsÚ_optionsr¼   ©	r=   rn   ri   ro   rp   rq   rr   rs   Úframess	            r3   r€   Ú5BetaRefusalFallbackMiddleware._splice_fallback_streamƒ  s„   € ð* ×%Ñ%ØØØ'ØØØØð &ð 
ˆô Ü& x×'=Ñ'=Ô?OÐPVÓ?WÓXØ×%Ñ%Ø×#Ñ#ØØ×+Ñ+Ø×%Ñ%Ø"×0Ñ0ñ
ð 	
r5   c          
     óè   • U R                  UUUUUUUS9n[        [        UR                  [	        U5      5      UR
                  UR                  SUR                  UR                  UR                  S9$ )Nrm   Tr¶   )
Ú_spliced_frames_asyncr   r¾   r|   Ú_AsyncFrameByteStreamrÀ   rÁ   rÂ   rÃ   r¼   rÄ   s	            r3   rš   Ú;BetaRefusalFallbackMiddleware._splice_fallback_stream_async«  s„   € ð ×+Ñ+ØØØ'ØØØØð ,ð 
ˆô  Ü& x×'=Ñ'=Ô?TÐU[Ó?\Ó]Ø×%Ñ%Ø×#Ñ#ØØ×+Ñ+Ø×%Ñ%Ø"×0Ñ0ñ
ð 	
r5   c          
   #  óR  #   • U R                   nUR                  n	 UR                  n
[        SSS SS / S9n[        X«5       S h  v•N nUR                  c   U	b  U	R                  5         g g U
R                  5         S n	[        R                  X#U5      n[        U[        U5      5       GH‹  nXŽ   n[        US   5      nUS-   [        U5      :  nU" U5        UR                  5       nS nS n[        S5       GH  nUR                  UR                  UU5      S9n U" U5      nUR                  R$                  (       a  UR                  n	  O¾['        UR                  5      nUR                  R                  5         US:X  aF  UR(                  S:X  a6  U(       a/  [        R+                  S[-        U5      5        UR.                  nS nMÐ  [        R!                  SUUR(                  [-        U5      5        [#        UUR(                  S
9n  O   Ub<  U(       a  GMn  UR1                  U5       H  nUv •  M	       U	b  U	R                  5         g g Uc   eUR                  nUR3                  U5        [        UR4                  U[7        UR8                  US9UR:                  UR<                  UR?                  5       S9n[        UU5       S h  v•N nUR@                  (       a  URC                  5         UR                  c    U	b  U	R                  5         g g UR                  5         S n	URE                  UUU5        GMŽ     U	b  U	R                  5         g g  GN
! [         a.  n[        R!                  S	UU5        [#        US S
9n S nA  GMz  S nAff = f NÅ! U	b  U	R                  5         f f = f7f©Nr   TF)Ú
index_baseÚhas_nextÚspliceÚ	wire_openÚ
primary_idÚseam_framesrk   rj   r#   rh   zOanthropic-sdk: BetaRefusalFallbackMiddleware: fallback request to %s failed: %s)rk   Ústatusi�  z�anthropic-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   )#ra   r|   Ú
_HopReaderÚ
_drive_hopÚrefusedÚcloseÚ_ChainStateÚbeginÚranger   r�   Úcontinuationr{   Úhop_bodyÚ	Exceptionr+   ÚerrorÚ_HopFailurer}   Ú
_read_jsonÚstatus_coder±   Ú_json_dumpsÚbaseÚterminal_failure_framesÚ
queue_seamÚ
next_indexÚ_SpliceInforÔ   rÐ   rÑ   Úpending_seam_framesÚopenedÚmark_openedÚabsorb_refusal)r=   rn   ri   ro   rp   rq   rr   rs   rd   ÚcurrentÚstream_aÚreaderÚoutcomeÚchainÚhopÚentryrk   rÎ   rÜ   Úres_bÚfailureÚattemptÚhop_requestÚerrÚerr_bodyÚframeÚhop_responses                              r3   r½   Ú-BetaRefusalFallbackMiddleware._spliced_frameså  s…  é € ð —O‘Oˆ	à*2×*@Ñ*@ˆðk	 à×-Ñ-ˆHÜØàØØØØñˆFô ",¨HÓ!=×=ˆGØ�‰Ñ&Øðx Ñ"Ø—‘•ð #ðw �N‰NÔØˆGô  ×%Ñ% d¸7ÓCˆEä˜Y¬¨I«×7�Ø!™�Ü˜E '™NÓ+�Ø ™7¤S¨£^Ñ3�Ù�C”ð  %×1Ñ1Ó3�Ø15�Ø.2�Ü$ QŸx�GØ")§,¡,°E·N±NÀ5È,Ó4W ,Ð"X�Kð	Ù )¨+Ó 6˜ð ×*Ñ*×5×5Ø"'×"5Ñ"5˜ÙÜ)¨%×*=Ñ*=Ó>�HØ×'Ñ'×-Ñ-Ô/Ø !“|¨×(9Ñ(9¸SÓ(@Æ\ÜŸ™ðgä'¨Ó1ôð
 (-§z¡z˜Ø $˜Ù Ü—I‘IØrØØ×)Ñ)Ü# HÓ-ô	ô *°¸e×>OÑ>OÑP�GÙñC  (ðF Ñ&æÚ ð "'×!>Ñ!>¸wÖ!G˜Ø#œñ "Hàð6 Ñ"Ø—‘•ð #ð1 Ñ(Ð(Ð(Ø$×2Ñ2�Ø× Ñ  Ô'Ü#Ø$×/Ñ/Ø%Ü&°%×2BÑ2BÈ%ÑPØ#Ÿo™oØ$×/Ñ/Ø %× 9Ñ 9Ó ;ñ�ô &0°¸fÓ%E×E�Ø—>—>Ø×%Ñ%Ô'Ø—?‘?Ñ*Øð Ñ"Ø—‘•ð #ð ×"Ñ"Ô$Ø�ð
 ×$Ñ$ W¨e°\×Bñg 8ðj Ñ"Ø—‘•ð #ò} >øô8 %ó ÜŸ	™	ØmØ!Øôô
 #.°EÀ$Ñ"G˜ßûðúñj Føð Ñ"Ø—‘•ð #üs‹   ‚N'œ(N ÁMÁN ÁN'Á,B.N ÄMÄ#DN È4N'É	A=N ËNË3N Ë:N'Ì*N Ì9N'ÍN Í
N	Í!NÍ<N ÎN	Î	N ÎN$Î$N'c          
    ój  #   • U R                   nUR                  n	 UR                  n
[        SSS SS / S9n[        X«5        S h  v•N nU7v •  M   N
 UR	                  5       nUR
                  c   U	b  U	R                  5       I S h  v•N    g g U
R                  5       I S h  v•N    S n	[        R                  X#U5      n[        U[        U5      5       GH  nX�   n[        US   5      nUS-   [        U5      :  nU" U5        UR                  5       nS nS n[        S5       GHe  nUR                  UR                  UU5      S9n U" U5      I S h  v•N  nO:! [         a-  n[         R#                  S	UU5        [%        US S
9n S nA  GOS nAff = fUR                  R&                  (       a  UR                  n	  OÑ[)        UR                  5      I S h  v•N  nUR                  R                  5       I S h  v•N    US:X  aG  UR*                  S:X  a7  U(       a0  [         R-                  S[/        U5      5        UR0                  nS nGM'  [         R#                  SUUR*                  [/        U5      5        [%        UUR*                  S
9n  O   UbF  U(       a  GMÅ  UR3                  U5       H  nU7v •  M
       U	b  U	R                  5       I S h  v•N    g g Uc   eUR                  nUR5                  U5        [        UR6                  U[9        UR:                  US9UR<                  UR>                  URA                  5       S9n[        UU5        S h  v•N  nU7v •  M  
 UR	                  5       nURB                  (       a  URE                  5         UR
                  c    U	b  U	R                  5       I S h  v•N    g g UR                  5       I S h  v•N    S n	URG                  UUU5        GM     U	b  U	R                  5       I S h  v•N    g g ! U	b  U	R                  5       I S h  v•N    f f = f7frÌ   )$ra   r|   rÕ   Ú_drive_hop_asyncÚfinishr×   ÚacloserÙ   rÚ   rÛ   r   r�   rÜ   r{   rÝ   rÞ   r+   rß   rà   r}   Ú_read_json_asyncrâ   r±   rã   rä   rå   ræ   rç   rè   rÔ   rÐ   rÑ   ré   rê   rë   rì   )r=   rn   ri   ro   rp   rq   rr   rs   rd   rí   rî   rï   rú   rð   rñ   rò   ró   rk   rÎ   rÜ   rô   rõ   rö   r÷   rø   rù   rû   s                              r3   rÈ   Ú3BetaRefusalFallbackMiddleware._spliced_frames_asynca  sã  é € ð —O‘Oˆ	à*2×*@Ñ*@ˆðb	'à×-Ñ-ˆHÜØàØØØØñˆFô  0°ÔA÷ �eØ•ñÐAà—m‘m“oˆGØ�‰Ñ&Øðb Ñ"Ø—n‘nÓ&×&Ò&ð #ða —/‘/Ó#×#Ñ#ØˆGä×%Ñ% d¸7ÓCˆEä˜Y¬¨I«×7�Ø!™�Ü˜E '™NÓ+�Ø ™7¤S¨£^Ñ3�Ù�C”à$×1Ñ1Ó3�Ø6:�Ø.2�Ü$ QŸx�GØ")§,¡,°E·N±NÀ5È,Ó4W ,Ð"X�Kð	Ù&/°Ó&<× <Ð <™øÜ$ó ÜŸ	™	ØmØ!Øôô
 #.°EÀ$Ñ"G˜Þûðúð ×*Ñ*×5×5Ø"'×"5Ñ"5˜ÙÜ%5°e×6IÑ6IÓ%J×JÐJ�HØ×-Ñ-×4Ñ4Ó6×6Ñ6Ø !“|¨×(9Ñ(9¸SÓ(@Æ\ÜŸ™ðgä'¨Ó1ôð
 (-§z¡z˜Ø $˜Ú Ü—I‘IØrØØ×)Ñ)Ü# HÓ-ô	ô *°¸e×>OÑ>OÑP�GÙñC  (ðF Ñ&æÚ Ø!&×!>Ñ!>¸wÖ!G˜Ø#�ñ "Hàð2 Ñ"Ø—n‘nÓ&×&Ò&ð #ð/ Ñ(Ð(Ð(Ø$×2Ñ2�Ø× Ñ  Ô'Ü#Ø$×/Ñ/Ø%Ü&°%×2BÑ2BÈ%ÑPØ#Ÿo™oØ$×/Ñ/Ø %× 9Ñ 9Ó ;ñ�ô $4°LÀ&Ô#I÷  ð  ˜%Ø•Kð $Jà Ÿ-™-›/�Ø—>—>Ø×%Ñ%Ô'Ø—?‘?Ñ*Øð Ñ"Ø—n‘nÓ&×&Ò&ð #ð #×)Ñ)Ó+×+Ñ+Ø�à×$Ñ$ W¨e°\×BñS 8ðV Ñ"Ø—n‘nÓ&×&Ò&ð #øˆwÑ"Ø—n‘nÓ&×&Ò&ð #üs#  ‚P3œ%P ÁAÁAÁAÁ	P ÁAÁP Á2P3ÂBÂ	P3ÂP Â#B&Â$B#P ÅEÅEÅEÅP Å
FÅ$!FÆP ÆFÆAP ÇGÇ"P Ç8G;Ç9C P Ê9P3ËKËP3ËA:P ÍM"ÍMÍM"ÍAP Î"P3Î8N;Î9P3Ï P ÏOÏP Ï3P3Ð	PÐ
P3ÐP0Ð(P+Ð)P0Ð0P3)rb   ra   rc   )rd   zIterable[BetaFallbackParam]r^   z#Iterable[AnthropicBetaParam] | NonerO   rP   )rn   r   rq   r   rO   úAPIResponse[Any])rn   r   rq   r   rO   úAsyncAPIResponse[Any])rn   r   rO   údict[str, Any] | None)rŒ   úBetaFallbackState | NonerO   r³   )rŒ   r  rO   úCallable[[int], None])rn   r   ri   údict[str, Any]ro   r�   rp   r  rq   r   rr   r³   rs   r  rO   r  )rn   r   ri   r  ro   r�   rp   r  rq   r   rr   r³   rs   r  rO   r  )rn   r   ri   r  ro   r�   rp   r  rq   r   rr   r³   rs   r  rO   úGenerator[bytes, None, None])rn   r   ri   r  ro   r�   rp   r  rq   r   rr   r³   rs   r  rO   úAsyncGenerator[bytes, None])rR   rS   rT   rU   rV   r>   r   r—   rœ   ru   rv   rw   r€   rš   r½   rÈ   rX   r2   r5   r3   r*   r*   h   sÔ  † ñ?ðJ 6:ñ	+à.ð+ð 3ð	+ð
 
õ+ð( óBó ðBðH óBó ðBôHô4ô ð"&
ð ð&
ð ð	&
ð
 ð&
ð #ð&
ð ð&
ð ð&
ð #ð&
ð 
ô&
ðP
ð ð
ð ð	
ð
 ð
ð (ð
ð !ð
ð ð
ð #ð
ð 
ô
ðtz ð ðz ð ð	z ð
 ðz ð #ðz ð ðz ð ðz ð #ðz ð 
&ôz ðxq'ð ðq'ð ð	q'ð
 ðq'ð (ðq'ð !ðq'ð ðq'ð #ðq'ð 
%÷q'r5   c                  ó\   • \ rS rSr% S\S'    S\S'    S\S'   S\S'   S\S	'    S
rS\S'   Srg
)Ú_RefusaliÕ  úOptional[str]r0   r”   ÚboolÚhas_prefill_claimúDict[str, Any]ÚusageÚeventNúOptional[Dict[str, Any]]Úsuppressed_start_messager2   )rR   rS   rT   rU   rW   r  rX   r2   r5   r3   r  r  Õ  s>   ‡ ØÓØSàÓØSàÓØÓØÓð(ð :>ÐÐ6Ó=ò/r5   r  c                  ó.   • \ rS rSr% SrS\S'   S\S'   Srg)	rè   iè  z6Splice context for fallback hops; `None` for stream A.úList[Dict[str, Any]]rÔ   r�   rk   r2   N©rR   rS   rT   rU   rV   rW   rX   r2   r5   r3   rè   rè   è  s   ‡ Ù@à$Ó$Ø†Jr5   rè   c                  ó.   • \ rS rSr% SrS\S'   S\S'   Srg)	rà   iï  zWA fallback hop whose request failed; stamps `recommended_model` when it
ends the chain.r�   rk   zOptional[int]rÓ   r2   Nr  r2   r5   r3   rà   rà   ï  s   ‡ ñð ƒJØÓÚRr5   rà   c                  ól   • \ rS rSr% SrS\S'    S\S'    S\S'    S	\S
'    S\S'    S\S'    S\S'   Srg)Ú_HopOutcomeiø  z*The outcome of consuming one hop's stream.zOptional[_Refusal]r×   r  rk   r  Ústart_eventr  Úblocksr³   rç   r  rê   Úlast_fallback_tor2   Nr  r2   r5   r3   r  r  ø  sD   ‡ Ù4àÓØEàÓØ:à)Ó)Ø0à Ó Ø\àƒOØ^àƒLØTà#Ó#ò3r5   r  c                  ó’   • \ rS rSr% SrS\S'                  SS jr\SS j5       rSS jr	SS jr
SS	 jrSS
 jrSS jrSrg)rÕ   i  uë  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. When its `message_start` was not re-emitted, its
`input_transformations` are copied onto that message_delta.

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 | Nonerð   c               óÐ   • [        U5      U l        X l        X0l        X@l        XPl        X`l        S U l        S U l        S U l	        S U l
        / U l        SU l        S U l        S U l        g )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=   rÍ   rÎ   rÏ   rÐ   rÑ   rÒ   s          r3   r>   Ú_HopReader.__init__.  sg   € ô & jÓ1ˆŒØ!ŒØŒØ#ŒØ%ÔØ'ÔØ"&ˆŒØ37ˆÔØ37ˆÔØ37ˆÔØ,.ˆŒ
ØˆŒØ-1ˆÔØˆ�r5   c                ó   • U R                   $ r:   )r,  r<   s    r3   rê   Ú_HopReader.openedG  ó   € à�|‰|Ðr5   c                ól  • [        [        UR                  5      5      nUb  UR                  S5      OSnU R                  nUS:X  a|  Uby  [        UR                  S5      5      nUbN  UR                  S5      n[        U[        5      (       a  UOSU l        [        UR                  S5      5      U l        X l	        Xl
        / $ US:X  aÍ  UbÊ  U R                  5       n[        UR                  S5      5      nUb`  UR                  S5      S	:X  aK  [        UR                  S
5      5      n	U	b  U	R                  S5      OSn
[        U
[        5      (       a  X l        U R                  R                  U5        Ub  / UQ[        SU5      P$ / UQ[!        U5      P$ US:X  aP  UbM  U R                  5       nU R                  R#                  U5        Ub  / UQ[        SU5      P$ / UQ[!        U5      P$ US:X  aP  UbM  U R                  5       nU R                  R%                  U5        Ub  / UQ[        SU5      P$ / UQ[!        U5      P$ US:X  Ga3  UGb/  [        UR                  S5      5      =(       d    0 nUR                  S5      S:X  Ga  [        UR                  S5      5      nUb  UR                  S5      S:X  a  UOSnUb  UR                  S5      OSn[        U[        5      (       a	  U(       a  UOSnU R&                  (       + =(       a    U R                  R)                  5       (       + nU R*                  (       Ga1  Uc  U(       Ga&  [-        [        UR                  S5      5      U R                  5      n[/        U R                  R1                  5       5      nSU l
        U R2                  R5                  5         [7        [9        UUb  UR                  S5      OSUSL=(       a    UR                  S5      SL UUU R;                  5       S9U R                  U R                  U R                  R)                  5       U R                  R<                  U R&                  U R                  S9U l        U$ U(       d  [@        RC                  S5        O[@        RC                  S5        U R                  5       nUb¼  UR                  S5      S:X  a/  [        UR                  S5      5      nUb  URE                  SS5        [        UR                  S5      5      =(       d    0 n/ URF                  Q[I        UURJ                  5      PUS'   UUS'   [M        X R;                  5       5        / UQ[        SU5      P$ / UQ[!        U5      P$ U R&                  (       d  U R2                  RO                  U5        / $ [!        U5      /$ )z:Process one event, returning the frames to forward for it.NÚtypeÚmessage_startr“   rk   r  Úcontent_block_startÚcontent_blockÚfallbackÚtoÚcontent_block_deltaÚcontent_block_stopÚmessage_deltaÚdeltar„   rt   Ústop_detailsÚfallback_credit_tokenr”   Úfallback_has_prefill_claimT)r0   r”   r  r  r  r  ©r×   rk   r  r  rç   rê   r  zvanthropic-sdk: BetaRefusalFallbackMiddleware: refusal stop_details has no fallback_credit_token; surfacing the refusalzkanthropic-sdk: BetaRefusalFallbackMiddleware: refusal but no fallback entries remain; surfacing the refusalÚrecommended_modelrÔ   )(r¢   Ú
_safe_jsonÚdatarD   r#  rƒ   r�   r'  r(  r)  r*  Ú_openr-  r!  ÚstartÚ_emitÚ_passthrough_sser<  Ústopr,  Úcontent_blocksr"  Ú	_backfillÚlistÚclose_open_blocksr+  Úclearr  r  Ú_suppressed_start_messagerç   rð   r+   rß   Ú
setdefaultrÔ   Ú_serving_iteration_entryrk   Ú_forward_input_transformationsrˆ   )r=   Ússer  Ú
event_typerÏ   r“   rk   rÅ   r6  r8  r•   r<  r=  Údetailsr0   Ú
pre_streamr  s                    r3   ÚfeedÚ_HopReader.feedK  s;  € äœ C§H¡HÓ-Ó.ˆØ*/Ñ*;�U—Y‘Y˜vÔ&Àˆ
Ø—‘ˆà˜Ó(¨UÑ->Ü˜uŸy™y¨Ó3Ó4ˆGØÑ"ØŸ™ GÓ,�Ü'1°%¼×'=Ñ'=™eÀ4�”Ü$,¨W¯[©[¸Ó-AÓ$B�Ô!Ø %ÔØ"ÔØˆIØÐ0Ó0°UÑ5FØ—Z‘Z“\ˆFÜ$ U§Y¡Y¨Ó%?Ó@ˆMØÑ(¨]×->Ñ->¸vÓ-FÈ*Ó-TÜ˜m×/Ñ/°Ó5Ó6�Ø.0©n˜2Ÿ6™6 'œ?À$�Ü˜h¬×,Ñ,Ø-5Ô*Ø�M‰M×Ñ Ô&ð Ñ%ð ?�&Ð>œ%Ð 5°uÓ=Ð>ðð 6�vÐ5Ô/°Ó4Ð5ðð
 Ð0Ó0°UÑ5FØ—Z‘Z“\ˆFØ�M‰M×Ñ Ô&ð Ñ%ð ?�&Ð>œ%Ð 5°uÓ=Ð>ðð 6�vÐ5Ô/°Ó4Ð5ðð
 Ð/Ó/°EÑ4EØ—Z‘Z“\ˆFØ�M‰M×Ñ˜uÔ%ð Ñ%ð >�&Ð=œ%Ð 4°eÓ<Ð=ðð 6�vÐ5Ô/°Ó4Ð5ðð
 ˜?Ô*¨uÒ/@Ü˜UŸY™Y wÓ/Ó0×6°BˆEØ�y‰y˜Ó'¨9Ô4Ü'¨¯	©	°.Ó(AÓB�Ø*6Ñ*BÀ|×GWÑGWÐX^ÓG_ÐclÓGl™,Ðrv�Ø@GÑ@S˜Ÿ™Ð$;Ô<ÐY]�Ü!+¨E´3×!7Ñ!7¾E™Àt�Ø!%§¡Ô-×T°d·m±m×6RÑ6RÓ6TÔ2T�
ð —>—>�> uÑ'8¿JÜ%¤h¨u¯y©y¸Ó/AÓ&BÀD×DUÑDUÓV�EÜ! $§-¡-×"AÑ"AÓ"CÓD�Fð (,�DÔ$Ø—J‘J×$Ñ$Ô&Ü#.Ü (Ø"'Ø@GÑ@S W§[¡[°Ô%<ÐY]Ø.5¸TÐ.A×.wÀgÇkÁkÐRnÓFoÐswÐFwØ"'Ø"'Ø59×5SÑ5SÓ5Uñ!ð #Ÿk™kØ$(×$5Ñ$5Ø#Ÿ}™}×;Ñ;Ó=Ø#'§=¡=×#;Ñ#;Ø#Ÿ|™|Ø)-×)?Ñ)?ñ$�D”Lð  "�MÞÜ—I‘IðGõô
 —I‘Ið@ôð —Z‘Z“\ˆFØÑ!Ø—9‘9˜]Ó+¨yÓ8ô $,¨E¯I©I°nÓ,EÓ#F�LØ#Ñ/Ø$×/Ñ/Ð0CÀTÔJô ! §¡¨7Ó!3Ó4×:¸�ð'Ø×&Ñ&ð'ä,¨U°F·L±LÓAð'��lÑ#ð "'��g‘Ü.¨u×6TÑ6TÓ6VÔWØ?˜Ð?¤ ¸Ó!>Ð?Ð?Ø3�VÐ3Ô-¨cÓ2Ð3Ð3à�|�|à�J‰J×Ñ˜cÔ"ØˆIô ! Ó%Ð&Ð&r5   c                ó¢   • U R                   b  U R                  (       a  U R                  c  g[        U R                  R	                  S5      5      $ )z´`message` from this fallback's `message_start` when it was not
re-emitted because the caller already received a `message_start`.
`None` for stream A, whose start is always emitted.Nr“   )r#  r$  r)  r¢   rD   r<   s    r3   rN  Ú$_HopReader._suppressed_start_messageÇ  s>   € ð �<‰<Ñ t§§¸$×:KÑ:KÑ:SØÜ˜×)Ñ)×-Ñ-¨iÓ8Ó9Ð9r5   c                óœ  • U R                   (       a  / $ SU l         / nU R                  c2  U R                  b$  UR                  [	        U R                  5      5        O’U R
                  (       d�  U R                  bt  [        R                  " U R                  5      n[        UR                  S5      5      nUb  U R                  b  U R                  US'   UR                  [        SU5      5        UR                  U R                  5        UR                  S U R                   5       5        SU l        U R                  R!                  5         U$ )z Open 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.TNr“   Úidr4  c              3  ó8   #   • U  H  n[        U5      v •  M     g 7fr:   )rG  )Ú.0Úhelds     r3   Ú	<genexpr>Ú#_HopReader._open.<locals>.<genexpr>á  s   é € ÐDº°Ô& t×,Ð,ºùó   ‚)r,  r#  r*  rˆ   rG  r$  r)  Ú_copyÚdeepcopyr¢   rD   r%  rF  Úextendr&  r+  rM  )r=   rÅ   r  r“   s       r3   rD  Ú_HopReader._openÏ  sü   € ð �<�<ØˆIØˆŒØ ˆØ�<‰<ÑØ×ÑÑ+Ø—‘Ô.¨t×/?Ñ/?Ó@ÔAøØ—— T×%6Ñ%6Ñ%BÜŸ.š.¨×):Ñ):Ó;ˆKÜ˜{Ÿ™¨yÓ9Ó:ˆGØÑ" t×'7Ñ'7Ñ'CØ $× 0Ñ 0�˜‘Ø�M‰Mœ% °Ó=Ô>Ø�‰�d×'Ñ'Ô(Ø�‰ÑD¸¿ºÓDÔDØˆÔØ�
‰
×ÑÔØˆr5   c                ób   • U R                   c  U R                  (       a  / $ U R                  5       $ )zCFrames still owed when the stream ends without a chainable refusal.)rð   r,  rD  r<   s    r3   Úfinish_framesÚ_HopReader.finish_framesæ  s#   € à�<‰<Ñ# t§|§|ØˆIØ�z‰z‹|Ðr5   c           
     óú   • U R                   b  U R                   $ [        SU R                  U R                  U R                  R                  5       U R                  R                  U R                  U R                  S9$ )zCThe outcome once the hop's stream is fully consumed (or cut early).Nr@  )	rð   r  r'  r)  r!  rI  rç   r,  r-  r<   s    r3   rÿ   Ú_HopReader.finishì  sc   € à�<‰<Ñ#Ø—<‘<ÐÜØØ—+‘+Ø×)Ñ)Ø—=‘=×/Ñ/Ó1Ø—}‘}×/Ñ/Ø—<‘<Ø!×3Ñ3ñ
ð 	
r5   )r"  r+  r*  r-  r'  r,  r%  r&  r#  r)  r(  r!  r$  rð   N)rÍ   r³   rÎ   r  rÏ   z_SpliceInfo | NonerÐ   r  rÑ   ú
str | NonerÒ   úlist[bytes]rO   rP   )rO   r  )rR  r   rO   rl  )rO   r  ©rO   rl  )rO   r  )rR   rS   rT   rU   rV   rW   r>   Úpropertyrê   rV  rN  rD  rg  rÿ   rX   r2   r5   r3   rÕ   rÕ     sŒ   ‡ ñð0  ÓØUðð ðð ð	ð
 #ðð ðð ðð !ðð 
ôð2 óó ðôz'ôx:ôô.÷
r5   rÕ   c              #  óð   #   • [         R                  " U 5       H.  nUR                  U5       H  nUv •  M	     UR                  c  M.    O   UR	                  5        H  nUv •  M	     UR                  5       $ 7f)zKFeed one hop's SSE events through `reader`, yielding the frames to forward.)r   Ú
raw_eventsrV  rð   rg  rÿ   ©rp   rï   rR  rú   s       r3   rÖ   rÖ   û  se   é € ä× Ò  Ö*ˆØ—[‘[ Ö%ˆEØŒKñ &à�>‰>Ó%Ùñ	 +ð
 ×%Ñ%Ö'ˆØŒñ (à�=‰=‹?Ðùs   ‚AA6Á/A6c               óä   #   • [         R                  " U 5        Sh  v•N nUR                  U5       H  nU7v •  M
     UR                  c  M5    UR	                  5        H  nU7v •  M
     g NN
 N!7f)u¯   Feed 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)r   rp  rV  rð   rg  rq  s       r3   rþ   rþ     sa   é € ô !×+Ò+¨HÔ5÷ ˆcØ—[‘[ Ö%ˆEØ�Kñ &à�>‰>Ó%ØØ×%Ñ%Ö'ˆØ�ò (ñÑ5ùs+   ‚A0™A.�A,žA.¡)A0ÁA0Á,A.Á.A0c                  óö   • \ rS rSr% SrS\S'    S\S'    S\S'    S	\S
'    S\S'   S\S'   S\S'   S	\S'   S\S'   S\S'   S\S'    S!S jr\S"S j5       rS#S jr	S$S jr
S%S jrS&S jrS'S jrS(S jrS)S jrSrg )*rÙ   i  z9Bookkeeping shared across the hops of one spliced stream.r³   rç   r  rÐ   rk  rÑ   r�   Úprimary_modelr0   ú	List[Any]rä   Úpartialr‘   r  Úlast_refusalzDict[str, Any] | NoneÚlast_start_eventr  rÔ   c                ó   • Xl         / U l        g r:   )Ú_bodyÚ_pending_seams)r=   ri   s     r3   r>   Ú_ChainState.__init__3  s   € ØŒ
Ø+-ˆÕr5   c                óÎ  • UR                   c   eU " U5      nX$l        UR                  Ul        UR                  Ul        [        UR                  =(       d    0 R                  S5      5      nUb  UR                  S5      OSn[        U[        5      (       a  UOSUl
        UR                   R                  Ul        / Ul        UR                   R                  (       a  [        UR                  5      O/ Ul        UR"                  =(       d    UR                  Ul        UR                   Ul        UR                  Ul        [+        UR                   UR                  5      Ul        U$ )u¿   The 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.
Nr“   r[  )r×   rt  rç   rê   rÐ   r¢   r  rD   rƒ   r�   rÑ   r0   rä   r  Ú_to_prefill_blocksr  rv  r  r‘   rw  rx  Ú_declined_iteration_entriesrÔ   )Úclsri   ro   rð   rñ   Ústart_messageÚstart_ids          r3   rÚ   Ú_ChainState.begin7  s  € ð �‰Ñ*Ð*Ð*Ù�D“	ˆØ+ÔØ"×-Ñ-ˆÔØ!Ÿ.™.ˆŒÜ  '×"5Ñ"5×";¸×!@Ñ!@ÀÓ!KÓLˆØ.;Ñ.G�=×$Ñ$ TÔ*ÈTˆÜ'1°(¼C×'@Ñ'@™8ÀdˆÔØ—o‘o×+Ñ+ˆŒØˆŒ
Ø>E¿o¹o×>_×>_Ô*¨7¯>©>Ô:ÐegˆŒð #×3Ñ3×J°u×7JÑ7JˆÔØ$Ÿ_™_ˆÔØ!(×!4Ñ!4ˆÔÜ6°w·±È×H[ÑH[Ó\ˆÔØˆr5   c                ó  • U R                   nU =R                   S-  sl         U R                  R                  [        SSU[	        U R
                  XR                  R                  5      S.5      [        SSUS.5      /5        Xl        g)zñQueue 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.
rj   r5  )r3  r8   r6  r:  ©r3  r8   N)rç   r{  rd  rF  r‰   r‘   rw  r”   )r=   r•   Ú
seam_indexs      r3   ræ   Ú_ChainState.queue_seamR  s   € ð —_‘_ˆ
Ø�Š˜1Ñ�Ø×Ñ×"Ñ"äØ)à 5Ø!+Ü)4°T·_±_Àh×PaÑPa×PjÑPjÓ)kñóô Ð*Ð5IÐT^Ñ,_Ó`ð
ô	
ð #�r5   c                ó,   • [        U R                  5      $ r:   )rK  r{  r<   s    r3   ré   Ú_ChainState.pending_seam_framesj  s   € Ü�D×'Ñ'Ó(Ð(r5   c                óF   • SU l         U R                  R                  5         g )NT)rÐ   r{  rM  r<   s    r3   rë   Ú_ChainState.mark_openedm  s   € ØˆŒØ×Ñ×!Ñ!Õ#r5   c                ó6   • / U R                   QU R                  Q$ r:   )rä   rv  r<   s    r3   rÜ   Ú_ChainState.continuationq  s   € Ø*�—‘Ð*˜TŸ\™\Ð*Ð*r5   c                óR  • [        U R                  U5      R                  5        VVs0 s H  u  p4US:w  d  M  X4_M     nnnU R                  b  [	        U R                  5      US'   U(       a4  UR                  S5      n/ [        U[        5      (       a  UO/ QSUS.PUS'   U$ s  snnf )uu  The 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.
rd   r>  ÚmessagesÚ	assistant)ÚroleÚcontent)rz   rz  Úitemsr0   r4   rD   rƒ   rK  )r=   ró   rÜ   ÚkeyÚvalueri   r�  s          r3   rÝ   Ú_ChainState.hop_bodyt  s°   € ô *4°D·J±JÀÓ)F×)LÑ)LÔ)Nô 
Ú)N™:˜3ÐRUÐYdÑRd‹JˆCŠJÑ)Nð 	ñ  
ð �:‰:Ñ!Ü,?ÀÇ
Á
Ó,KˆDÐ(Ñ)ÞØ—x‘x 
Ó+ˆHð Ü(¨´4×8Ñ8‘(¸bð à$°Ñ>ð ˆD�Ñð ˆùó 
s
   ¨B#¸B#c                ó°  • UR                   c   eUR                   R                  U l        X0l        UR                   R                  (       a  [	        UR
                  5      O/ U l        U R                  R                  [        UR                   U5      5        UR                   U l
        UR                  b  UR                  U l        UR                  U l        g)z7Fold a refused hop's outcome in, readying the next hop.N)r×   r0   rä   r  r~  r  rv  rÔ   rd  r  rw  r  rx  rç   )r=   rð   rk   rÜ   s       r3   rì   Ú_ChainState.absorb_refusalŠ  s™   € à�‰Ñ*Ð*Ð*Ø—_‘_×*Ñ*ˆŒ
Ø Œ	Ø=D¿_¹_×=^×=^Ô)¨'¯.©.Ô9ÐdfˆŒØ�‰×ÑÔ:¸7¿?¹?ÈEÓRÔSØ#ŸO™OˆÔØ×ÑÑ*Ø$+×$7Ñ$7ˆDÔ!Ø!×,Ñ,ˆ�r5   c                ó°  • / nU R                   (       d�  U R                  bt  [        R                  " U R                  5      n[	        UR                  S5      5      nUb  U R                  b  U R                  US'   UR                  [        SU5      5        UR                  U R                  5        [        R                  " U R                  R                  5      n[	        UR                  S5      5      nUb>  [	        UR                  S5      5      nUb!  UR                  S;   a  UR                  OSUS'   [	        UR                  S	5      5      =(       d    0 n[        R                  " U R                  5      US
'   X…S	'   [!        XPR                  R"                  5        UR                  [        SU5      5        UR                  [        SSS05      5        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), `usage.iterations` carrying the recorded chain, and
`input_transformations` copied from a `message_start` that was not
re-emitted â€” then message_stop.
Nr“   r[  r4  r<  r=  )i­  i  rA  r  rÔ   r;  Úmessage_stopr3  )rÐ   rx  rb  rc  r¢   rD   rÑ   rˆ   rF  rd  r{  rw  r  rÓ   rk   rÔ   rQ  r  )	r=   rõ   rÅ   r  r“   r  r<  rT  r  s	            r3   rå   Ú#_ChainState.terminal_failure_frames–  sg  € ð !ˆØ�~�~ $×"7Ñ"7Ñ"CÜŸ.š.¨×)>Ñ)>Ó?ˆKÜ˜{Ÿ™¨yÓ9Ó:ˆGØÑ" t§¡Ñ'BØ $§¡�˜‘Ø�M‰Mœ% °Ó=Ô>Ø�‰�d×)Ñ)Ô*ä—’˜t×0Ñ0×6Ñ6Ó7ˆÜ˜Ÿ™ 7Ó+Ó,ˆØÑÜ˜uŸy™y¨Ó8Ó9ˆGØÑ"Ø@GÇÁÐR\Ó@\¨w¯}ª}Ðbf�Ð+Ñ,Ü˜Ÿ™ 7Ó+Ó,×2°ˆÜ#Ÿnšn¨T¯_©_Ó=ˆˆlÑØˆg‰Ü& u×.?Ñ.?×.XÑ.XÔYØ�‰”e˜O¨UÓ3Ô4Ø�‰”e˜N¨V°^Ð,DÓEÔFØˆr5   )
rz  r{  rä   r‘   rw  rx  rç   rv  r0   rÐ   N)ri   r  rO   rP   )ri   r  ro   r�   rð   r  rO   rÙ   )r•   r�   rO   rP   rm  rN   )rO   ú	list[Any])ró   r'   rÜ   rœ  rO   r  )rð   r  rk   r�   rÜ   rœ  rO   rP   )rõ   rà   rO   rl  )rR   rS   rT   rU   rV   rW   r>   ÚclassmethodrÚ   ræ   ré   rë   rÜ   rÝ   rì   rå   rX   r2   r5   r3   rÙ   rÙ     s™   ‡ ÙCàƒOØ;àƒOØ=àÓð2ð Óð4ð ÓØ
ƒOØÓØƒOØÓØ+Ó+Ø$Ó$ðIô.ð óó ðô4#ô0)ô$ô+ôô,
-÷r5   rÙ   c                ó^   • Ub  SU ;   a  gSU;   a  [         R                  " US   5      U S'   gg)zÔCopy `input_transformations` from a fallback's `message_start` that was
not re-emitted onto the emitted `message_delta`, matching what a server-side
mid-stream fallback sends. A list already on the delta is kept.NÚinput_transformations)rb  rc  )r  r  s     r3   rQ  rQ  ¶  s>   € ð  Ñ'Ð+BÀeÓ+KØØÐ":Ó:Ü).¯ªÐ8PÐQhÑ8iÓ)jˆÐ%Ò&ð ;r5   c                ó’  • U R                   R                  S5      n[        U[        5      (       a|  U(       au  S [	        SU5       5       nU Vs/ s H  oDc  M  0 UESS0EPM     nnU(       a?  [        U5      S:X  a.  [        US   R                  S5      [        5      (       d  XS   S'   U$ [        SXR                   5      /$ s  snf )	u3  The `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.
rÔ   c              3  ó8   #   • U  H  n[        U5      v •  M     g 7fr:   )r¢   )r]  ró   s     r3   r_  Ú._declined_iteration_entries.<locals>.<genexpr>Í  s   é € ÐQÒ5P¨Eœ Ÿ˜Ò5Pùra  ru  r3  r“   rj   r   rk   )r  rD   rƒ   rK  r   r   r�   Ú_to_iteration_usage)rt   Úmodel_labelÚreportedÚdict_entriesró   Úentriess         r3   r  r  À  s®   € ð �}‰}× Ñ  Ó.€HÜ�(œD×!Ñ!¦hÙQ´T¸+ÀxÔ5PÓQˆÙS_Ó(uÒS_È%Ô)E¨EÐ)E°6¸9Ô)EÑS_ˆÐ(uÞÜ�7‹|˜qÓ ¬°G¸A±J·N±NÀ7Ó4KÌS×)QÑ)QØ&1˜‘
˜7Ñ#ØˆNÜ 	¨;¿¹ÓFÐGÐGùò )vs   ÁCÁCc                óì   • U R                  S5      n[        U[        5      (       aC  U(       a<  [        [	        SU5      S   5      nUb!  0 UESUR                  S5      =(       d    US.E$ [        SX5      $ )zƒThe serving hop's `fallback_message` completer entry: its own
self-reported iteration relabeled, or one built from its delta usage.rÔ   ru  rH   Úfallback_messagerk   )r3  rk   )rD   rƒ   rK  r¢   r   r£  )Údelta_usagerk   r¥  Úlasts       r3   rP  rP  Ö  sm   € ð �‰˜|Ó,€HÜ�(œD×!Ñ!¦hÜœ˜[¨(Ó3°BÑ7Ó8ˆØÑØ\�dÐ\Ð$6ÀÇÁÈ'ÓAR×A[ÐV[Ò\Ð\ÜÐ1°5ÓFÐFr5   c                  óf   • \ rS rSr% SrS\S'    SSS jjrSS jrSS jrSS jr	SS	 jr
SS
 jrSrg)r   iá  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.
r³   rç   c                ó8   • Xl         Xl        / U l        / U l        g r:   )Ú_index_baserç   Ú_blocksrD  )r=   rÍ   s     r3   r>   Ú_BlockTracker.__init__ë  s   € Ø%ÔØ$Œà9;ˆŒà "ˆ�
r5   c                óP   • U R                    VVs/ s H  u  pUPM	     snn$ s  snnf )z/The accumulated content blocks, in start order.)r¯  )r=   Ú_Úblocks      r3   rI  Ú_BlockTracker.content_blocksó  s    € à&*§l¢lÔ3¢l™(˜!“¡lÒ3Ð3ùÓ3s   �"c                óp  • UR                  S5      n[        U[        5      (       d  g[        UR                  S5      5      nU R                  R                  X#b  [        U5      O0 45        X R                  -   nXAS'   U R                  R                  U5        [        U R                  US-   5      U l
        g)z7Track a content_block_start, shifting `event["index"]`.r8   Nr6  rj   )rD   rƒ   r³   r¢   r¯  rˆ   Údictr®  rD  Úmaxrç   )r=   r  r8   r6  Úshifteds        r3   rE  Ú_BlockTracker.start÷  s’   € à—	‘	˜'Ó"ˆÜ˜%¤×%Ñ%ØÜ  §¡¨?Ó!;Ó<ˆØ�‰×Ñ˜UÑ;T¤D¨Ô$7ÐZ\Ð]Ô^Ø×*Ñ*Ñ*ˆØ ˆg‰Ø�
‰
×Ñ˜'Ô"Ü˜dŸo™o¨w¸©{Ó;ˆ�r5   c                óÚ   • UR                  S5      n[        U[        5      (       d  g[        UR                  S5      5      nUb  [	        U R
                  X#5        X R                  -   US'   g)zQApply a content_block_delta to its accumulating block, shifting `event["index"]`.r8   Nr<  )rD   rƒ   r³   r¢   Ú_apply_deltar¯  r®  )r=   r  r8   r<  s       r3   r<  Ú_BlockTracker.delta  sY   € à—	‘	˜'Ó"ˆÜ˜%¤×%Ñ%ØÜ˜Ÿ™ 7Ó+Ó,ˆØÑÜ˜Ÿ™ uÔ4Ø×!1Ñ!1Ñ1ˆˆgŠr5   c                ó  • UR                  S5      n[        U[        5      (       d  gX R                  -   nX1S'   X0R                  ;   a  U R                  R                  U5        [        U R                  US-   5      U l        g)z6Track a content_block_stop, shifting `event["index"]`.r8   Nrj   )rD   rƒ   r³   r®  rD  Úremover·  rç   )r=   r  r8   r¸  s       r3   rH  Ú_BlockTracker.stop  sg   € à—	‘	˜'Ó"ˆÜ˜%¤×%Ñ%ØØ×*Ñ*Ñ*ˆØ ˆg‰Ø—j‘jÓ Ø�J‰J×Ñ˜gÔ&Ü˜dŸo™o¨w¸©{Ó;ˆ�r5   c              #  óˆ   #   • U R                    H  n[        SSUS.5      v •  M     U R                   R                  5         g7f)z4content_block_stop events for any blocks still open.r:  r…  N)rD  rF  rM  )r=   r8   s     r3   rL  Ú_BlockTracker.close_open_blocks  s8   é € à—Z”ZˆEÜÐ,Ð7KÐV[Ñ.\Ó]Ô]ñ  à�
‰
×ÑÕùs   ‚A A)r¯  r®  rD  rç   N)r   )rÍ   r³   rO   rP   )rO   úlist[dict[str, Any]])r  r  rO   rP   ©rO   zIterator[bytes])rR   rS   rT   rU   rV   rW   r>   rI  rE  r<  rH  rL  rX   r2   r5   r3   r   r   á  s/   ‡ ñð ƒOØ8ö#ô4ô
<ô2ô	<÷r5   r   c                ó2  ^• [        U4S jU  5       S5      nUc  gUR                  S5      nUS:X  aK  [        UR                  S5      =(       d    S5      [        UR                  S5      =(       d    S5      -   US'   gUS:X  aK  [        UR                  S5      =(       d    S5      [        UR                  S	5      =(       d    S5      -   US'   gUS
:X  aW  UR                  S5      n[        U[        5      (       d  / nXSS'   [        SU5      R                  UR                  S5      5        gUS:X  aK  [        UR                  S5      =(       d    S5      [        UR                  S5      =(       d    S5      -   US'   gUS:X  a  UR                  S5      US'   gg)zAApply a content_block_delta to the accumulating block at `index`.c              3  ó<   >#   • U  H  u  pUT:X  d  M  Uv •  M     g 7fr:   r2   )r]  Úblock_indexr³  r8   s      €r3   r_  Ú_apply_delta.<locals>.<genexpr>!  s   øé € ÐQ²&Ñ.˜K¸KÈ5Ñ<P—%‘%²&ùs   ƒ“	Nr3  Ú
text_deltaÚtextrl   Úinput_json_deltaÚ_partial_jsonÚpartial_jsonÚcitations_deltaÚ	citationsru  ÚcitationÚthinking_deltaÚthinkingÚsignature_deltaÚ	signature)ÚnextrD   r�   rƒ   rK  r   rˆ   )r  r8   r<  r³  Ú
delta_typerÎ  s    `    r3   r»  r»    sX  ø€ äÔQ±&ÓQÐSWÓX€EØ�}ØØ—‘˜6Ó"€JØ�\Ó!Ü˜EŸI™I fÓ-×3°Ó4´s¸5¿9¹9ÀVÓ;L×;RÐPRÓ7SÑSˆˆfŠØ	Ð)Ó	)Ü!$ U§Y¡Y¨Ó%?×%EÀ2Ó!FÌÈUÏYÉYÐWeÓMf×MlÐjlÓImÑ!mˆˆoÒØ	Ð(Ó	(Ø—I‘I˜kÓ*ˆ	Ü˜)¤T×*Ñ*ØˆIØ!*�+ÑÜˆ[˜)Ó$×+Ñ+¨E¯I©I°jÓ,AÕBØ	Ð'Ó	'Ü §	¡	¨*Ó 5× ;¸Ó<¼sÀ5Ç9Á9ÈZÓCX×C^Ð\^Ó?_Ñ_ˆˆjÒØ	Ð(Ó	(Ø"ŸY™Y {Ó3ˆˆkÒð 
)r5   c                ó*  • / nU  H´  nUR                  S5      S:X  a  M  UR                  S5      n[        U[        5      (       d  UR                  U5        MS  UR	                  5        VVs0 s H  u  pEUS:w  d  M  XE_M     nnn[        U5      nUb  UOUR                  S5      US'   UR                  U5        M¶     U(       aI  US   R                  S5      S;   a1  UR                  5         U(       a  US   R                  S5      S;   a  M1  U$ s  snnf )u¿  Convert a hop's accumulated response blocks to the appended assistant turn.

A `fallback_has_prefill_claim` refusal guarantees the partial output is
resendable, so the blocks go out near-verbatim. Three rewrites apply:
`fallback` seam blocks (wire markers, not content) are dropped, tool inputs
are reassembled from their accumulated `input_json_delta` JSON
(content_block_start carries `input: {}`), and trailing thinking blocks are
stripped â€” the server rejects an assistant turn whose final block is
`thinking`, so a refusal that cut the stream mid-thought would otherwise
400 the continuation. A partial that was nothing but thinking strips to
empty, and the hop falls back to the same-body form.
r3  r7  rË  ÚinputrH   )rÑ  Úredacted_thinking)rD   rƒ   r�   rˆ   r“  rB  Úpop)Úresponse_blocksÚoutr³  rÌ  r”  r•  Úparseds          r3   r~  r~  5  sï   € ð €CÛ ˆØ�9‰9�VÓ 
Ó*ÙØ—y‘y Ó1ˆÜ˜,¬×,Ñ,Ø�J‰J�uÔÙØ.3¯k©k¬mÔVªm¡
 ¸sÀoÑ?U“�’©mˆÑVÜ˜LÓ)ˆØ#)Ñ#5™¸5¿9¹9ÀWÓ;Mˆˆg‰Ø�
‰
�5Öñ !ö �#�b‘'—+‘+˜fÓ%Ð)JÓJØ�‰Œ	ö �#�b‘'—+‘+˜fÓ%Ð)JÕJà€Jùó Ws   Á+DÁ;Dc                ó’  • U R                  S5      n[        U[        5      (       d  U $ Sn/ n[        SU5       Hö  n[	        U5      nUb  UR                  S5      OSnUb  [        U[        5      (       d  UR                  U5        MO  [        SU5      nU Vs/ s H,  n[        U5      (       a  UR                  S5      S:X  a  M*  UPM.     n	n[        U	5      [        U5      :X  a  UR                  U5        M¿  SnU	(       d  UR                  S	5      S
:X  a  Mß  UR                  0 UESU	0E5        Mø     U(       d  U $ 0 U ESU0E$ s  snf )u  A copy of `body` with `{type: "fallback"}` seam blocks filtered out of the
replayed message history; `body` itself when there are none.

An assistant turn left with no content by the strip â€” a seam-only turn â€” is
dropped whole; the server rejects empty-content turns.r�  Fru  Nr’  r3  r7  Tr‘  r�  )rD   rƒ   rK  r   r¢   rˆ   r   r   )
ri   r�  ÚstrippedÚstripped_messagesr“   Úmessage_dictr’  Úcontent_listr³  Úkepts
             r3   ry   ry   S  s;  € ð �x‰x˜
Ó#€HÜ�h¤×%Ñ%ØˆØ€HØ#%ÐÜ˜ XÖ.ˆÜ Ó(ˆØ1=Ñ1I�,×"Ñ" 9Ô-ÈtˆØÑ¤z°'¼4×'@Ñ'@Ø×$Ñ$ WÔ-ÙÜ˜K¨Ó1ˆÙ#/Ól¢<˜%¼À¿¹È5Ï9É9ÐU[ÓK\Ð`jÑKj—¡<ˆÐlÜˆt‹9œ˜LÓ)Ó)Ø×$Ñ$ WÔ-ÙØˆÞ˜×(Ñ(¨Ó0°KÓ?ÙØ× Ñ Ð!B LÐ!B°)¸TÑ!BÖCñ /ö ØˆØ2ˆdÐ2�JÐ 1Ñ2Ð2ùò ms   Â)EÃEc           	     ó´  ^• [        U R                  5      S   R                  SS5      nUR                  S5       Vs1 s H  o3R	                  5       iM     snm[
        R                  U4S jU 5       5      nU(       d  U(       a   SSR                  [        SU/UQ5      5      0O0 nU R                  [        U R                  U[        S5      5      S9$ s  snf )	zÙA copy of `request` with `betas` appended to its `anthropic-beta` header
(skipping values already present) and the middleware's helper-telemetry tag
appended to `x-stainless-helper`. Single `request.copy()` for both.
r   zanthropic-betarl   Ú,c              3  ó\   >#   • U  H!  n[        U5      T;  d  M  [        U5      v •  M#     g 7fr:   )r�   )r]  r    Úexistings     €r3   r_  Ú+_with_middleware_headers.<locals>.<genexpr>y  s$   øé € ÐW²E¨D¼SÀ»YÈhÑ=V›iœc $Ÿi˜i²Eùs   ƒ,š,Nzfallback-refusal-middleware)Úheaders)r    rè  rD   ÚsplitÚstripr¶  ÚfromkeysÚjoinÚfilterr{   r!   r$   )rn   r^   rí   r•  Ú	additionsÚbeta_headerræ  s         @r3   rx   rx   r  s¹   ø€ ô
 ˜GŸO™OÓ,¨QÑ/×3Ñ3Ð4DÀbÓI€GØ+2¯=©=¸Ô+=Ó>Ò+= %—‘–Ñ+=Ñ>€HÜ—‘ÔW±EÓWÓW€IÞW^ÖbkÐ# S§X¡X¬f°T¸GÐ;PÀiÐ;PÓ.QÓ%RÑSÐqs€KØ�<‰<Ü˜gŸo™o¨{¼MÐJgÓ<hÓið ð ð ùò ?s   ½Cc                ót   • [        U [        5      (       a#  U R                  b  U R                  R                  $ g)zEThe refusal's minted credit token; only the beta surface carries one.N)rƒ   r%   r=  r>  ©r“   s    r3   r…   r…   €  s/   € ä�'œ;×'Ñ'¨G×,@Ñ,@Ñ,LØ×#Ñ#×9Ñ9Ð9Ør5   c                ót   • [        U [        5      (       a#  U R                  b  U R                  R                  $ g)zOThe policy category that caused the refusal; only the beta surface carries one.N)rƒ   r%   r=  r”   rñ  s    r3   r†   r†   ‡  s/   € ä�'œ;×'Ñ'¨G×,@Ñ,@Ñ,LØ×#Ñ#×,Ñ,Ð,Ør5   c                ó   • SSU 0SU0SUS.S.$ )zBThe synthetic `fallback` content block marking one model boundary.r7  rk   rt   )r3  r”   )r3  Úfromr8  Útriggerr2   )r‘   r•   r”   s      r3   r‰   r‰   Ž  s)   € ð Ø˜*Ð%Ø˜Ð!Ø%°8Ñ<ñ	ð r5   c           
     ó¼  • [        [        U R                  R                  S5      5      5      nUb$  [	        UR                  S5      [        5      (       d  g[        0 UES/ UQ[        SUS   5      Q0E5      R                  S5      nU R                  R                  5       nS H  nXT;   d  M
  XE	 M     [        R                  " U R                  UUU R                  S9$ )zÍA 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-8Nr’  ru  ©zcontent-encodingzcontent-length)râ   rè  r’  rn   )r¢   rB  r’  Údecoderƒ   rD   rK  rã   r   Úencoderè  r{   r¤   ÚResponserâ   rn   )Úoriginalr’   r“   ri   rè  Úheaders         r3   Ú_seamed_http_responserþ  ˜  sÐ   € ô ”z (×"2Ñ"2×"9Ñ"9¸'Ó"BÓCÓD€GØ�œj¨¯©°YÓ)?Ä×FÑFØÜÐ_˜'Ð_ 9Ð.^°Ð.^¼¸[È'ÐR[ÑJ\Ó8]Ð.^Ñ_Ó`×gÑgÐhoÓp€DØ×Ñ×#Ñ#Ó%€GÛ8ˆØÕØ’ñ 9ô �?Š?Ø×(Ñ(ØØØ× Ñ ñ	ð r5   c           
     óº   • [        U R                  U5      nUc  U $ [        UU R                  U R                  SU R
                  U R                  U R                  S9$ ©NFr¶   )rþ  r|   r   rÀ   rÁ   rÂ   rÃ   r¼   ©rp   r’   r·   s      r3   rŠ   rŠ   ®  s^   € Ü
 × 6Ñ 6¸Ó
>€CØ
�{ØˆÜØØ×!Ñ!Ø×ÑØØ×'Ñ'Ø×!Ñ!Ø×,Ñ,ñð r5   c           
     óº   • [        U R                  U5      nUc  U $ [        UU R                  U R                  SU R
                  U R                  U R                  S9$ r   )rþ  r|   r   rÀ   rÁ   rÂ   rÃ   r¼   r  s      r3   r›   r›   ½  s^   € Ü
 × 6Ñ 6¸Ó
>€CØ
�{ØˆÜØØ×!Ñ!Ø×ÑØØ×'Ñ'Ø×!Ñ!Ø×,Ñ,ñð r5   c                ó  • [        U [        SU5      5      n[        UR                  S5      5      nUbL  [        [        U R                  S5      5      =(       d    0 U5      nU(       a  XBS'   U$ UR	                  SS5        U$ )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)Ú_patchr   r¢   rD   rÙ  )ri   ró   Úpatchedr  Úmergeds        r3   rz   rz   Ì  sw   € ô �Tœ4Ð 0°%Ó8Ó9€GÜ˜UŸY™Y Ó7Ó8€MØÑ Üœ §¡¨/Ó!:Ó;×A¸rÀ=ÓQˆÞØ'-�OÑ$ð €Nð �K‰K˜¨Ô.Ø€Nr5   c                ó„   • [        U 5      nUR                  5        H   u  p4Uc  UR                  US5        M  XBU'   M"     U$ )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)r¶  r“  rÙ  )rä   Ú	overridesr  r”  r•  s        r3   r  r  á  sA   € ô �4‹j€GØ—o‘oÖ'‰
ˆØ‰=Ø�K‰K˜˜TÖ"à �C‹Lñ	 (ð
 €Nr5   c                óF   • [        X5      nU(       a  [        U5      US'   U$ )z”The 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>  )rz   r4   )ri   r7  Úcredit_tokenr  s       r3   r‡   r‡   î  s&   € ô ˜Ó'€FÞÜ*=¸lÓ*KˆÐ&Ñ'Ø€Mr5   c                óP   •  [         R                  " U 5      $ ! [         a     g f = fr:   )r£   ÚloadsrÞ   )rÉ  s    r3   rB  rB  ÷  s(   € ðÜ�zŠz˜$ÓÐøÜó Ùðús   ‚ ˜
%¤%c                ó,   • [         R                  " U SS9$ )N)rä  Ú:)Ú
separators)r£   Údumps©r•  s    r3   rã   rã   þ  s   € Ü�:Š:�e¨
Ñ3Ð3r5   c                ó>   • [        U 5      (       a  [        SU 5      $ S $ )Nr  )r   r   r  s    r3   r¢   r¢     s   € Ü,3°E¯N©NŒ4Ð  %Ó(ÐDÀÐDr5   c                ól   •  [         R                  " U R                  5       5      $ ! [         a     g f = fr:   )r£   r  ÚreadrÞ   ©rp   s    r3   rá   rá     s.   € ðÜ�zŠz˜(Ÿ-™-›/Ó*Ð*øÜó Ùðús   ‚#& ¦
3²3c              ƒ  óˆ   #   •  [         R                  " U R                  5       I S h  v•N 5      $  N! [         a     g f = f7fr:   )r£   r  ÚareadrÞ   r  s    r3   r  r    s7   é € ðÜ�zŠz §¡Ó 0×0Ó1Ð1Ñ0øÜó Ùðüs,   ‚A„#2 §0¨2 ¯A°2 ²
?¼A¾?¿Ac                óF   • [        U [        U5      S9R                  S5      $ )N©r  rC  r÷  )Ú_serialize_sserã   rú  )r  Úpayloads     r3   rF  rF    s   € Ü ¬K¸Ó,@ÑA×HÑHÈÓQÐQr5   c                óØ   • U R                   (       a-  SR                  U R                   5      S-   R                  S5      $ [        U R                  U R
                  S9R                  S5      $ )z¿Forward 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

r÷  r  )r·   rì  rú  r  r  rC  )rR  s    r3   rG  rG    sN   € ð
 ‡w‡wØ—	‘	˜#Ÿ'™'Ó" VÑ+×3Ñ3°GÓ<Ð<Ü §	¡	°·±Ñ9×@Ñ@ÀÓIÐIr5   c                ój   • SnU b	  USU  S3-  nUR                  S5       H  nUSU S3-  nM     US-   $ )zÒSerialize 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`.
rl   zevent: r  zdata: )ré  )r  rC  rÛ  Úlines       r3   r  r  "  sR   € ð €CØÑØ�˜˜˜rÐ"Ñ"ˆØ—
‘
˜4Ö ˆØ�˜�v˜RÐ Ñ Šñ !à�‰:Ðr5   c           	     ó
  • U=(       d    0 nU UUR                  S5      =(       d    SUR                  S5      =(       d    SUR                  S5      =(       d    SUR                  S5      =(       d    SUR                  S5      S.$ )NÚinput_tokensr   Úoutput_tokensÚcache_read_input_tokensÚcache_creation_input_tokensÚcache_creation)r3  rk   r"  r#  r$  r%  r&  )rD   )r3  rk   r  Úus       r3   r£  r£  0  sp   € ð 	��€AàØØŸ™˜nÓ-×2°ØŸ™˜Ó/×4°1Ø#$§5¡5Ð)BÓ#C×#HÀqØ'(§u¡uÐ-JÓ'K×'PÈqØŸ%™%Ð 0Ó1ñð r5   c                óª   • U=(       d    0 n0 UEU =(       d    0 EnUR                  5        H$  u  p4Ub  M
  UR                  U5      c  M  X   X#'   M&     U$ )z0Fill `None` fields on `primary` from `fallback`.)r“  rD   )Úprimaryr7  rÛ  r”  r•  s        r3   rJ  rJ  ?  sS   € à�~˜2€HØ9˜XÐ9¨'¯-°RÐ9€CØ—i‘i–k‰
ˆØ‹=˜XŸ\™\¨#Ó.Ó:Ø‘}ˆC‹Hñ "ð €Jr5   c                ó°   • U R                   R                  5       nS H  nX2;   d  M
  X#	 M     [        R                  " U R                  UUU R
                  S9$ )zÈA 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ø  )râ   rè  r~   rn   )rè  r{   r¤   rû  râ   rn   )rü  r~   rè  rý  s       r3   r¾   r¾   I  sX   € ð ×Ñ×#Ñ#Ó%€GÛ8ˆØÕØ’ñ 9ô �?Š?Ø×(Ñ(ØØØ× Ñ ñ	ð r5   c                  óF   • \ rS rSrSS jr\SS j5       r\S	S j5       rSrg)
r¿   i]  c                ó   • Xl         g r:   ©Ú_frames©r=   rÅ   s     r3   r>   Ú_FrameByteStream.__init__^  ó   € Ø�r5   c                ó   • U R                   $ r:   r-  r<   s    r3   Ú__iter__Ú_FrameByteStream.__iter__a  r1  r5   c                ó8   • U R                   R                  5         g r:   )r.  rØ   r<   s    r3   rØ   Ú_FrameByteStream.closee  s   € à�‰×ÑÕr5   r-  N)rÅ   r	  rO   rP   rÃ  rN   )	rR   rS   rT   rU   r>   r   r3  rØ   rX   r2   r5   r3   r¿   r¿   ]  s/   † ôð óó ðð óó ór5   r¿   c                  óF   • \ rS rSrSS jr\SS j5       r\S	S j5       rSrg)
rÉ   ij  c                ó   • Xl         g r:   r-  r/  s     r3   r>   Ú_AsyncFrameByteStream.__init__k  r1  r5   c                ó   • U R                   $ r:   r-  r<   s    r3   Ú	__aiter__Ú_AsyncFrameByteStream.__aiter__n  r1  r5   c              ƒ  óT   #   • U R                   R                  5       I S h  v•N   g  N7fr:   )r.  r   r<   s    r3   r   Ú_AsyncFrameByteStream.acloser  s   é € à�l‰l×!Ñ!Ó#×#Ó#ùs   ‚( &¡(r-  N)rÅ   r
  rO   rP   )rO   úAsyncIterator[bytes]rN   )	rR   rS   rT   rU   r>   r   r;  r   rX   r2   r5   r3   rÉ   rÉ   j  s/   † ôð óó ðð ó$ó ó$r5   rÉ   )r0   r�   rO   r(   )rp   úhttpx2.Responserï   rÕ   rO   z#Generator[bytes, None, _HopOutcome])rp   r@  rï   rÕ   rO   r?  )r  r  r  r  rO   rP   )rt   r  r¤  r�   rO   rÂ  )rª  r  rk   r�   rO   r  )r  z list[tuple[int, dict[str, Any]]]r8   r³   r<  r  rO   rP   )rÚ  rÂ  rO   rœ  )ri   r  rO   r  )rn   r   r^   r,   rO   r   )r“   zMessage | BetaMessagerO   rk  )r‘   r�   r•   r�   r”   rk  rO   r  )rü  r@  r’   rÂ  rO   zhttpx2.Response | None)rp   r  r’   rÂ  rO   r  )rp   r  r’   rÂ  rO   r  )ri   r  ró   r'   rO   r  )rä   r  r	  r  rO   r  )ri   r  r7  r'   r  rk  rO   r  )rÉ  r�   rO   r   )r•  r   rO   r�   )r•  rQ   rO   r  )rp   r@  rO   r   )r  r�   r  r  rO   Úbytes)rR  r   rO   rA  )r  rk  rC  r�   rO   r�   )r3  z&Literal['message', 'fallback_message']rk   r�   r  r  rO   r  )r)  r  r7  r  rO   r  )rü  r@  r~   z.httpx2.SyncByteStream | httpx2.AsyncByteStreamrO   r@  )nÚ
__future__r   r{   rb  r£   ÚloggingÚtypingr   r   r   r   r   r	   r
   r   r   r   r   Úcontextvarsr   r   Útyping_extensionsr   r   r¤   Ú_utilsr   Ú_modelsr   Ú_requestr   Ú	_responser   r   Ú
_streamingr   r   r   Ú_exceptionsr   Ú_middlewarer   r   r   Ú_base_clientr    r!   Ú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+   rW   rª   r-   r4   r)   rA   rC   r*   r  rè   rà   r  rÕ   rÖ   rþ   rÙ   rQ  r  rP  r   r»  r~  ry   rx   r…   r†   r‰   rþ  rŠ   r›   rz   r  r‡   rB  rã   r¢   rá   r  rF  rG  r  r£  rJ  r¾   ÚSyncByteStreamr¿   ÚAsyncByteStreamrÉ   r2   r5   r3   Ú<module>rY     s6  ðÞ "ã Û Û ÷÷ ÷ ñ ÷ *ß /ã å Ý  Ý "ß 6ß >Ñ >Ý )ß >Ñ >ß 8Ý $Ý .Ý 2Ý <Ý ?Ý Wð Ø#ð€ð ×'Ò'Ð(BÓC€€^Ó Cà€à0O€Ð-Ó OØ >ô3÷*ñ *ñ< 9CÐCbÐlpÑ8q€Ð5Ó qñ S]Ø*°BñSÐ ÐOó ô
j	' Jô j	'ôZ/ˆyô /ô&�)ô ôS�)ô Sô3�)ô 3÷4f
ñ f
ôR	ô÷]ñ ]ô@kôHô,G÷;ñ ;ô|4ô,ô<3ô>ôôôôô,ôôô*
ôôô4ôEôôôRôJôðØ
0ðØ9<ðØEZðàôôðØðØ'Uðàôô(
�v×,Ñ,ô 
ô
$˜F×2Ñ2õ 
$r5   