"j.SrSSKJr SSKrSSKrSSKJrJrJrJ r SSK J r J r J r SSKJrJrJr SSKJrJr SSKJrJr S S KJr S S KJr S S KJr S S KJrJrJ r J!r!J"r"J#r#J$r$J%r% S SK&J'r' S SK(J)r) SSKJ*r*J+r+ /SQr,Sr-Sr.Sr/Sr0\Sr1\Rd"S\RfS9r4S Sjr5S!Sjr6S"Sjr7S#Sjr8S$Sjr9\"SS\+55r:g)%uModel-continuation primitives shared by the agent graph. A *continuation* happens when a model returns a `ModelResponse` with `state == 'suspended'` (Anthropic `pause_turn`, OpenAI background mode, …): the graph re-issues the request with the suspended response echoed back, and the provider resumes the same logical turn. This module owns the provider-agnostic glue for stitching those segments back into a single response/stream: - [`merge_responses`][pydantic_ai.models._continuation.merge_responses] folds a continuation response into the one it continues. - [`merge_mode`][pydantic_ai.models._continuation.merge_mode] reports whether a continuation *replaces* or *accumulates*, so the streamed composite can reindex parts consistently with the merge. - [`_ContinuationStreamedResponse`][pydantic_ai.models._continuation._ContinuationStreamedResponse] drives the streamed loop, presenting every segment as one continuous stream. This module is deliberately decoupled from `_agent_graph`: it imports only from `models`, `messages`, `usage`, `exceptions`, and the stdlib. Pluggable timing is injected as `sleep_func` so the loop stays free of `now_utc()`/RNG and replays deterministically under durable executors (e.g. Temporal). ) annotationsN)AsyncGenerator AsyncIterator AwaitableCallable)AbstractContextManager nullcontextsuppress) dataclassfieldreplace)datetimetimezone)AnyLiteral)_utils) RunContext)UnexpectedModelBehavior)FinalResultEvent ModelMessage ModelResponseModelResponseStateModelResponseStreamEventPartDeltaEvent PartEndEventPartStartEvent) ModelSettings) RequestUsage)ModelStreamedResponse)MAX_BACKGROUND_POLLSMAX_GENERATION_CONTINUATIONS MergeModecancel_suspended_job merge_modemerge_responses_ContinuationStreamedResponse__pydantic_ai__replace_previous_response i)replace-same-id replace-new accumulate)tzcURn[R"U5(dgUR[5n[ [R"U5=(a UR[ 55$)zUWhether `response` carries the `FallbackModel` `replace_previous_response` directive.F)metadatar is_str_dictget_PYDANTIC_AI_METADATA_KEYbool_REPLACE_PREVIOUS_RESPONSE_KEY)responser2 namespaces ]/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/models/_continuation.py_has_replace_markerr;xsU  H   h ' ' 67I ""9-_)--@^2_ ``c\[R"U5(dU$UR[5n[R"U5(a [U;dU$UR 5VVs0sHup#U[:wdMX#_M nnn0UEnU(a X['U$U[ U$s snnf)aReturn `metadata` without the transient `replace_previous_response` marker (other keys intact). Copies before mutating so the caller's dicts (including the shared `__pydantic_ai__` namespace, which also holds the `FallbackModel` continuation pin) aren't touched. )rr3r4r5r7items)r2r9kvs r:_strip_replace_markerrAs   h ' ' 67I   y ) ).LPY.Y"+//"3["3$!q?  /HNN/SYY/..399,!$!9!9!ZX=Z=Z    2rX5N5N2rSYSjSjSpnp2rs*ZX->->*Z6??CXVX*Z[ %V__5H&3 Mr<cH# [R"URU55n[R"U5IShvN gN![Ra6 [ [ 5 UIShvN SSS5 e!,(df  e=f[ a gf=f7f)u=Best-effort teardown of a server-side suspended/background job that survives cancellation. When the trigger is a workflow/task cancellation (e.g. Temporal), awaiting the (activity-wrapped) cancel from inside an already-cancelled scope would raise `CancelledError` before the cancel runs, silently leaking the job. Shield the cancel so it completes before the cancellation propagates; Temporal's workflow loop respects `asyncio.shield`. Any error from the cancel itself is swallowed — a failing teardown must not replace the error (or cancellation) that aborted the run. N)asyncio ensure_futurecancel_suspended_responseshieldCancelledErrorr Exception)modelr8jobs r:r&r&s{    ? ? I JC nnS!!!  ! ! i II! !     s^&B"A AA B"A #B-B3A64B9 B B BB"BB"c^\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S'S\S'S\S'SrS\S'\rS \S'\ r S\S'\ "SSS9r S\S'\ "SSS9r S\S'\ "SSS9rS\S'\ "SSS9rS\S '\ "SSS9rS!\S"'S4S#jrS5U4S$jjrS6S%jrS7S&jrS8S'jr\S9S(j5rS:S)jrS;S*jr\SS-jrS>S.jr\S?S/j5r\S@S0j5r \S@S1j5r!\SAS2j5r"S3r#U=r$$)Br)aCA [`StreamedResponse`][pydantic_ai.models.StreamedResponse] that stitches continuation segments into one stream. Each segment is an ordinary `model.request_stream(...)` sub-stream. Their events are re-emitted as a single continuous stream, with part indices offset so parts from accumulated segments (Anthropic `pause_turn`) don't collide, while replaced segments (OpenAI background `retrieve`) keep reusing the same index space. `get()` returns the live merged snapshot at any point; `usage` sums/replaces in lockstep with the merge so the graph accounts for it exactly once. r!rUzModelSettings | Nonemodel_settingszlist[ModelMessage] base_messageszRunContext[Any] | None run_contextintmax_generation_continuationsz"Callable[[float], Awaitable[None]] sleep_funczCallable[[RequestUsage], None] check_usagezCallable[[ModelResponse], None]finalize_responseNModelResponse | Noneinitial_suspended_responsemax_background_pollsz)Callable[[], AbstractContextManager[Any]]segment_contextF)defaultinit_merged_responsezStreamedResponse | None _current_subr6_stopped _detachedz5AsyncGenerator[ModelResponseStreamEvent, None] | None_segment_iteratorcURc5UR5UlURUR5UlUR$)aStream every segment as one continuous event stream. This intentionally bypasses the base `StreamedResponse.__aiter__`'s `iterator_with_final_event` / `iterator_with_part_end` wrappers: each sub-stream is already wrapped by them, so it emits fully-formed `PartStart`/`PartDelta`/`PartEnd` and `FinalResultEvent`s. The composite only applies reindexing + final-result capture (inside `_get_event_iterator`) and the cancel-guard (reproducing the base `_finished`/`_cancelled` transitions) on top. One minor semantic gap: `PartEndEvent.next_part_kind` is `None` at each sub-stream boundary (a segment can't see the next segment's first part), whereas a single-segment stream would populate it. This is acceptable because parts never merge across segment boundaries. )_event_iterator_get_event_iteratorrk_iterator_with_cancel_guardselfs r: __aiter__'_ContinuationStreamedResponse.__aiter__sF    '%)%=%=%?D "#'#C#CDDZDZ#[D ###r<c|>[TU]5nURb/UQURR5Q7nU$)uECancel-teardown errors to suppress, extended with the in-flight sub-stream's own. The cancel-guard tears the current segment down via its `close_stream()`, so the transport error it raises is whatever that sub's transport produces — httpx for most providers, but botocore (Bedrock) or grpc (xAI) for others, which each report their own types via an override. Consult the in-flight sub (`_current_sub` is still set at exception time) on top of the httpx default, so a non-httpx teardown error is suppressed into a clean `'interrupted'` stop rather than escaping to the consumer. )superget_stream_cancel_errorsrh)rqerrors __class__s r:rv6_ContinuationStreamedResponse.get_stream_cancel_errors,sA13    (MvM 1 1 J J LMF r<c# UShvN nURc[R"5UlU7v M7N2 UR(dSUlgg!UR 5a UR (degf=f7f)NT)_first_chunk_monotonictime perf_counter _cancelled _finishedrv cancelled)rqiteratorevents r:ro9_ContinuationStreamedResponse._iterator_with_cancel_guard;s| &' e..6372C2C2ED/  x??!%# ,,. >>" sBBA?=?/A?AB&BBBBcURnUS:Xa5US- nX@R:a[SU<SURS35eX44$US- nX0R:a[SU<SURS35eX44$)uCount a suspended re-issue against its ceiling (same-id poll vs everything else), raising if exceeded. Only a `'replace-same-id'` re-suspension — a passive re-poll of one long-running background job — gets the generous `max_background_polls` ceiling. A model-change or `FallbackModel`-directed replace is *fresh* generation, not the same job, so it counts against the strict `max_generation_continuations` cap alongside accumulate re-suspensions — otherwise a chain of fresh suspensions is the exact runaway the strict cap guards against. The first re-issue has no prior merge to classify (`last_mode is None`) so it counts as strict, harmless since both ceilings allow at least one. See `MAX_BACKGROUND_POLLS`. Returns the updated `(accumulate_count, replace_count)`. r-r zModel response for job z1 remained suspended after polling the maximum of z timeszModel response z( was suspended more than the maximum of )rCrcrr])rqr8 last_modeaccumulate_count replace_countjob_ids r:_count_continuation1_ContinuationStreamedResponse._count_continuationRs.. ) ) Q M888--fZ7h00199 ..  ! "C"CC-%fZ/W889A ..r<c# SnSnSnURnSnUR(dUR(aGO_Uc URnOURS:XaUR XCX5upUR RU5=n(a<URU5IShvN UR(dUR(aO/URQUPnOOX@l SnUR5 UR RX`RURUR5IShvN n XlU ShvN n [!U ["5(a XlU 7v M+UcUR'XIU5nUR)X57v MVX@l URb*UR-URR+55 ggGN4NN SSS5IShvN O!,IShvN (df  O=fSSS5 O!,(df  O=fU=(d SnW R+5n Uc$U RS:XaUR-U 5 U n O8UR-U5 UR-U 5 [/XK5n[1XK5n Xl SUlU R2UlUR7U R25 U nGM![8a e[:aV UbQURS:XaAUR(d0UR(d[=UR U5IShvN ef=f!URb*UR-URR+55 ff=f7f)Nr suspended)rbr~rirZstaterrUcontinuation_delayr^rgrdrequest_streamrYmodel_request_parametersr[rh isinstancerfinal_result_event_segment_offset_reindexr4r`r'r(rH_usager_ GeneratorExit BaseExceptionr&) rqrrrr8last_segment_offsetmessagesdelaysegment_offsetsubr sub_responserLs r:rn1_ContinuationStreamedResponse._get_event_iteratorps" '+ 22 V @??dmm##11H^^{26:6N6N -=73$!% = =h GGuG"ooe444 ??dmm!>!3!3>X>H )1%.2))+#zz88 "5"5t7T7TVZVfVf  ,/)+.G%)%1ABB:? 7&+ (-5151E1EhUh1i"&--"FF6%- !"  ,&&t'8'8'<'<'>?-S5$ G3       ,++'5&9# #wwy ##))[8..|<)F**84**<8!+8 BI,XDF(.%$(!$ll   .!CH    #+(Etbfbobo*4::x@@@    ,&&t'8'8'<'<'>?-sN BK!'G(AK!9AH9G:H= G5G" G G"AG5K!#8N K!H G""G5# H.G1/H5H ;G>< H H K! H&"B?K!!A"M MM  M9NN cUcg[XR55nUS:Xa[UR5$US:XagU$)u5Index at which the current segment's parts begin in the stitched stream. Shares [`merge_mode`][pydantic_ai.models._continuation.merge_mode]'s decision so reindexing matches the eventual merge: - `'accumulate'` appends after all prior parts (offset = number of prior parts). - `'replace-same-id'` (a background job re-polled under the same `provider_response_id`) re-emits the *same* parts in the *same* index space, so it reuses the replaced segment's offset. - `'replace-new'` (a model change, or a `FallbackModel` `replace_previous_response` directive) supersedes the whole prior response — `merge_responses` keeps only the new parts, indexed from 0 — so its events must start at offset 0 too, or the live event indices would drift past the final response's (e.g. after one or more accumulated segments). rr/r.)r'r4lenrI)r8rrrKs r:r-_ContinuationStreamedResponse._segment_offsetsE  (GGI. < x~~& & = ""r<cU(a6[U[[[45(a[ XR U-S9$U$)N)index)rrrrr r)rqroffsets r:r&_ContinuationStreamedResponse._reindexs1 j(VWW5 f(<= = r<c|URnUR=nb UR5nUcU$[X5$U$)z@The merged response so far, folding in any in-flight sub-stream.)rgrhr4r()rqrLrrs r: _snapshot'_ContinuationStreamedResponse._snapshotsB&&$$ $C 1779L#)>< \v7\ \ r<cXUR5nUb UR$UR$)uLive usage across all segments so far, including the in-flight sub-stream. The composite's `_usage` is only refreshed when a segment completes, so — unlike a plain segment, whose model updates `_usage` live during iteration — reading it mid segment would omit the in-flight sub's usage. Fold in the current sub's live snapshot so consumers (e.g. `AgentStream.usage`) see the running total at any point. )rrHr)rqsnapshots r:rH#_ContinuationStreamedResponse.usages(>>#!)!5x~~F4;;Fr<cUR5nUR(aSnO=UR(aSnO)UR(aUbURS:XaSnOSnUc[ /UR US9$[XS9$)udBuild the live merged [`ModelResponse`][pydantic_ai.messages.ModelResponse] across all segments so far. The composite normally resolves the whole `suspended → … → complete` chain, so mid-run it's `'complete'` once the loop exits, `'interrupted'` if cancelled, and `'incomplete'` while a segment is still in flight. The one case it *does* surface `'suspended'` is a **detach**: the consumer stopped iterating and the stream was torn down via `aclose()` — not `cancel()` — while the current/last segment is itself a still-pending suspended job. The server-side job survives (detach doesn't cancel it), so recording `'suspended'` makes the run resumable later, matching the non-streaming path where a persisted suspended response can be resumed. A real `cancel()` (`_cancelled`) also cancels the server-side job, so it stays `'interrupted'` and non-resumable. complete interruptedr incomplete)rIrDr)r)rrr~rjrrrDr )rqrrs r:r4!_ContinuationStreamedResponse.get so>># >>E __!E ^^ 4;9VE E   rdooUS Sx--r<c># SUlURb"URR5IShvN [URUR 55IShvN gN1N![URUR 55IShvN f=f7f)zOStop the continuation loop and cancel any server-side suspended/background job.TN)rirh close_streamr&rUr4rps r:r*_ContinuationStreamedResponse.close_stream+sv  ?  ,''44666 'tzz488:> > > 7 ?&tzz488:> > >sIB*A+A'A+'B!A)"B'A+)B+(BBBBc# SUlURb$URR5IShvN ggN![a&n[R "U5(deSnAgSnAff=f7f)uTear down the in-flight sub-stream (its HTTP connection) without cancelling any job. Each segment's `model.request_stream(...)` context manager lives inside the stitching async generator, so — unlike an ordinary `StreamedResponse` whose connection the agent graph closed via `async with request_stream(...)` — an early break from a consumer doesn't reliably propagate `aclose()` to it. Closing the generator here runs that context manager's teardown (mirroring the pre-stitching behavior), and is safe to call once the consumer has stopped iterating (including after a normal, fully-drained stream, where it's a no-op). Cancellation of a server-side job stays on the `close_stream()` path, driven by `AgentStream.cancel()`. Closes the inner segment generator directly: the outer cancel-guard's `async for … in iterator` does not forward `aclose()` to it, so closing the cancel-guard alone would leave each segment's `request_stream(...)` context manager (and its connection) open until garbage collection. TN)rjrkaclose RuntimeErrorr"is_async_generator_already_running)rqexcs r:r$_ContinuationStreamedResponse.aclose7sj*  ! ! - ,,33555 .5 @@EEF s7A1><>A1> A.A)$A1)A..A1cURbURR$URb1URR(aURR$g)N)rhrDrgrps r:rD(_ContinuationStreamedResponse.model_name\sO    ($$// /  ,1F1F1Q1Q((33 3r<cURbURR$URbURR$S$N)rh provider_namergrps r:r+_ContinuationStreamedResponse.provider_namedsC    ($$22 26:6K6K6Wt$$22a]aar<cURbURR$URbURR$S$r)rh provider_urlrgrps r:r*_ContinuationStreamedResponse.provider_urljsC    ($$11 1595J5J5Vt$$11`\``r<cURbURR$URbURR$[$r)rh timestamprg_FALLBACK_TIMESTAMPrps r:r'_ContinuationStreamedResponse.timestamppsC    ($$.. .262G2G2St$$..lYllr<) rhrjrmrr{rgrkrirr)return'AsyncIterator[ModelResponseStreamEvent])rztuple[type[BaseException], ...])rrrr) r8rrzMergeMode | Nonerr\rr\rztuple[int, int])rz.AsyncGenerator[ModelResponseStreamEvent, None])r8rarr"rr\rr\)rrrr\rr)rra)rr)rr)rNone)rstr)rz str | None)rr)%__name__ __module__ __qualname____firstlineno____doc____annotations__rbr#rcr rdr rgrhrirjrkrrrvrorrn staticmethodrrrpropertyrHr4rrrDrrr__static_attributes__ __classcell__)rxs@r:r)r)s  L((%%''"%%22//667; 4;!5#4 BMO>L-24e-L*L,1$U,KL)K5u5Hd5 E6It6PU]ahmOnLn$$ &?& 0&./%/2B/VY/jm/ /rs,# NNDD11'%0   % % ".!<!   B C  ",,Q8<<@a("/d * Fm$4Fm Fmr<