o 6Wj@s:UddlmZddlZddlZddlZddlmZmZm 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/ddl0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7ddgZ8e9dZ:de;d<dZeddd Z?d!e;d"<ed#d$d Z@d%e;d&<Gd'dde*ZAGd(d)d)eZBGd*d+d+eZCGd,d-d-eZDGd.d/d/eZEGd0d1d1ZFdd7d8ZGdd:d;ZHGdbodyrSrXresponserT first_hoppinmodelrefusal)_applicable_bodyr6r9 _start_index _make_pin_with_middleware_headersrQ_strip_seam_blocksrPcopy http_response is_successstreamlen_splice_fallback_streamstrparse isinstancer r# stop_reason _credit_token_refusal_category _merged_bodyappend _seam_block_prepend_seam_blocksr1rSrTrXstate start_indexr] initial_bodyinitial_requestr[r\r+res from_modelseamsmessager:categoryto_modelservedr2r2r3handles`        z$BetaRefusalFallbackMiddleware.handlerAsyncAPIResponse[Any]cs||}|dur||IdHSt}||}||}t||j}t|}|dkr/|ni||j|}|j |d}||IdH} | j j sK| S|j rf|d} | t |jkr[| S|j||| || |dS|} | } t|dpqd} g}| t |jdkr| j j r| IdH}t|ttfr|jdkrnG| d7} || t|}t|}||j t||j| |dIdH} | j j rt|j| d}|t| |||} | t |jdkr| j j s|r| j j r| IdH}t|ttfr|jdkrt| |S| SrV)rar6r9rbrcrdrQrerPrfrgrhrirj_splice_fallback_stream_asyncrlrmrnr r#rorprqrrrsrt_prepend_seam_blocks_asyncrvr2r2r3 handle_asyncsb      $  z*BetaRefusalFallbackMiddleware.handle_asyncdict[str, Any] | NonecCsjt|j}t|j}|jr&|jdks&|jt ks&|j ddks&|dur(dS| ddur3t d|S)zMThe request's JSON body when this middleware applies to it, `None` otherwise.postbetatrueNrLazSending 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_dictjsonhttpxURLurlrPmethodlowerpath_MESSAGES_PATHparamsr9r)r1rSrXrr2r2r3ra5s   z.BetaRefusalFallbackMiddleware._applicable_bodyrwBetaFallbackState | NoneintcCsX|dus |jdur dS|j}d|krt|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. Nr>zBetaFallbackState.index z! is out of bounds for a chain of z? fallback(s); was the state shared with a different middleware?)r+rjrPr)r1rwrxr2r2r3rbOsz*BetaRefusalFallbackMiddleware._start_indexCallable[[int], None]csdfdd }|S) zUPin requests sharing the state to the entry being tried (or warn that there is none).r+rr,r-cs0dur |_dSjsd_tddSdS)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+rRr(warningr/r1rwr2r3r]bs z4BetaRefusalFallbackMiddleware._make_pin..pinN)r+rr,r-r2)r1rwr]r2rr3rc_s z'BetaRefusalFallbackMiddleware._make_pinrXdict[str, Any]r[r\r]c CB|j||||||d}tt|jt||j|jd|j|j|j dS)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. rZTrawcast_toclientri stream_clsoptions retries_taken) _spliced_framesr_spliced_http_responserg_FrameByteStream_cast_to_client _stream_cls_optionsrr1rSrXr[rTr\r]framesr2r2r3rkps"z5BetaRefusalFallbackMiddleware._splice_fallback_streamc Cr)NrZTr) _spliced_frames_asyncrrrg_AsyncFrameByteStreamrrrrrrr2r2r3rs" z;BetaRefusalFallbackMiddleware._splice_fallback_stream_asyncGenerator[bytes, None, None]c cs|j}|j}zU|j} tdddddgd} t| | EdH} | jdur0W|dur.|dSdS| d}t|| } t|t |D] } || }t |d}| dt |k}|| | }d}d}tdD]q}|j | ||d}z||}Wn ty}ztd ||t|dd }WYd}~nDd}~ww|jjr|j}n6t|j}|j|dkr|jd kr|rtd t|| j}d}qhtd ||jt|t||jd }|dur|rqC| |D]}|VqW|dur|dSdS|dusJ|j}| |t| j|t| j|d| j| j| d} t|| EdH} | j r-| !| jdurBW|dur@|dSdS|d}| "| ||qCW|dur\|dSdS|durh|wwNrTF) index_basehas_nextsplice wire_open primary_id seam_framesr^rYr!rWzOanthropic-sdk: BetaRefusalFallbackMiddleware: fallback request to %s failed: %s)r^statusizanthropic-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) iterationsr^)#rPrg _HopReader _drive_hoprefusedclose _ChainStatebeginrangerjrl continuationrfhop_body Exceptionr(error _HopFailurerh _read_json status_coder _json_dumpsbaseterminal_failure_frames queue_seam next_index _SpliceInforrrpending_seam_framesopened mark_openedabsorb_refusal)r1rSrXr[rTr\r]rLcurrentstream_areaderoutcomechainhopentryr^rrres_bfailureattempt hop_requesterrerr_bodyframe hop_responser2r2r3rs  \              U  z-BetaRefusalFallbackMiddleware._spliced_framesAsyncGenerator[bytes, None]c CsF|j}|j}z|j} tdddddgd} t| | 2z 3dHW} | Vq6| } | jdur?W|dur=|IdHdSdS| IdHd}t|| } t |t |D]-}||}t |d}|dt |k}||| }d}d}t dD]z}|j | ||d}z ||IdH}Wn ty}ztd ||t|dd }WYd}~nJd}~ww|jjr|j}n C  C    " 8{c@s:eZdZUded< ded< ded<ded<ded<d S) _Refusal Optional[str]r:rboolhas_prefill_claimDict[str, Any]usageeventN)rCrDrErGr2r2r2r3rs rc@"eZdZUdZded<ded<dS)rz6Splice context for fallback hops; `None` for stream A.List[Dict[str, Any]]rrlr^NrCrDrErFrGr2r2r2r3rs  rc@r)rz[A fallback hop whose request failed; stamps `recommended_model` when it ends the chain.rlr^z Optional[int]rNrr2r2r2r3rs rc@sVeZdZUdZded< ded< ded< ded < d ed < d ed < ded<dS) _HopOutcomez*The outcome of consuming one hop's stream.zOptional[_Refusal]rrr^zOptional[Dict[str, Any]] start_eventrblocksrrrrlast_fallback_toNrr2r2r2r3rs rc@s\eZdZUdZded< d!ddZed"ddZd#ddZd$ddZ d$ddZ d%ddZ d S)&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 | Nonerrrrrr_SpliceInfo | Nonerr str | Noner list[bytes]r,r-cCs\t||_||_||_||_||_||_d|_d|_d|_ d|_ g|_ d|_ d|_ d|_dS)NF) _BlockTracker_tracker _has_next_splice _wire_open _primary_id _seam_frames_model _start_usage _start_event _held_start_held_opened_last_fallback_tor)r1rrrrrrr2r2r3r4s  z_HopReader.__init__cC|jSr.)rr0r2r2r3r'z_HopReader.openedsserc Cs tt|j}|dur|dnd}|j}|dkrG|durGt|d}|dur?|d}t|tr4|nd|_t|d|_||_ ||_ gS|dkr|dur| }t|d}|dur|dd krt|d } | duru| dnd} t| tr| |_ |j ||durg|td|Sg|t|S|d kr|dur| }|j ||durg|td |Sg|t|S|d kr|dur| }|j ||durg|td |Sg|t|S|d kr|durt|dpi} | ddkrt| d} | dur| ddkr| nd} | dur%| dnd}t|tr2|r2|nd}|j o>|j  }|jr|dusK|rtt|d|j}t|j }d|_ |jtt|| durr| dnd| duo~| ddu||d|j|j |j |j j|j|j d|_|S|st dnt d| }|dur| ddkrt| d} | dur| !ddt|dpi}g|j"t#||j$|d<||d<g|td |Sg|t|S|js|j%|gSt|gS)z:Process one event, returning the frames to forward for it.Ntype message_startr~r^rcontent_block_start content_blockfallbacktocontent_block_deltacontent_block_stop message_deltadeltaror` stop_detailsfallback_credit_tokenrfallback_has_prefill_claimT)r:rrrrrr^rrrrrzvanthropic-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_jsondatar9rrnrlrrrr_openrrstart_emit_passthrough_sserstoprcontent_blocksr _backfilllistclose_open_blocksrclearrrrrr(r setdefaultr_serving_iteration_entryr^rs)r1rr event_typerr~r^rr r rrrdetailsr: pre_streamrr2r2r3feed+s     "        z_HopReader.feedcCs|jrgSd|_g}|jdur|jdur|t|jn+|jsH|jdurHt|j}t | d}|dur@|j dur@|j |d<|t d|| |j| dd|jDd|_|j|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.TNr~idrcs|]}t|VqdSr.)r).0heldr2r2r3 z#_HopReader._open..)rrrrsrrr_copydeepcopyrr9rrextendrrr )r1rrr~r2r2r3rs&      z_HopReader._opencCs|jdus|jr gS|S)zCFrames still owed when the stream ends without a chainable refusal.N)rrrr0r2r2r3 finish_framessz_HopReader.finish_framesrc Cs8|jdur|jStd|j|j|j|jj|j|jdS)zCThe outcome once the hop's stream is fully consumed (or cut early).Nr) rrrrrrrrrr0r2r2r3rs z_HopReader.finishN)rrrrrrrrrrrrr,r-)r,r)rrr,rr,r)r,r) rCrDrErFrGr4propertyrr&rr0rr2r2r2r3rs     z rr[httpx.Responserr,#Generator[bytes, None, _HopOutcome]ccsRt|D]}||D]}|Vq |jdurnq|D]}|Vq|S)zKFeed one hop's SSE events through `reader`, yielding the frames to forward.N)r raw_eventsr&rr0rr[rrrr2r2r3rs  rAsyncIterator[bytes]cCsXt|2z3dHW}||D]}|Vq|jdurnq6|D]}|Vq$dS)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)rr5r&rr0r6r2r2r3rs  rc@seZdZUdZded< ded< ded< ded < ded <d ed <d ed <ded<ded<ded<ded< d7ddZed8ddZd9d d!Zd:d#d$Z d;d%d&Z dd0d1Z d?d4d5Zd6S)@rz9Bookkeeping shared across the hops of one spliced stream.rrrrrrrl primary_modelr: List[Any]rpartialr|r last_refusalzDict[str, Any] | Nonelast_start_eventrrrXrr,r-cCs||_g|_dSr.)_body_pending_seams)r1rXr2r2r3r4s z_ChainState.__init__rrcCs|jdusJ||}t|dpd|_|j|_|j|_t|jp"id}|dur0|dnd}t |tr9|nd|_ |jj |_ g|_ |jj rMt|jng|_|jpU|j|_|j|_|j|_t|j|j|_|S)z3The chain state after stream A's chainable refusal.Nr^r_r~r')rrlr9r8rrrrrrnrr:rr_to_prefill_blocksrr:rr|r;r<_declined_iteration_entriesr)clsrXrr start_messagestart_idr2r2r3r s  z_ChainState.beginrc CsV|j}|jd7_|jtdd|t|j||jjdtdd|dg||_dS)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. rYr)rr+r r rr+N)rr>r/rrtr|r;r)r1r seam_indexr2r2r3r#s z_ChainState.queue_seamrcCs t|jSr.)rr>r0r2r2r3r;r5z_ChainState.pending_seam_framescCsd|_|jdS)NT)rr>r r0r2r2r3r>sz_ChainState.mark_opened list[Any]cCsg|j|jSr.)rr:r0r2r2r3rBsz_ChainState.continuationrr%rcCsfddi|j|D}|jdur|j|d<|r1|d}gt|tr'|ngd|d|d<|S)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. cSi|] \}}|dkr||qS)rLr2r)keyvaluer2r2r3 Mz(_ChainState.hop_body..Nrmessages assistant)rolecontent)r=itemsr:r9rnr)r1rrrXrMr2r2r3rEs   z_ChainState.hop_bodyr^cCsp|jdusJ|jj|_||_|jjrt|jng|_|jt |j||j|_ |j dur2|j |_ |j |_ dS)z7Fold a refused hop's outcome in, readying the next hop.N)rr:rrr?rr:rr/r@r;rr<r)r1rr^rr2r2r3rXs   z_ChainState.absorb_refusalrrc Cs g}|js-|jdur-t|j}t|d}|dur%|jdur%|j|d<|td|| |j t|j j }t|d}|dur\t|d}|dur\|j dvrX|jnd|d<t|d pdi}t|j|d <||d <|td ||td 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. Nr~r'rrr)iirrrr message_stopr)rr<r-r.rr9rrsrr/r>r;rrr^r) r1rrrr~rrr$rr2r2r3rds(   z#_ChainState.terminal_failure_framesN)rXrr,r-)rXrrrr,r)rrlr,r-r1rB)r,rF)rr%rrFr,r)rrr^rlrrFr,r-)rrr,r)rCrDrErFrGr4 classmethodrrrrrrrrr2r2r2r3rs8          rr` model_labelrllist[dict[str, Any]]cCs|jd}t|tr8|r8ddtd|D}dd|D}|r8t|dkr6t|dd ts6||dd <|Std ||jgS) 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. rcsr(r.)rr)rr2r2r3r+r,z._declined_iteration_entries..r9cSs$g|]}|duri|ddiqS)Nrr~r2rVr2r2r3 s$z/_declined_iteration_entries..rYrr^r~)rr9rnrr rjrl_to_iteration_usage)r`rTreported dict_entriesentriesr2r2r3r@s   r@ delta_usagerr^cCsZ|d}t|tr'|r'ttd|d}|dur'i|d|dp#|dStd||S)zThe serving hop's `fallback_message` completer entry: its own self-reported iteration relabeled, or one built from its delta usage.rr9r>Nfallback_messager^)rr^)r9rnrrr rX)r\r^rYlastr2r2r3r"s  r"c@sZeZdZUdZded< dddd Zdd d ZdddZdddZdddZ dddZ dS)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. rrrrr,r-cCs||_||_g|_g|_dSr.) _index_baser_blocksr)r1rr2r2r3r4s z_BlockTracker.__init__rUcCsdd|jDS)z/The accumulated content blocks, in start order.cSsg|]\}}|qSr2r2)r)_blockr2r2r3rWz0_BlockTracker.content_blocks..)r`r0r2r2r3rsz_BlockTracker.content_blocksrrcCsz|d}t|ts dSt|d}|j||durt|nif||j}||d<|j|t |j |d|_ dS)z7Track a content_block_start, shifting `event["index"]`.r+Nr rY) r9rnrrr`rsdictr_rmaxr)r1rr+r shiftedr2r2r3rs     z_BlockTracker.startcCsN|d}t|ts dSt|d}|durt|j||||j|d<dS)zQApply a content_block_delta to its accumulating block, shifting `event["index"]`.r+Nr)r9rnrr _apply_deltar`r_)r1rr+rr2r2r3rs  z_BlockTracker.deltacCsV|d}t|ts dS||j}||d<||jvr |j|t|j|d|_dS)z6Track a content_block_stop, shifting `event["index"]`.r+NrY)r9rnrr_rremoverer)r1rr+rfr2r2r3rs     z_BlockTracker.stopIterator[bytes]ccs.|jD] }tdd|dVq|jdS)z4content_block_stop events for any blocks still open.r rDN)rrr )r1r+r2r2r3rs z_BlockTracker.close_open_blocksN)r)rrr,r-)r,rU)rrr,r-r,ri) rCrDrErFrGr4rrrrrr2r2r2r3rs      rr list[tuple[int, dict[str, Any]]]r+rrr-cs*tfdd|Dd}|durdS|d}|dkr1t|dp"dt|dp*d|d<dS|dkrKt|d p.Nr text_deltatextr_input_json_delta _partial_json partial_jsoncitations_delta citationsr9citationthinking_deltathinkingsignature_delta signature)nextr9rlrnrr rs)rr+rrb delta_typersr2r/r3rgs& ,,  ,rgresponse_blocksrFcCsg}|D]9}|ddkrq|d}t|ts||qdd|D}t|}|dur1|n|d|d<||q|rX|ddd vrX||rX|ddd vsI|S) uConvert 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. rr rpcSrG)rpr2rHr2r2r3rKrLz&_to_prefill_blocks..Ninputr>)rvredacted_thinking)r9rnrlrsrQrpop)r{outrbrqparsedr2r2r3r?s      r?rXc Cs|d}t|ts |Sd}g}td|D]Q}t|}|dur$|dnd}|dus/t|ts5||qtd|}dd|D}t|t|krO||qd}|s[|d d kr[q|i|d|iq|sk|Si|d|iS) uA 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.rMFr9NrPcSs&g|]}t|r|ddks|qS)rr )rr9)r)rbr2r2r3rW-s&z&_strip_seam_blocks..TrOrN)r9rnrr rrsrj) rXrMstrippedstripped_messagesr~ message_dictrP content_listkeptr2r2r3res.     rerSrrKcstdd|jDdd}dd|dDtfdd |D}d d|jD}|s5|rBd t d |g||d<|j t |t d dS)zA 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. cSs i|] \}}t|tr||qSr2)rnrlr)kvr2r2r3rKAs z,_with_middleware_headers..anthropic-betar_cSsh|]}|qSr2)strip)r)rJr2r2r3 Brcz+_with_middleware_headers..,c3s$|] }t|vrt|VqdSr.)rl)r)rexistingr2r3r+Cs"z+_with_middleware_headers..cSs"i|] \}}|dkr||qS)r)rrr2r2r3rKDs"z, Nzfallback-refusal-middleware)headers) rHeadersrrQr9splitrdfromkeysjoinfilterrfrr")rSrKr additionsrr2rr3rd:s"rdr~Message | BetaMessagercC t|tr|jdur|jjSdS)zEThe refusal's minted credit token; only the beta surface carries one.N)rnr#rrr~r2r2r3rpJrpcCr)zOThe policy category that caused the refusal; only the beta surface carries one.N)rnr#rrrr2r2r3rqQrrqr|rrcCsdd|id|id|ddS)zBThe synthetic `fallback` content block marking one model boundary.r r^r`)rr)rfromr triggerr2)r|rrr2r2r3rtXs rtoriginalr}httpx.Response | NonecCstt|jd}|dust|dtsdSti|dg|td|di d}|j }dD] }||vr>||=q5t j |j|||jdS)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-8NrPr9zcontent-encodingzcontent-length)rrrPrS)rrrPdecodernr9rrr encoderrfrResponserrS)rr}r~rXrheaderr2r2r3_seamed_http_responsebs, rrUc C8t|j|}|dur |St||j|jd|j|j|jdSNFr)rrgrrrrrrr[r}rr2r2r3rux rurc Crr)rrgrrrrrrrr2r2r3rrrr r% credit_tokencCsi||}|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.rr2)rXr rmergedr2r2r3rrs rrrnrcCs"zt|WStyYdSwr.)rloadsr)rnr2r2r3rs   rrJcCstj|ddS)N)r:) separators)rdumpsrJr2r2r3rsrr=rcCst|r td|SdS)Nr)rr rr2r2r3rrcCs&zt|WStyYdSwr.)rrreadrr[r2r2r3rs  rcs.z t|IdHWStyYdSwr.)rrareadrrr2r2r3rs  rrpayloadbytescCst|t|ddS)Nrrr)_serialize_sserr)rrr2r2r3rrrrrcCs2|jrd|jddSt|j|jddS)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)rr2r2r3rsrrcCsDd}|dur|d|d7}|dD] }|d|d7}q|dS)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`. r_Nzevent: rzdata: )r)rrrliner2r2r3rs rr&Literal['message', 'fallback_message']rc CsJ|pi}|||dp d|dpd|dpd|dpd|ddS)N input_tokensr output_tokenscache_read_input_tokenscache_creation_input_tokenscache_creation)rr^rrrrr)r9)rr^rur2r2r3rXs    rXprimarycCsP|pi}i||p i}|D]\}}|dur%||dur%||||<q|S)z0Fill `None` fields on `primary` from `fallback`.N)rQr9)rr rrIrJr2r2r3rs rri,httpx.SyncByteStream | httpx.AsyncByteStreamcCs8|j}dD] }||vr||=qtj|j|||jdS)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)rrrirS)rrfrrrrS)rrirrr2r2r3rs rc@2eZdZd ddZeddd Zedd d Zd S)rrrr,r-cC ||_dSr._framesr1rr2r2r3r4r5z_FrameByteStream.__init__ricCrr.rr0r2r2r3__iter__ rz_FrameByteStream.__iter__cCs|jdSr.)rrr0r2r2r3r sz_FrameByteStream.closeN)rrr,r-rjrB)rCrDrEr4rrrr2r2r2r3r   rc@r)rrrr,r-cCrr.rrr2r2r3r4r5z_AsyncFrameByteStream.__init__r7cCrr.rr0r2r2r3 __aiter__rz_AsyncFrameByteStream.__aiter__cs|jIdHdSr.)rrr0r2r2r3rsz_AsyncFrameByteStream.acloseN)rrr,r-)r,r7rB)rCrDrEr4rrrr2r2r2r3rrr)r[r3rrr,r4)r[r3rrr,r7)r`rrTrlr,rU)r\rr^rlr,r)rrkr+rrrr,r-)r{rUr,rF)rXrr,r)rSrrKr)r,r)r~rr,r)r|rlrrlrrr,r)rr3r}rUr,r)r[rUr}rUr,rU)r[rr}rUr,r)rXrr r%rrr,r)rnrlr,r)rJrr,rl)rJr=r,r)r[r3r,r)rrlrrr,r)rrr,r)rrrrlr,rl)rrr^rlrrr,r)rrr rr,r)rr3rirr,r3)g __future__rrfr-rloggingtypingrrrrrrr 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(rGrr*r&r6r8r'rrrrrrrrr@r"rrgr?rerdrprqrtrrurrrrrrrrrrrrXrrSyncByteStreamrAsyncByteStreamrr2r2r2r3s4            a  _    A  !