ó
    °"³j… ã            	      ó¦  • % S SK Jr  S SKrS SKrS SKrS SKrS SKJr  S SKJ	r	  S SK
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  S SKJr  S S	KJrJr  S S
KJrJrJrJrJ r J!r!  S SK"J#r#  S SK$J%r%J&r&  S SK'J(r(  S SK)J*r*J+r+J,r-J.r/J0r0  S SK1J2r2  S SK3J4r4J5r5J6r6J7r7J8r8  S SK9J:r:  S SK;J<r<J=r=  S SK>J?r?J@r@  S SKAJBrB  S SKCJDrD  S SKEJFrF  S SKGJHrHJIrI  S SKJJKrKJLrLJMrMJNrNJOrO  S SKPJQrQ  SSKRJSrSJTrTJUrUJVrVJWrWJXrXJYrZJ[r[J\r\J]r^  SSK_J`r`  SSKaJbrbJcrcJdrd  SSKeJfrfJgrg  SSKhJiriJjrjJkrkJlrl  SS KXJmrm  SS!KnJoroJprpJqrqJrrrJsrsJtrtJuru  SS"KvJwrwJxrx  SS#KyJzrz  SS$K{J|r|J}r}J~r~JrJ€r€  SS%K�J‚r‚  \(       a  SS&KƒJ„r„  SS'K…J†r†  S(r‡\%" S)5      rˆ\%" S*5      r‰\Š" S5      r‹S+rŒ\S,   r� \\Ž/\S   4   r� \" S-SS.9r�S/\‘S0'   \SxS1 j5       r’SyS2 jr“\%" S35      r”\%" S45      r•      SzS5 jr–S{S6 jr—        S|S7 jr˜S8r™S9\‘S:'          S}S; jrš      S}S< jr›\GR8                  " S=S>9 " S? S@5      5       r�\GR8                  " S=S>9 " SA SB\\”\w4   5      5       rž " SC SD\K\�\ž\”\4   \\GR>                  \Q   4   5      r     S~SE jr¡      SSF jr¢S€SG jr£\GR8                   " SH SI\ \”\Q4   5      5       r¤      S�SJ jr¥      S‚SK jr¦      SƒSL jr§    S„SM jr¨S…SN jr©        S†SO jrª          S‡SP jr«\        SˆSQ j5       r¬S‰SR jr­\GR8                   " SS ST\ \”\Q4   5      5       r®\GR8                   " SU SV\ \”\Q4   5      5       r¯\GR8                   " SW SX\ \”\Q4   5      5       r°SŠSY jr±S‹SZ 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‹Sa jr¹\GR8                   " Sb Sc5      5       rº\" Sd5      r»Se\‘Sf'   \S�Sg j5       r¼S‘Sh jr½        S’Si jr¾      S“Sj jr¿S”Sk jrÀ          S•Sl jrÁS–Sm jrÂSnrÃ S—So jrÄ      S˜Sp jrÅ    S™Sq jrÆSšSr jrÇSsSt.     S›Su jjrÈSšSv jrÉSsSt.     S›Sw jjrÊg)œé    )ÚannotationsN)ÚTask)Údeque)ÚAsyncGeneratorÚAsyncIteratorÚ	AwaitableÚCallableÚ	GeneratorÚIterableÚSequence)ÚasynccontextmanagerÚcontextmanager)Ú
ContextVar)Údeepcopy)ÚfieldÚreplace)ÚTYPE_CHECKINGÚAnyÚGenericÚLiteralÚ	TypeGuardÚcast)ÚTracer)ÚTypeVarÚassert_never)ÚHistoryProcessor)ÚDEFAULT_INSTRUMENTATION_VERSIONÚcapture_current_contextÚget_instructionsÚget_instructions_sourceÚtime_to_first_chunk_ctx)Úprocess_tool_calls)Úcancel_and_drainÚdataclasses_no_defaults_reprÚfill_run_metadataÚis_str_dictÚnow_utc)Úuuid7)ÚAbstractCapabilityÚModelSelector)ÚCompletedStreamedResponseÚModelRequestContext)ÚAbstractNativeTool)ÚToolSearchTool)ÚToolManager)Ú_discovered_tool_names_in_orderÚparse_discovered_tools)ÚBaseNodeÚEndÚGraphÚGraphBuilderÚGraphRunContext)ÚNodeRunEndTé   )
Ú_displayÚ_enqueueÚ_outputÚ_system_promptÚ_usage_attributionÚ
exceptionsÚmessagesÚmodelsÚresultÚusage)ÚRunCancellation)Ú_parse_loaded_capabilitiesÚparse_loaded_capabilitiesÚ registered_loaded_capability_ids)Úbest_effort_priceÚfill_response_cost)ÚAnchoredEvidenceÚEventStreamBufferÚdispatch_event_streamÚset_current_run_context)ÚToolRetryError)ÚMAX_BACKGROUND_POLLSÚMAX_GENERATION_CONTINUATIONSÚ	MergeModeÚ_ContinuationStreamedResponseÚcancel_suspended_jobÚ
merge_modeÚmerge_responses)ÚOutputDataTÚ
OutputSpec)ÚModelSettings)ÚAgentNativeToolÚDeferredToolResultÚDeferredToolResultsÚ
RunContextÚToolDefinition)Úcollect_toolset_instructions)ÚAgent)ÚInstrumentationSettings)ÚGraphAgentStateÚGraphAgentDepsÚUserPromptNodeÚModelRequestNodeÚCallToolsNodeÚbuild_run_contextÚcapture_run_messagesr   Úresolve_conversation_idr"   Úresolve_run_idÚTÚSÚ__pydantic_ai__)ÚearlyÚgracefulÚ
exhaustivezpydantic_ai.agent_graph_sleep)Údefaultz&ContextVar[AgentGraphSleepFunc | None]Ú_AGENT_GRAPH_SLEEPc              #  óž   #   • [         R                  U 5      n Sv •  [         R                  U5        g! [         R                  U5        f = f7f)a9  Set a custom async sleep function for agent graph delays.

By default, the agent graph uses `asyncio.sleep` when it needs to wait during
a run. Durable execution frameworks (Temporal, Prefect, DBOS, Restate, etc.)
should use this context manager to register their own durable sleep so that
delays survive workflow replays and don't waste activity time.

Example:
```python
from pydantic_ai import Agent


async def durable_sleep(seconds: float) -> None:
    ...  # e.g. `await workflow.sleep(seconds)` under Temporal

with Agent.using_sleep(durable_sleep):
    ...
```
N)rp   ÚsetÚreset)Ú
sleep_funcÚtokens     ÚU/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/_agent_graph.pyÚset_agent_graph_sleeprw   œ   s<   é € ô* ×"Ñ" :Ó.€Eð(Ûä× Ñ  Õ'øÔ× Ñ  Õ'üs   ‚A™3 �A³A
Á
Ac              ƒ  ó    #   • [         R                  5       nUb  U" U 5      I Sh  v•N   g[        R                  " U 5      I Sh  v•N   g N$ N7f)zHSleep using the registered agent graph sleep function, or asyncio.sleep.N)rp   ÚgetÚasyncioÚsleep)Údelayrt   s     rv   Ú_agent_graph_sleepr}   ¸   sA   é € ä#×'Ñ'Ó)€JØÑÙ˜Ó×Ñä�mŠm˜EÓ"×"Ñ"ñ 	 á"ùs!   ‚#A¥A
¦AÁAÁAÁAÚDepsTÚOutputTc               óÈ   #   • U(       a  UR                  S5      7v •  U(       a  M  U   Sh  v•N nU7v •  M   N
 U(       a  UR                  S5      7v •  U(       a  M  gg7f)aS  Drain buffered run events at the start and end of a node stream.

Events buffered while the node stream is live are yielded by the stream itself, as soon as they
are emitted (see `_iter_completed_or_buffered`); draining them here as well could yield them
ahead of an earlier event the stream is about to deliver, inverting emission order.
r   N)Úpop)ÚstreamÚevent_stream_bufferÚevents      rv   Ú_with_event_stream_bufferr…   Å   sU   é € ö Ø!×%Ñ% aÓ(Ó(÷ Ð
á÷ ˆeØ�ñ�væ
Ø!×%Ñ% aÓ(Ó(÷ Ò
ùs*   ‚#A"§A"©;­9®;±A"¹;»#A"Á A"c              ƒ  óf   #   • U R                  5          U I S h  v•N   g  N! [         a     g f = f7f©N)ÚcancelÚBaseException)Útasks    rv   Ú_cancel_taskr‹   ×   s-   é € à‡K�K„MðØ�
‹
øÜó ñ 	ðüs(   ‚1”! ™š! ž1Ÿ! ¡
.«1­.®1c              ƒ  ó¢   #   • [        U[        5      (       a  UR                  S:X  a  gUR                  S:X  a  [        X5      I Sh  v•N   g N7f)u  State to record for a streamed turn the consumer stopped, cancelling a leaked job when appropriate.

The composite treats every `aclose()` (which the handler teardown triggers) as a *detach*, so
`partial.state` is `'suspended'` whenever the last segment is a still-pending job â€” regardless of
*why* the consumer stopped. Only the graph knows why, from `stream_error`'s type:

- `GeneratorExit` is a walk-away detach (the consumer broke out of `run_stream`/`stream_text`). Mirror
  the non-streaming detach: keep `'suspended'` so the run is resumable, and leave the job alive.
- any other exception is a genuine downstream failure. Mirror the non-streaming cancel-on-error policy:
  force `'interrupted'` (non-resumable) and best-effort cancel the still-live job so it doesn't leak.
Ú	suspendedNÚinterrupted)Ú
isinstanceÚGeneratorExitÚstaterR   )ÚmodelÚstream_errorÚpartials      rv   Ú!_resolve_interrupted_stream_stater•   â   sD   é € ô  �,¤×.Ñ.°7·=±=ÀKÓ3OØØ‡}�}˜Ó#Ü" 5Ó2×2Ð2Øñ 	3ùs   ‚AAÁAÁAÚnewzLiteral['new']ÚNEW_CONVERSATIONc                óÄ   • U [         :X  a  [        [        5       5      $ U b  U $ U(       a%  [        U5       H  nUR                  =nc  M  Us  $    [        [        5       5      $ )u¢  Resolve the `conversation_id` to use for an agent run.

Priority:

1. `explicit == 'new'` â†’ fresh UUID7 (forks a conversation off the supplied history).
2. Explicit string â†’ used as-is.
3. Most recent non-`None` `conversation_id` on `message_history` (scanned from the end).
4. Fresh UUID7.

A fresh UUID7 is intentionally distinct from the run's `run_id`, so callers can
treat the two identifiers as independent.
)r—   Ústrr(   ÚreversedÚconversation_id)ÚexplicitÚmessage_historyÚmessageÚcids       rv   rg   rg   þ   sZ   € ð  Ô#Ó#Ü”5“7‹|ÐØÑØˆÞÜ Ö0ˆGØ×.Ñ.Ð.�Ó;Ø’
ñ 1ô Œu‹w‹<Ðó    c                óÞ   • U bX  U S:X  a  [         R                  " S5      eU(       a3  [        X5      [        U5      :  a  [         R                  " SU < S35      eU $ [	        [        5       5      $ )u’  Resolve the `run_id` to use for an agent run.

Unlike `conversation_id`, `run_id` is never inherited from `message_history`.
Each agent run â€” including a deferred-tool resume â€” gets its own id so
`new_messages()` can key off stamped `run_id` values.

Priority:

1. Explicit string â†’ used as-is (raises `UserError` if empty, or if that id already
   appears on `message_history`).
2. Fresh UUID7.
Ú zm`run_id` must be a non-empty string when provided. Empty `run_id` breaks `new_messages()` boundary detection.z`run_id=a-  ` already appears in `message_history`. Each agent run needs a distinct `run_id`; reuse breaks `new_messages()`. Use `conversation_id` to correlate across turns or deferred-tool resume. When retrying a failed run with the same `run_id`, rebuild `message_history` without the failed attempt's messages.)r>   Ú	UserErrorÚ_first_run_id_indexÚlenr™   r(   )rœ   r�   s     rv   rh   rh     sz   € ð  ÑØ�r‹>Ü×&Ò&ðMóð ö Ô2°?ÓMÔPSÐTcÓPdÓdÜ×&Ò&Ø˜8™,ð '9ð 9óð ð ˆÜŒu‹w‹<Ðr    T)Úkw_onlyc                  ó"  • \ rS rSr% Sr\R                  " \\R                     S9r
S\S'   \R                  " \R                  S9rS\S'   SrS	\S
'   SrS	\S'   \R                  " S S9rS\S'    \R                  " S S9rS\S'    SrS\S'   SrS\S'    SrS\S'    \R                  " \\R.                     S9rS\S'    \R                  " \S9rS\S'    \R                  " \\\\\4   4   S9rS\S'    S"S jrS"S jr  S#     S$S  jjr!S!r"g)%r`   i;  z3State kept across the execution of the agent graph.©Údefault_factoryúlist[_messages.ModelMessage]r�   z_usage.RunUsagerB   r   ÚintÚoutput_retries_usedÚrun_stepc                 ó(   • [        [        5       5      $ r‡   ©r™   r(   © r    rv   Ú<lambda>ÚGraphAgentState.<lambda>C  s
   € ¼CÄÃ¼Lr    r™   Úrun_idc                 ó(   • [        [        5       5      $ r‡   r¯   r°   r    rv   r±   r²   I  s
   € ÄSÌËÄ\r    r›   Nzdict[str, Any] | NoneÚmetadataú
int | NoneÚlast_max_tokensz$models.ModelRequestParameters | NoneÚlast_model_request_parameterszlist[_enqueue.PendingMessage]Úpending_messagesú list[_messages.AgentStreamEvent]rƒ   z$dict[str, dict[str, ToolDefinition]]Úmcp_tool_defs_cachec                óN   • [         R                  " U R                  5      U l        g r‡   )r:   ÚPendingMessageQueuer¹   )Úselfs    rv   Ú__post_init__ÚGraphAgentState.__post_init__h  s   € ô !)× <Ò <¸T×=RÑ=RÓ SˆÕr    c                óÀ  • U R                   (       a’  [        U R                   S   =n[        R                  5      (       ac  UR                  S:X  aR  UR
                  (       a@  [        UR
                  S   =n[        R                  5      (       a   UR                  SS9  gggggg! [         a.    [        R                  " SU R                  =(       d    S S35      ef = f)	zRRaise `IncompleteToolCall` if the last model response was truncated mid-tool-call.éÿÿÿÿÚlengthT)Úraise_if_invalidúModel token limit (úprovider defaultzË) exceeded while generating a tool call, resulting in incomplete arguments. Increase the `max_tokens` model setting, or simplify the prompt to result in a shorter response that will fit within the limit.N)r�   r�   Ú	_messagesÚModelResponseÚfinish_reasonÚpartsÚToolCallPartÚargs_as_dictÚ	Exceptionr>   ÚIncompleteToolCallr·   )r¾   Úmodel_responseÚ	tool_calls      rv   Úcheck_incomplete_tool_callÚ*GraphAgentState.check_incomplete_tool_callm  sà   € ð × × Ü¨T×-AÑ-AÀ"Ñ-EÐE˜>Äy×G^ÑG^×_Ñ_Ø×,Ñ,°Ó8Ø×$×$Ü¨×(<Ñ(<¸RÑ(@Ð@˜9Ä)×BXÑBX×YÑYðØ×&Ñ&¸Ð&Ò=ð Zð %ð 9ð `ð !øô ó Ü ×3Ò3Ø)¨$×*>Ñ*>×*TÐBTÐ)Uð  Vað  bóð ðús   ÂB% Â%8Cc                ó¨   • U =R                   S-  sl         U R                   U:”  a-  U R                  5         SU S3n[        R                  " U5      Ueg)a‚  Record one unit of output-retry budget consumption.

Raises `UnexpectedModelBehavior` when `output_retries_used` would exceed
`max_output_retries`. Called for `ModelRetry`s from output validators (text path)
and for `ToolRetryError`s from output-tool dispatch / empty-or-non-actionable
responses; per-tool retry limits are still enforced separately by
`ToolManager._check_max_retries`.
r8   z!Exceeded maximum output retries (Ú)N)r¬   rÑ   r>   ÚUnexpectedModelBehavior)r¾   Úmax_output_retriesÚerrorrž   s       rv   Úconsume_output_retryÚ$GraphAgentState.consume_output_retry}  sX   € ð 	× Ò  AÑ%Õ Ø×#Ñ#Ð&8Ó8Ø×+Ñ+Ô-Ø9Ð:LÐ9MÈQÐOˆGÜ×4Ò4°WÓ=À5ÐHð 9r    )r¹   )ÚreturnÚNoner‡   )rÖ   r«   r×   úBaseException | NonerÚ   rÛ   )#Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__Údataclassesr   ÚlistrÇ   ÚModelMessager�   Ú__annotations__Ú_usageÚRunUsagerB   r¬   r­   r³   r›   rµ   r·   r¸   r:   ÚPendingMessager¹   rJ   rƒ   Údictr™   r\   r»   r¿   rÑ   rØ   Ú__static_attributes__r°   r    rv   r`   r`   ;  st  ‡ á=à4?×4EÒ4EÐVZÐ[d×[qÑ[qÑVrÑ4s€OÐ1ÓsØ(×.Ò.¸v¿¹ÑO€Eˆ?ÓOØ Ð˜Ó Ø€HˆcÓØ×#Ò#Ñ4HÑI€FˆCÓIðð
 '×,Ò,Ñ=QÑR€O�SÓRðð '+€HÐ#Ó*Ø"&€O�ZÓ&ØVØJNÐ!Ð#GÓNØPØ6A×6GÒ6GÐX\Ð]e×]tÑ]tÑXuÑ6vÐÐ3ÓvðNà<G×<MÒ<MÐ^oÑ<pÐÐ9ÓpðKð
 AL×@QÒ@QØ˜S $ s¨NÐ':Ñ";Ð;Ñ<ñAÐÐ=ó ð4ôTô
ð& '+ðIàðIð $ðIð 
÷	Ið Ir    r`   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'   S\S'   S\S'   S\S'   S\S '   S!\S"'   S#\S$'   S%\S&'   S'\S('   S)\S*'   S)\S+'   \R                  " S,S-9rS.\S/'   S0\S1'   S2\S3'   S4\S5'   S6\S7'    S8r	S9\S:'   \R                  " \
S,S;9rS<\S='    \R                  " \\\\R                      4   S,S;9rS>\S?'    \R                  " \\\R&                  4   S,S;9rS@\SA'    \R                  " \\\\4   \SB\\   4   4   S,S;9rSC\SD'    \R                  " \\\\   4   S,S;9rS'\SE'    S8rSF\SG'   SHrg8)Ira   i‘  z.Dependencies/config passed to the agent graph.r~   Ú	user_depsú,str | Sequence[_messages.UserContent] | NoneÚpromptr«   Únew_message_indexú_messages.ModelRequest | NoneÚresumed_requestr¶   Úresumed_request_indexúmodels.Modelr’   zModelSelector[DepsT] | NoneÚmodel_selectorÚmodel_selected_for_stepzqCallable[[ModelSelector[DepsT], models.ModelSelectionContext[DepsT]], Awaitable[tuple[models.Model, str | None]]]Úevaluate_model_selectorz)Callable[[models.Model], Awaitable[None]]Úenter_modelz3Callable[[RunContext[DepsT]], ModelSettings | None]Úget_model_settingsz_usage.UsageLimitsÚusage_limitsrÖ   ÚEndStrategyÚend_strategyzPCallable[[RunContext[DepsT]], Awaitable[list[_messages.InstructionPart] | None]]r   z!_output.OutputSchema[OutputDataT]Úoutput_schemaz1list[_output.OutputValidator[DepsT, OutputDataT]]Úoutput_validatorsú(Any | Callable[[RunContext[DepsT]], Any]Úvalidation_contextzAbstractCapability[DepsT]Úroot_capabilityz$dict[str, AbstractCapability[DepsT]]Úcapabilitiesúset[str]Úloaded_capability_idsÚdiscovered_tool_namesF)Úreprzlist[AgentNativeTool[DepsT]]Únative_toolszToolManager[DepsT]Útool_managerr   ÚtracerzInstrumentationSettings | NoneÚinstrumentation_settingsz_display.BannerDisplayÚdisplay_bannerNzAgent[DepsT, Any] | NoneÚagent)r©   r  rC   Úcancellationzdict[int, list[asyncio.Event]]Úpending_immediate_dispatchesz%dict[int, _messages.AgentStreamEvent]Úevent_stream_replacements.z4dict[tuple[str, str], Callable[..., Awaitable[Any]]]Údurable_operationsÚrun_capabilities_by_idú
str | NoneÚmodel_idr°   )rÝ   rÞ   rß   rà   rá   rå   râ   r   r  r  rC   r  ré   r«   rã   rz   ÚEventr  rÇ   ÚAgentStreamEventr  Útupler™   r	   r   r   r  r)   r  r  rê   r°   r    rv   ra   ra   ‘  sé  ‡ á8àÓà8Ó8ØÓØ2Ó2Ø%Ó%àÓØ/Ó/Ø'Ó'ðó ð ;Ó:ØKÓKØ$Ó$ØÓØÓØfÓfà4Ó4ØHÓHØ@Ó@à.Ó.à6Ó6ð $Ó#Ø#Ó#à1<×1BÒ1BÈÑ1N€LÐ.ÓNØ$Ó$àƒNØ<Ó<à*Ó*Øaà&*€EÐ#Ó*à$/×$5Ò$5ÀoÐ\aÑ$b€L�/ÓbØcàCN×CTÒCTØ˜S $ w§}¡}Ñ"5Ð5Ñ6¸UñDÐ Ð"@ó ðSð HS×GXÒGXØ˜S )×"<Ñ"<Ð<Ñ=ÀEñHÐÐDó ðð
 P[×O`ÒO`Ø˜U 3¨ 8™_¨h°s¸IÀc¹NÐ7JÑ.KÐKÑLÐSXñPÐÐLó ðð DO×CTÒCTØ˜SÐ"4°SÑ"9Ð9Ñ:ÀñDÐÐ@ó ðð
  €HˆjÓòr    ra   c                  ó   • \ rS rSrSrSrg)Ú	AgentNodei÷  z‰The base class for all agent nodes.

Using subclass of `BaseNode` for all nodes reduces the amount of boilerplate of generics everywhere
r°   N)rÝ   rÞ   rß   rà   rá   rê   r°   r    rv   r  r  ÷  s   † ôr    r  c                ó"   • [        U [        5      $ )zöCheck if the provided node is an instance of `AgentNode`.

Usage:

    if is_agent_node(node):
        # `node` is an AgentNode
        ...

This method preserves the generic parameters on the narrowed type, unlike `isinstance(node, AgentNode)`.
)r�   r  )Únodes    rv   Úis_agent_noder  þ  s   € ô �dœIÓ&Ð&r    c              ƒ  ó   #   • [        U [        5      (       a9  U R                  (       a  gU R                  U5       ISh  v•N nU  Sh  v•N nM  [        U [        5      (       a5  U R
                  b  gU R                  U5       ISh  v•N nU  Sh  v•N nM  g N\ NS
 SSS5      ISh  v•N    g! , ISh  v•N  (       d  f       g= f NC N:
 SSS5      ISh  v•N    g! , ISh  v•N  (       d  f       g= f7f)a€  Run the node's event stream to completion, so capabilities wrapping it see its events.

`ModelRequestNode` and `CallToolsNode` are the nodes that emit events; the rest never do.
Both record that their stream was opened, so a caller that streamed the node itself under
[`agent.iter()`][pydantic_ai.agent.Agent.iter] doesn't get it streamed a second time when
the run is then advanced.
N)r�   rc   Ú_did_streamr‚   rd   Ú_wrapped_events_iterator)r  ÚctxÚmodel_streamÚ_eventÚtool_streams        rv   Údrain_node_event_streamr"    s¿   é € ô �$Ô(×)Ñ)Ø××ØØ—;‘;˜s×#Ô# |Ù ,÷ �fÙÜ	�Dœ-×	(Ñ	(Ø×(Ñ(Ñ4ØØ—;‘;˜s×#Ô# {Ù +÷ �fÙð 
)ñ $ñ ÷ $×#×#×#×#Ð#úñ $ñ ÷ $×#×#×#×#Ð#üsÐ   ‚=C>¿BÁ C>ÁB3ÁB Á
BÁB ÁB3Á8C>Â	CÂ
C>ÂC$ÂCÂCÂCÂC$ÂC>ÂB Â B3Â!C>Â,B/Â-C>Â3C
Â9B<Â:C
ÃC>ÃCÃC$ÃC>ÃC ÃC>Ã$C;Ã*C-Ã+C;Ã7C>c                ó¼   • [        U 5      R                  [        R                  R                  L a,  [        R
                  " [        U 5      R                   S35      eg )Na^   does not support streamed requests. This step needs to stream either because the run itself is streamed (`agent.run_stream()`, `agent.run_stream_events()`), or because a capability registers a `wrap_run_event_stream` hook and so needs events to observe. Implement `request_stream()` on the model, or use a non-streamed run without such a capability.)ÚtypeÚrequest_streamr@   ÚModelr>   r£   rÝ   )r’   s    rv   Ú _ensure_model_supports_streamingr'  '  sS   € ÜˆEƒ{×!Ñ!¤V§\¡\×%@Ñ%@Ò@Ü×"Ò"Ü�E‹{×#Ñ#Ð$ð %nð nó
ð 	
ð Ar    c                  ó¦  • \ rS rSr% SrS\S'   S\S'   SrS\S	'   SrS
\S'   \R                  " \
\R                  \      S9rS\S'   \R                  " \S9rS\S'   \R                  " \
\R                  \      S9rS\S'   \R                  " \\\R                  \   4   S9rS\S'       SS jr        SS jr      SS jrSS jr\rSrg)rb   i1  z7The node that handles the user prompt and instructions.rí   Úuser_promptúdataclasses.KW_ONLYÚ_NzDeferredToolResults | NoneÚdeferred_tool_resultsr  Úinstructionsr¨   z.list[_system_prompt.SystemPromptRunner[DepsT]]Úinstructions_functionsztuple[str, ...]Úsystem_promptsÚsystem_prompt_functionsz3dict[str, _system_prompt.SystemPromptRunner[DepsT]]Úsystem_prompt_dynamic_functionsc              ƒ  óÒ
  #   •  [        5       nUR                  (       a  / nOUR                  nSUl         [	        UR
                  R                  5      US S & X1R
                  l        [        U5      UR                  l	        U R                  b$  U R                  U R                  X15      I S h  v•N $ U(       aA  [        US   =n[        R                  5      (       a  UR
                  S:X  a  [        USS9US S & S nSnS nU(       GaJ  US   =n(       Ga=  [        U[        R                  5      (       GaF  U R                   Gc8  UR#                  5         [        R                  " UR$                  UR&                  UR(                  UR*                  S9nSnUR$                   Vs/ s H&  n[        U[        R,                  5      (       d  M$  UPM(     n	nU	(       a¡  [        U	5      S:X  a   U	S   R.                  UR                  l        GOK/ n
U	 HZ  n[        UR.                  [2        5      (       a  U
R5                  UR.                  5        M?  U
R7                  UR.                  5        M\     X¡R                  l        GO×[        U[        R8                  5      (       Ga·  UR
                  S	:X  a7  U R                   c*  [:        [<        [>        4   " [        R                  " / S
9US9$ U R                   cø  [A        [C        U5      UR
                  RD                  S-   UR
                  RF                  UR                  RH                  RJ                  S9nUR                  RH                  RM                  U5      I S h  v•N UR                  l$        URN                  (       a  [P        [<        [>        4   " U5      $ [S        X5      I S h  v•N nU(       d  [P        [<        [>        4   " U5      $ OkUR
                  S	:X  a  [T        RV                  " S5      eURN                  (       a4  UR
                  S:X  a  [        USS9US S & O[T        RV                  " S5      eU(       d  [C        U5      nU(       a  U RY                  X75      I S h  v•N   U(       a  U RY                  U/U5      I S h  v•N   O�/ nU(       d(  UR7                  U R[                  U5      I S h  v•N 5        U R                   b/  UR5                  [        R,                  " U R                   5      5        [        R                  " US
9n[:        [<        [>        4   " XVS9$ ! [         a    / n GNf = f GN¥s  snf  GNå GNœ Nà NÀ N”7f)NTrÂ   rŽ   ©Úrepair_last_responseF)rÊ   r³   r›   rµ   r8   r   r�   ©rÊ   )ÚrequestÚ_resume_suspended)r­   ÚretryÚmax_retriesz£Cannot provide a new user prompt when the message history ends in a suspended response. Resume it by running the agent with this message history and no new prompt.zZCannot provide a new user prompt when the message history contains unprocessed tool calls.)r6  Úis_resuming_without_prompt).Úget_captured_run_messagesÚusedr?   ÚLookupErrorÚ_clean_message_historyr‘   r�   r¥   Údepsrï   r,  Ú_handle_deferred_tool_resultsr�   rÇ   ÚModelRequestÚ_repair_dangling_tool_callsr)  r�   rÊ   r³   r›   rµ   ÚUserPromptPartÚcontentrî   r™   ÚappendÚextendrÈ   rc   r~   r7   r   re   r­   r¬   r  Údefault_max_retriesÚfor_run_stepÚ
tool_callsrd   Ú_get_instructionsr>   r£   Ú_reevaluate_dynamic_promptsÚ
_sys_parts)r¾   r  Úctx_messagesr?   Úlast_messageÚnext_messager:  Úrun_contextÚpartÚuser_prompt_partsÚcombined_contentÚinstruction_partsrÊ   s                rv   ÚrunÚUserPromptNode.runH  s€  é € ð		)Ü4Ó6ˆLð × × Ø‘à'×0Ñ0�Ø$(�Õ!ô -¨S¯Y©Y×-FÑ-FÓGˆ‘ˆà$,�	‰	Ô!Ü%(¨£]ˆ�‰Ô"à×%Ñ%Ñ1Ø×;Ñ;¸D×<VÑ<VÐX`Óf×fÐfö Ü¨8°B©<Ð7˜<¼×9OÑ9O×PÑPØ×"Ñ" mÓ3ô 6°hÐUYÑZˆH‘QˆKà6:ˆØ%*Ð"à04ˆç¨°"©Ð5˜Ö5Ü˜,¬	×(>Ñ(>×?Ò?ÀD×DTÑDTÒD\à—‘”Ü(×5Ò5Ø&×,Ñ,Ø'×.Ñ.Ø$0×$@Ñ$@Ø)×2Ñ2ñ	 �ð .2Ð*ð 7C×6HÒ6HÓ$wÒ6H¨dÌJÐW[Ô]f×]uÑ]u×Lv§TÑ6HÐ!Ð$wÞ$ÜÐ,Ó-°Ó2Ø*;¸AÑ*>×*FÑ*F˜Ÿ™žàHJÐ(Û$5˜DÜ)¨$¯,©,¼×<Ñ<Ø 0× 7Ñ 7¸¿¹Ö Eà 0× 7Ñ 7¸¿¹Ö Eñ	 %6ð
 +;Ÿ™œùÜ˜L¬)×*AÑ*A×BÒBØ×%Ñ%¨Ó4¸×9IÑ9IÑ9Qô ,¬E´;Ð,>Ò?Ü )× 6Ò 6¸RÑ @ÐT`ñð ð ×#Ñ#Ñ+ä")Ü)¨#Ó.Ø!$§¡×!3Ñ!3°aÑ!7Ø!Ÿi™i×;Ñ;Ø$'§H¡H×$9Ñ$9×$MÑ$Mñ	#�Kð 36·(±(×2GÑ2G×2TÑ2TÐU`Ó2a×,a�C—H‘HÔ)Ø#×.×.ô  -¬U´KÐ-?Ò@ÀÓNÐNÜ.?ÀÓ.Q×(QÐ%Þ,ä,¬U´KÐ-?Ò@ÀÓNÐNð -ð "×'Ñ'¨;Ó6ô %×.Ò.ðfóð ð "×,×,Ø#×)Ñ)¨]Ó:ô 'BÀ(ÐaeÑ&f˜¡™ä(×2Ò2Øxóð ö Ü+¨CÓ0ˆKæØ×2Ñ2°8ÓI×IÐIæØ×2Ñ2°L°>À;ÓO×OÑOà68ˆEÞØ—‘ 4§?¡?°;Ó#?×?Ô@à×ÑÑ+Ø—‘œY×5Ò5°d×6FÑ6FÓGÔHä$×1Ò1¸Ñ>ˆLä¤¤{Ð 2Ò3Ø ñ
ð 	
øôA ó 	8Ø57‹Hð	8úò  gùò@ %xòB -bò )Rñ6 Jñ Pñ @ùs¥   ‚U'„
U  ŽB U'Â.UÂ/C4U'Æ##UÇ
UÇF&U'Í6UÍ7AU'ÏUÏB=U'Ò U!Ò!U'Ò"U#Ò#-U'ÓU%ÓA/U'Õ UÕU'ÕUÕU'ÕU'ÕU'Õ!U'Õ#U'Õ%U'c              ƒ  óR  #   • U(       d  [         R                  " S5      eS nS n[        U5       HI  n[        U[        R
                  5      (       a  UnM&  [        U[        R                  5      (       d  MG  Un  O   U(       d  [         R                  " S5      eUR                  (       d  [         R                  " S5      e0 nUR                  UR                  5       5        U(       aˆ  UR                   Hx  n[        U[        R                  [        R                  -  5      (       d  M5  UR                  U;   a%  [         R                  " SUR                  < S35      eSXxR                  '   Mz     [        [        [         4   " UUUR"                  =(       d    S U R$                  S9$ 7f)NzBTool call results were provided, but the message history is empty.z\Tool call results were provided, but the message history does not contain a `ModelResponse`.zeTool call results were provided, but the message history does not contain any unprocessed tool calls.z
Tool call z: was already executed and its result cannot be overridden.Úskip)Útool_call_resultsÚtool_call_metadatar)  )r>   r£   rš   r�   rÇ   rA  rÈ   rI  ÚupdateÚto_tool_call_resultsrÊ   ÚToolReturnPartÚRetryPromptPartÚtool_call_idrd   r~   r7   rµ   r)  )	r¾   r,  r?   r  Úlast_model_requestÚlast_model_responserž   rY  rQ  s	            rv   r@  Ú,UserPromptNode._handle_deferred_tool_resultsÑ  sy  é € ö Ü×&Ò&Ð'kÓlÐlà<@ÐØ>BÐÜ Ö)ˆGÜ˜'¤9×#9Ñ#9×:Ñ:Ø%,Ò"Ü˜G¤Y×%<Ñ%<×=Ó=Ø&-Ð#Ùñ *ö #Ü×&Ò&Ønóð ð #×-×-Ü×&Ò&Øwóð ð NPÐØ× Ñ Ð!6×!KÑ!KÓ!MÔNæØ*×0Ô0�Ü˜d¤I×$<Ñ$<¼y×?XÑ?XÑ$X×YÓYØ×(Ñ(Ð,=Ó=Ü(×2Ò2Ø(¨×):Ñ):Ñ(=Ð=wÐxóð ð <BÐ%×&7Ñ&7Ó8ñ 1ô œU¤KÐ/Ò0ØØ/Ø4×=Ñ=×EÀØ×(Ñ(ñ	
ð 	
ùs   ‚A0F'Á6B/F'Ä)A>F'c              ƒ  ó@  #   • U R                   (       Ga  U Hÿ  n[        U[        R                  5      (       d  M$  / nUR                   H±  n[        U[        R
                  5      (       a~  UR                  (       am  U R                   R                  UR                  5      =n(       aA  UR                  U5      I Sh  v•N n[        R
                  " U=(       d    SUR                  S9nUR                  U5        M³     XCR                  :w  d  Mø  XCl        GM     gg N_7f)zvReevaluate any `SystemPromptPart` with dynamic_ref in the provided messages by running the associated runner function.Nr¢   )Údynamic_ref)
r1  r�   rÇ   rA  rÊ   ÚSystemPromptPartrd  ry   rU  rE  )r¾   r?   rP  ÚmsgÚreevaluated_message_partsrQ  ÚrunnerÚupdated_part_contents           rv   rK  Ú*UserPromptNode._reevaluate_dynamic_prompts   sé   é € ð
 ×/×/Ð/Û�Ü˜c¤9×#9Ñ#9×:Ó:ØRTÐ-Ø #§	¤	˜Ü% d¬I×,FÑ,F×GÑGÈD×L\×L\à)-×)MÑ)M×)QÑ)QØ $× 0Ñ 0ó*ð  ˜võ  ð >D¿Z¹ZÈÓ=T×7TÐ 4Ü'0×'AÒ'AØ$8×$>¸BÈD×L\ÑL\ñ(" ð 2×8Ñ8¸Ö>ñ !*ð 1·I±IÕ=Ø$=Ÿ	ò'  ð 0ñ 8Uùs   ‚5D»BDÂ<DÂ=ADÄDc              ƒ  óv   #   • [         R                  " U R                  U R                  U5      I Sh  v•N $  N7f)z>Build the initial system-prompt messages for the conversation.N)r<   Úresolve_system_promptsr/  r0  )r¾   rP  s     rv   rL  ÚUserPromptNode._sys_parts  s5   é € ä#×:Ò:Ø×Ñ ×!=Ñ!=¸{ó
÷ 
ð 	
ñ 
ùs   ‚09²7³9r°   )r  úDGraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, NodeRunEndT]]rÚ   zHModelRequestNode[DepsT, NodeRunEndT] | CallToolsNode[DepsT, NodeRunEndT])r,  rZ   r?   rª   r  rn  rÚ   z!CallToolsNode[DepsT, NodeRunEndT])r?   rª   rP  úRunContext[DepsT]rÚ   rÛ   )rP  ro  rÚ   z list[_messages.SystemPromptPart])rÝ   rÞ   rß   rà   rá   rå   r,  r-  râ   r   rã   r<   ÚSystemPromptRunnerr~   r.  r  r/  r0  ré   r™   r1  rU  r@  rK  rL  r$   Ú__repr__rê   r°   r    rv   rb   rb   1  s=  ‡ áAà=Ó=àÓà8<ÐÐ5Ó<à#€L�*Ó#ØMX×M^ÒM^Ø˜^×>Ñ>¸uÑEÑFñNÐÐJó ð '2×&7Ò&7ÈÑ&N€N�OÓNØNY×N_ÒN_Ø˜^×>Ñ>¸uÑEÑFñOÐÐKó ð \g×[lÒ[lØ˜S .×"CÑ"CÀEÑ"JÐJÑKñ\Ð#Ð%Xó ðG
ØWðG
à	QôG
ðR-
à2ð-
ð /ð-
ð Rð	-
ð
 
+ô-
ð^>Ø4ð>ØCTð>à	ô>ô6
ð ,ƒHr    rb   c              ƒ  ó$  #   • / nU R                   R                  U5      I Sh  v•N nU(       a  UR                  U5        UR                  [        U R                   R                  R
                  U5      I Sh  v•N 5        U=(       d    S$  Nh N7f)zÈCombine base instructions (from agent/capabilities) with toolset instructions.

Toolset instructions are fetched from the current tool manager's toolset,
which reflects any changes from for_run_step.
N)r?  r   rF  r]   r  Útoolset)r  rP  rÊ   Úbases       rv   rJ  rJ  $  so   é € ð .0€Eà—‘×*Ñ*¨;Ó7×7€DÞØ�‰�TÔà	‡L�LÔ3°C·H±H×4IÑ4I×4QÑ4QÐS^Ó_×_Ô`à�=�DÐñ 8ñ `ùs"   ‚!B£B¤ABÁ8BÁ9BÂBc                óT   • Ub%  [         R                  R                  U5      U l        gg)uã  Render the instruction parts being sent onto the request that records them.

`ModelRequestParameters.instruction_parts` is what the model reads, so a `before_model_request`
hook that rewrites the parts would otherwise leave message history and OTel reporting
instructions the model never received.

`None` means "unset" rather than "no instructions" â€” it's what makes `Model._get_instruction_parts`
fall back to the request's own `instructions` â€” so it leaves the request alone.
N)rÇ   ÚInstructionPartÚjoinr-  )r6  rT  s     rv   Ú_apply_instruction_partsrx  8  s)   € ð Ñ$Ü(×8Ñ8×=Ñ=Ð>OÓPˆÕð %r    c              ƒ  ó¤  #   • U R                   R                  n[        U[        R                  5      (       a  UR
                  OSn/ n/ nU R                   R                  R                   H7  nUR                  S:X  a  UR                  U5        M&  UR                  U5        M9     [        U 5      n[        U R                   R                  5      n/ n	U(       at  U Hn  n
[        U
[        5      (       a  U	R                  U
5        M+  U
" U5      n[        R                  " U5      (       a
  UI Sh  v•N nUc  M]  U	R                  U5        Mp     [!        S U 5       5      nU(       d:  U	 Vs/ s H-  n[        U["        5      (       a  UR$                  (       a  M+  UPM/     n	nUR&                  R)                  5        VVs1 s H  u  pÞUR*                  SL d  M  UiM     nnn[,        R.                  " UU	U[1        UR2                  UUUR4                  S9UR6                  UUR8                  UUR:                  UR<                  US9$  GNs  snf s  snnf 7f)z&Build tools and create an agent model.NÚoutputc              3  óZ   #   • U  H!  oR                   [        R                  :H  v •  M#     g 7fr‡   )Úwith_nativer.   Úkind)Ú.0Úts     rv   Ú	<genexpr>Ú._prepare_request_parameters.<locals>.<genexpr>w  s   é € Ð ^Ê~È!§¡´.×2EÑ2EÖ!EÊ~ùs   ‚)+T©Údeferred_capability_idsr  )Úfunction_toolsr  rƒ  Úrevealed_tool_namesÚoutput_modeÚoutput_toolsÚoutput_objectÚprompted_output_templateÚallow_text_outputÚallow_image_outputrT  )r?  rü   r�   r;   ÚStructuredTextOutputSchemaÚtemplater  Ú	tool_defsr}  rE  re   rã   r  r-   ÚinspectÚisawaitableÚanyr.   Úoptionalr  ÚitemsÚdefer_loadingr@   ÚModelRequestParametersÚ_revealed_tool_namesr  r  ÚmodeÚ
object_defÚallows_textÚallows_image)r  rT  rü   r‰  r„  r‡  Útool_defrP  Úraw_native_toolsr  Útoolr  Úhas_tool_search_corpusÚcapability_idÚ
capabilityrƒ  s                   rv   Ú_prepare_request_parametersr¡  H  s  é € ð
 —H‘H×*Ñ*€Mô #-¨]¼G×<^Ñ<^×"_Ñ"_ˆ×ÒÐeið ð ,.€NØ)+€LØ—H‘H×)Ñ)×3Ô3ˆØ�=‰=˜HÓ$Ø×Ñ Ö)à×!Ñ! (Ö+ñ	 4ô $ CÓ(€Kä59¸#¿(¹(×:OÑ:OÓ5PÐð .0€LÞÛ$ˆDÜ˜$Ô 2×3Ñ3Ø×#Ñ# DÖ)á˜Ó%�Ü×&Ò& q×)Ñ)ØŸ�AØ“=Ø ×'Ñ'¨Ö*ñ %ô" !Ñ ^É~Ó ^Ó^ÐÞ!ñ
 $0Óf¢<˜a¼
À1Än×8UÑ8UÐZ[×ZdÕZdŸ¡<ˆÐfð *5×)AÑ)A×)GÑ)GÔ)Iôâ)IÑ%ˆMØ×#Ñ# tÐ+÷ 	Ù)Ið ñ ô ×(Ò(Ø%Ø!Ø 7Ü0Ø×-Ñ-ØØ$;Ø"-×"CÑ"Cñ	
ð "×&Ñ&Ø!Ø#×.Ñ.Ø!9Ø'×3Ñ3Ø(×5Ñ5Ø+ñ!ð ò3  ùò" gùóùsC   ‚D+IÄ-IÄ.IÄ72IÅ)*IÆIÆIÆ<I
ÇI
ÇA(IÉIc                óŽ   • U (       a;  [        U S   =n[        R                  5      (       a  UR                  S:X  a  U SS U4$ U S4$ )aÃ  Split a trailing suspended `ModelResponse` off `messages` as the continuation seed.

A history ending in a `ModelResponse` with `state == 'suspended'` is the wire-truthful
encoding of a paused turn to resume: the continuation loop echoes that response back to
the provider itself, so it must not be part of the base history handed to the model.
A normal request ends in a `ModelRequest`, so the seed is `None` and the messages pass
through untouched.
rÂ   r�   N)r�   rÇ   rÈ   r‘   )r?   Úlasts     rv   Ú_split_resume_seedr¤  ¦  sL   € ö ”J x°¡|Ð3˜t´Y×5LÑ5L×MÑMÐRV×R\ÑR\Ð`kÓRkØ˜˜ˆ}˜dÐ"Ð"Ø�Tˆ>Ðr    c                óú   • U R                   (       aj  [        U R                  5      nUR                  U5        U R                   R	                  U5        UR
                  b  U R                   R                  USS9  ggg)u÷  Enforce token limits mid-turn against a provisional total during continuations.

Continuation segments accumulate usage but aren't committed to the run usage until the
final merged response is appended exactly once by `ModelRequestNode._append_response`
(so a continuation isn't double-counted, nor counted as a separate request step). To
still fail fast when a segment blows the token budget, check the limit against a
throwaway copy of the run usage plus the accumulated continuation usage. Works both in
the agent graph (where `run_context.usage` is the live run usage) and inside a durable
boundary (where it's the serialized snapshot the activity/step/task received â€” the final
workflow-side check still applies when the merged response is committed).
NF©Úwarn_if_cost_unavailable)rù   r   rB   ÚincrÚcheck_tokensÚcostÚ
check_cost)rP  Úcontinuation_usageÚprovisionals      rv   Ú_check_continuation_usager®  ¶  sp   € ð ××Ü˜{×0Ñ0Ó1ˆØ×ÑÐ+Ô,Ø× Ñ ×-Ñ-¨kÔ:Ø×"Ñ"Ñ.à×$Ñ$×/Ñ/°ÐV[Ð/Ò\ð /ð	  r    c              ƒ  óÔ   #   • UR                   nUb  Ub  UR                  c  g [        U5        [        XR                  5        g! [
         a    [        X5      I Sh  v•N    e f = f7f)zOCheck a suspended history seed before sending the continuation that resumes it.N)rù   Ú
cost_limitrH   r®  rB   r‰   rR   )r’   rP  Úseedrù   s       rv   Ú_check_resume_seed_usager²  Ë  sb   é € ð ×+Ñ+€LØ�|�|Ñ+¨|×/FÑ/FÑ/NØðÜ˜4Ô Ü! +¯z©zÕ:øÜó Ü" 5Ó/×/Ñ/Øðüs(   ‚!A(¤ A ÁA(ÁA%ÁA ÁA%Á%A(c             ƒ  ó.  #   • [        UR                  5      u  pE[        XU5      I Sh  v•N   SnSnSnUn	[        U5          U	c  Un
OÉU	R                  S:X  a®  U	R
                  nUS:X  a  US-  nU[        :„  nSU< S[         S3nOUS-  nU[        :„  nS	U< S
[         S3nU(       a)  [        X	5      I Sh  v•N   [        R                  " U5      eU R                  U	5      =n(       a   [        U5      I Sh  v•N   / UQU	Pn
OU	sSSS5        $  U R                  X¡R                  UR                   5      I Sh  v•N n[#        XñR                   5      nU	c5  Un	U	R                  S:X  a"  [%        U	5         ['        X)R(                  5        OCOB[%        U	5        [%        U5        [+        XŸ5      n[-        XŸ5      n	 ['        X)R(                  5        U" U	5        GM˜   GN² GN% Nå! [         a    [        X	5      I Sh  v•N    e f = f NÉ! [         a    U	b  [        X	5      I Sh  v•N    e f = f! [         a    [        X	5      I Sh  v•N    e f = f! [         a&    U	R                  S:X  a  [        X	5      I Sh  v•N    e f = f! , (       d  f       g= f7f)u±  Run the innermost non-streaming model request, resolving any continuation chain.

Loops over any suspended â†’ complete continuation segments (Anthropic `pause_turn`,
OpenAI background mode), echoing each suspended response back and merging the segments
into one response. Only the final merged response is returned, so `wrap_model_request`
spans the whole chain and `after_model_request` sees just the final response.
Continuations are not separate request steps, so usage is committed exactly once when
the merged response is appended to history. When `request_context.messages` ends in a
suspended `ModelResponse` (a resumed run), that response seeds the loop.

Under the bundled durable-execution capabilities (Temporal/DBOS/Prefect) this loop runs
in workflow code: the capability swaps `request_context.model` for a wrapper that
dispatches each segment's `model.request(...)` through its own activity/step/task, so a
failed segment retries alone and each suspended response is checkpointed between
segments.

Args:
    model: The model to call.
    request_context: The merged request context (messages, settings, parameters).
    run_context: The current run context, made available via `get_current_run_context`.
    on_progress: Callback invoked with the merged response after each segment, so the
        caller can preserve partial progress when a later segment's error is converted
        to a retry.

Returns:
    The (merged) model response.
Nr   r�   zreplace-same-idr8   zModel response for job z1 remained suspended after polling the maximum of z timeszModel response z( was suspended more than the maximum of )r¤  r?   r²  rL   r‘   Úprovider_response_idrN   rO   rR   r>   rÕ   Úcontinuation_delayr}   r‰   r6  Úmodel_settingsÚmodel_request_parametersÚ_narrow_tool_call_partsrH   r®  rB   rS   rT   )r’   Úrequest_contextrP  Úon_progressÚbase_messagesr±  Úaccumulate_countÚreplace_countÚ	last_modeÚresponser?   Újob_idÚ
over_limitÚlimit_messager|   Únew_responses                   rv   Úmodel_requestrÄ  Ú  sÁ  é € ôD -¨_×-EÑ-EÓFÑ€MÜ
" 5°tÓ
<×<Ð<ð ÐØ€Mð #'€IØ€HÜ	  Õ	-ØØÑØ(‘Ø—‘ ;Ó.Ø!×6Ñ6�ØÐ 1Ó1Ø! QÑ&�MØ!.Ô1EÑ!E�Jà1°&±ð <Ü2Ð3°6ð;ñ "ð
 %¨Ñ)Ð$Ø!1Ô4PÑ!P�Jà)¨&©Ð3[Ü7Ð8¸ð@ð "ö ä.¨uÓ?×?Ð?Ü$×<Ò<¸]ÓKÐKØ!×4Ñ4°XÓ>Ð>�5Õ>ðÜ0°Ó7×7Ð7ð 6˜]Ð5¨HÐ5‘à÷G 
.Ñ	-ðJ
Ø%*§]¡]Ø×<Ñ<¸o×>fÑ>fó&÷  �ô 3°<×AiÑAiÓjˆLØÑØ'�Ø—>‘> [Ó0Ü& xÔ0ðÜ1°+¿~¹~ÕNð 1ô # 8Ô,Ü" <Ô0ô ' xÓ>�	Ü*¨8ÓB�ðÜ-¨k¿>¹>ÔJñ ˜Ô!ò] ò! =òJ @ñ 8øÜ(ó ô 3°5ÓC×CÑCØðúñ øô !ó ð Ñ'Ü.¨uÓ?×?Ñ?Øðûô )ó Ü2°5ÓC×CÑCØðûô  %ó ð  —~‘~¨Ó4Ü2°5ÓC×CÑCØðú÷Q 
.Õ	-üsô   ‚'J©GªJÁA8JÂ9GÂ:2JÃ-G#Ã;G!Ã<G#Ä JÄ
JÄ)HÄ<HÄ=HÅ5JÅ7H.Æ.JÆ;IÇJÇJÇJÇ!G#Ç#HÇ;G>Ç<HÈJÈHÈH+È#H&È$H+È+JÈ.IÉI	ÉIÉJÉ(JÉ9I<É:JÊJÊ
JÊJc              óº  ^#   • [        UR                  5      u  p4[        U TU5      I Sh  v•N   [        T5         [	        UR
                  U UR                  UT[        [        [        U4S j[        U[        5       S9n U7v •  UR                  5       I Sh  v•N    SSS5        g N| N! UR                  5       I Sh  v•N    f = f! , (       d  f       g= f7f)uÑ  Open the innermost streaming model request, stitching any continuation chain.

Under the bundled durable-execution capabilities (Temporal/DBOS/Prefect) this runs in
workflow code: the capability swaps `request_context.model` for a wrapper whose
`request_stream` drains one segment inside its own activity/step/task and replays its
buffered events, so the composite below stitches per-segment replays.

The yielded stream is a composite that stitches the (possibly suspended â†’ complete)
segments into one continuous stream: it opens a `model.request_stream(...)` per segment
as it's iterated, so the whole chain is presented as a single stream and the
model-request hooks wrap it once. When `request_context.messages` ends in a suspended
`ModelResponse` (a resumed run), that response seeds the loop. On exit, the helper tears
down any in-flight segment's connection (`aclose()`), which deliberately does *not*
cancel a still-pending server-side job â€” cancellation stays on the
`AgentStream.cancel()` â†’ `close_stream()` path.

Args:
    model: The model to call.
    request_context: The merged request context.
    run_context: The current run context.

Yields:
    A `StreamedResponse` to iterate inside the durable boundary.
Nc                ó   >• [        TU 5      $ r‡   )r®  )r¬  rP  s    €rv   r±   Ú&model_request_stream.<locals>.<lambda>‰  s   ø€ Ô3LÈ[ÐZlÔ3mr    )r·  r’   r¶  r»  rP  Úmax_generation_continuationsÚmax_background_pollsrt   Úcheck_usageÚfinalize_responseÚinitial_suspended_responseÚsegment_context)r¤  r?   r²  rL   rQ   r·  r¶  rO   rN   r}   rH   r   Úaclose)r’   r¹  rP  r»  r±  Úsrs     `   rv   Úmodel_request_streamrÐ  ^  s¹   øé € ô> -¨_×-EÑ-EÓFÑ€MÜ
" 5¨+°tÓ
<×<Ð<Ü	  Õ	-Ü*Ø%4×%MÑ%MØØ*×9Ñ9Ø'Ø#Ü)EÜ!5Ü)ÜmÜ0Ø'+ô
 4Ó5ñ!
ˆð$	Ø‹Hð —)‘)“+×Ñ÷5 
.Ð	-ñ =ñ6 ø�"—)‘)“+×Òú÷5 
.Õ	-üs]   ƒ(C«B(¬C»AC
ÂB,ÂC
ÂB*ÂC
Â
CÂ*C
Â,CÃ C
ÃCÃC
Ã

CÃCc                ó¢  • U R                   R                  S:w  d1  U R                  R                  c  [        R
                  " 5       (       d  gU R                  R                  U R                  R                  =(       d     U R                  R                  R                  [        S U R                  R                  R                   5       5      S9  g)u�  Show the first-run banner, from whichever path prepared the run's first request.

Called once the step's tool manager is built, the earliest point that knows which tools the
model will be offered: dynamic toolsets and MCP servers have been resolved by now. Output tools
are left out, as the banner reports the output type separately and counting them would make the
number move with the output mode rather than with what the agent was given.

Every reason there won't be a banner is checked before any of that is gathered, so a run that
isn't getting one counts nothing: this is on a path every run takes, and past the first one it
comes down to reading a flag.

An instrumented run has what the banner would point it to, so it stays out of the way â€” without
spending the claim, since another agent in this process may not be instrumented. `clai` differs:
its banner is also its session header, so it shows one either way.
r8   Nc              3  ó>   #   • U  H  oR                   S :g  v •  M     g7f)rz  N)r}  )r~  r›  s     rv   r€  Ú,_display_first_run_banner.<locals>.<genexpr>±  s   é € Ð\Ò<[°—-‘- 8Ö+Ò<[ùs   ‚)r’   Útools)r‘   r­   r?  r	  r9   Úbanner_pendingr
  r  r’   Úsumr  rŽ  ©r  s    rv   Ú_display_first_run_bannerrØ  œ  sŒ   € ð  ‡y�y×Ñ˜QÓ #§(¡(×"CÑ"CÑ"OÔW_×WnÒWn×WpÑWpØà‡H�H×ÑØ�h‰h×Ñ×: 3§8¡8§>¡>×#:Ñ#:ÜÑ\¸C¿H¹H×<QÑ<Q×<[Ò<[Ó\Ó\ð ò r    c                  ó˜  • \ rS rSr% SrS\S'   SrS\S'   S\S	'   S
rS\S'    \" SSS
S9r	S\S'   \" SSSS9r
S\S'   \" SSS
S9rS\S'       SS 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5       r      S%S jr\rSrg
)&rc   iµ  z[The node that makes a request to the model using the last message in state.message_history.ú_messages.ModelRequestr6  FÚboolr:  r*  r+  Nú_messages.ModelResponse | Noner7  )r  Úinitro   zOCallToolsNode[DepsT, NodeRunEndT] | ModelRequestNode[DepsT, NodeRunEndT] | NoneÚ_resultr  zModelRequestContext | NoneÚlast_request_contextc              ƒ  óÀ   #   • U R                   b  U R                   $ U R                  (       a  [        R                  " S5      eU R	                  U5      I S h  v•N $  N7f)Nz.You must finish streaming before calling run())rÞ  r  r>   ÚAgentRunErrorÚ_make_request©r¾   r  s     rv   rU  ÚModelRequestNode.runË  sO   é € ð �<‰<Ñ#Ø—<‘<Ðà××ô ×*Ò*Ð+[Ó\Ð\à×'Ñ'¨Ó,×,Ð,Ñ,ùs   ‚AAÁAÁAc           	    ó¶  ^ ^^^^^^#   • T R                   (       a   S5       e T R                  TSS9I S h  v•N u  p#pEm[,        R.                  " 5       m[,        R.                  " 5       m/ mS m    SUUUUU UU4S jjn
[1        UUUUS9nTR                  R2                  Ul        SUl        TR                  R6                  nUR8                  (       a  UR;                  TUU
S	9nOU
" U5      n[,        R<                  " U5      n[,        R<                  " TR?                  5       5      n [,        R>                  " Xþ1[,        R@                  S
9I S h  v•N   [C        U5      I S h  v•N   URI                  5       (       aá  TRK                  5       (       dÌ    URM                  5       nT RQ                  TTUU5      I S h  v•N nST l         [        R                  " TR
                  R                  5        [!        UUSS9nT R%                  TUU5      n	 U	7v •  U	R'                  5       I S h  v•N   UT l.        T R)                  TU5      I S h  v•N   T R*                  c   eg S n TS   7v •   TRG                  5          UbØ  [_        U5      I S h  v•N   T(       a½  TS   R"                  n[a        UUU5      I S h  v•N n[c        UUTR
                  R                  TR
                  Rd                  S9n[g        U5        [        Rh                  " TR
                  R                  UR                  5        TR
                  R                  Rk                  U5        O=  UI S h  v•N nUT l.        T R)                  TU5      I S h  v•N   T R*                  c   e TS   R'                  5       I S h  v•N   g  GNy! [        R                   GaQ  n[	        TR
                  R                  TR
                  R                  TR                  R                  TR                  R                  S9TR                  l        ST l         [        R                  " TR
                  R                  5        [        TS S9I S h  v•N  n[!        UR"                  US9nT R%                  TX‡5      n	 U	7v •  U	R'                  5       I S h  v•N    O! U	R'                  5       I S h  v•N    f = fT R)                  TUR"                  5      I S h  v•N    T R*                  c   e S nAg S nAff = f GNË GN»! [D         a&    TRG                  5         [C        Xþ5      I S h  v•N    e f = f! [N         a  nUn S nAGNÂS nAff = f GN³! [        RR                   a¤  nST l         [U        T5      mT RW                  TU5      I S h  v•N    [!        [X        RZ                  " / S9US9nT R%                  TUU5      n	 U	7v •  U	R'                  5       I S h  v•N    O! U	R'                  5       I S h  v•N    f = f S nAg S nAff = f GN! U	R'                  5       I S h  v•N    f = f GN! [D         a  nUne S nAff = f GNÙ GN± GN! [        RR                   a    e [N         a6  nURl                  (       d  e URo                  TX¶S9I S h  v•N  n S nAGN[S nAff = f GNG! [        RR                   a=  nTc   eT Rq                  TT5        T RW                  TU5      I S h  v•N     S nAGN�S nAff = f GNs! TS   R'                  5       I S h  v•N    f = f! TRG                  5          UbÚ  [_        U5      I S h  v•N    T(       a¾  TS   R"                  n[a        UUU5      I S h  v•N  n[c        UUTR
                  R                  TR
                  Rd                  S9n[g        U5        [        Rh                  " TR
                  R                  UR                  5        TR
                  R                  Rk                  U5        Oé  UI S h  v•N  nOV! [        RR                   a    e [N         a5  nURl                  (       d  e URo                  TX¶S9I S h  v•N  n S nAOS nAff = fUT l.        T R)                  TU5      I S h  v•N    T R*                  c   eOS! [        RR                   a<  nTc   eT Rq                  TT5        T RW                  TU5      I S h  v•N     S nAOS nAff = fTS   R'                  5       I S h  v•N    f ! TS   R'                  5       I S h  v•N    f = f= f7f)Nz,stream() should only be called once per nodeT©Ú	streaming©rñ   rò   )rT  )r·  c              “  óÐ  >#   • [        U R                  5        [        R                  " 5       n[	        U R                  U TS9 IS h  v•N nST	l        [        R                  " TR                  R                  5        T	R                  TX R                  5      nTR                  U5        TR                  5          T
R                  5       I S h  v•N   [        R                  " UR!                  U5      5        S S S 5      IS h  v•N   WR#                  5       nUmU$  NÔ NO! [        R                  " UR!                  U5      5        f = f NF! , IS h  v•N  (       d  f       N[= f7f)N)r¹  rP  T)r'  r’   ÚtimeÚperf_counterrÐ  r  r=   Úrecord_requestr‘   rB   Ú_build_agent_streamr·  rE  rr   Úwaitr!   Útime_to_first_chunkry   )Úreq_ctxÚrequest_startrÏ  Úagent_streamr¿  Ú_handler_responseÚagent_stream_holderr  rP  r¾   Ústream_doneÚstream_readys        €€€€€€€rv   Ú_streaming_handlerÚ3ModelRequestNode.stream.<locals>._streaming_handler  s  øé € ô -¨W¯]©]Ô;ô !×-Ò-Ó/ˆMô ,¨G¯M©MÈ7Ð`k×lÒlÐprØ#'�Ô Ü"×1Ò1°#·)±)·/±/ÔBØ#×7Ñ7¸¸R×AaÑAaÓb�Ø#×*Ñ*¨<Ô8Ø× Ñ Ô"ðWØ%×*Ñ*Ó,×,Ð,ô ,×/Ò/°×0FÑ0FÀ}Ó0UÔV÷ m×lð —v‘v“xˆHØ (ÐØˆOñ# mñ -øô ,×/Ò/°×0FÑ0FÀ}Ó0UÕVú÷ m×l×lÐlüss   ƒAE&ÁDÁE&ÁA/EÂ;D ÃDÃD Ã%EÃ8E&ÄE
ÄE&ÄD Ä 'EÅEÅ
E&ÅE#ÅEÅE#ÅE&©r’   r?   r¶  r·  ©r¹  Úhandler)Úreturn_whenr5  )r·  Úreplay_eventsr   )r‘   r³   r›   ©r¹  r×   ©rð  r,   rÚ   ú_messages.ModelResponse)9r  Ú_prepare_requestr>   ÚSkipModelRequestÚ_first_new_message_indexr‘   r�   r³   r?  rñ   rò   rï   r=   rì  rB   r¡  r+   r¿  rí  Úaclose_eventsÚ_finish_handlingrÞ  rz   r  r,   r  rç  r   Ú_has_wrap_model_requestÚwrap_model_requestÚcreate_taskrî  ÚFIRST_COMPLETEDr#   r‰   rr   ÚdoneÚis_setrA   rÍ   Ú_resolve_wrap_resultÚ
ModelRetryre   Ú_build_retry_noderÇ   rÈ   rß  r‹   r•   r   r›   rH   Úrecord_usagerE  Ú_has_on_model_request_errorÚon_model_request_errorÚ_append_response)r¾   r  r’   r¶  r·  r�   ÚeÚskip_mrpÚskip_srrò  r÷  Úwrap_request_contextr   Úwrap_awaitableÚ	wrap_taskÚready_waiterÚresult_or_excrÏ   Údummy_srÚ	replay_srr“   Úexcr”   Úrecorded_stateÚpartial_responseró  rô  rP  rõ  rö  s   ``                       @@@@@rv   r‚   ÚModelRequestNode.streamØ  sm  þé € ð
 ×#×#ÐSÐ%SÓSÐ#ð	Øbf×bwÑbwØ˜tð cxð c÷ ]ÑYˆEÐ#;Èkô@ —}’}“ˆÜ—m’m“oˆØBDÐà<@Ðð	Ø(ð	à$÷	õ 	ôB  3ØØ$Ø)Ø%=ñ	 
Ðð ),¯©×(9Ñ(9ÐÔ%à)-ÐÔ&ØŸ(™(×2Ñ2ˆØ×2×2Ø,×?Ñ?ØØ 4Ø*ð @ð ‰Nñ 0Ð0DÓEˆNÜ×'Ò'¨Ó7ˆ	ô
 ×*Ò*¨<×+<Ñ+<Ó+>Ó?ˆð	1Ü—,’, Ð8Äg×F]ÑF]Ñ^×^Ð^ô  # <Ó0×0Ð0à�>‰>×Ñ L×$7Ñ$7×$9Ñ$9ðð&Ø$-×$4Ñ$4Ó$6�Mð (,×'@Ñ'@ÀÀkÐSgÐivÓ'w×!w�ð   $ˆDÔÜ×-Ò-¨c¯i©i¯o©oÔ>Ü1ØØ)AØ"ñˆIð
  ×3Ñ3°C¸ÐD\Ó]ˆLð3Ø"Ó"ð #×0Ñ0Ó2×2Ð2Ø(<ˆDÔ%Ø×'Ñ'¨¨^Ó<×<Ð<Ø—<‘<Ñ+Ð+Ð+Øð .2ˆð4	=Ø% aÑ(Ô(ð
 �O‰OÔð-=ØÑ+Ü& yÓ1×1Ð1ö
 +Ø"5°aÑ"8×"AÑ"A˜Ü/PÐQVÐXdÐfmÓ/n×)n˜Ü+2Ø#Ø"0Ø#&§9¡9×#3Ñ#3Ø,/¯I©I×,EÑ,Eñ	,Ð(ô +Ð+;Ô<Ü*×7Ò7¸¿	¹	¿¹ÐIY×I_ÑI_Ô`ØŸ	™	×1Ñ1×8Ñ8Ð9IÔJøð8ð	Ø3<¯_˜Nð" 5I˜Ô1Ø"×3Ñ3°C¸ÓH×HÐHØ#Ÿ|™|Ñ7Ð7Ñ7ð *¨!Ñ,×:Ñ:Ó<×<Ñ<òg]øô ×*Ñ*ô 	ô *BØ—	‘	×)Ñ)Ø—	‘	× Ñ Ø #§¡× 8Ñ 8Ø&)§h¡h×&DÑ&Dñ	*ˆC�H‰HÔ&ð  $ˆDÔÜ×-Ò-¨c¯i©i¯o©oÔ>ä8¸ÐPTÑU×UÐUˆHÜ/°·
±
ÐU]Ñ^ˆGØ×3Ñ3°C¸ÓKˆLð3Ø"Ó"à"×0Ñ0Ó2×2Ò2ø�l×0Ñ0Ó2×2Ò2úØ×'Ñ'¨¨Q¯Z©ZÓ8×8Ñ8Ø—<‘<Ñ+Ð+Ð+Üûð+	úòz _ò  1øô ó 	ð �O‰OÔÜ" <Ó;×;Ñ;Øð	ûô. !ó &Ø$%–Mûð&úâ!wøÜ×(Ñ(ó Ø#'�Ô ä/°Ó4�Ø×,Ñ,¨S°!Ó4×4Ñ4ä4Ü×+Ò+°"Ñ5ÐPhñ�ð  $×7Ñ7¸¸XÐG_Ó`�ð7Ø&Ó&à&×4Ñ4Ó6×6Ò6ø˜,×4Ñ4Ó6×6Ò6úÜûðúò8 3ø�l×0Ñ0Ó2×2Ò2úâ<øô ó 	ØˆLØûð	úò 2ò *oò .=øÜ)×4Ñ4ó "Ø!Ü(ó Ø#2×#N×#NØ %Ø3B×3YÑ3YØ +Ð=Qð 4Zð 4÷ .ð .žNûðúò Iøô &×0Ñ0ó =ð  1Ñ<Ð<Ð<Ø×-Ñ-¨cÐ3DÔEØ"×4Ñ4°S¸!Ó<×<×<ûð=úò =øÐ)¨!Ñ,×:Ñ:Ó<×<Ò<ûð] �O‰OÔð-=ØÑ+Ü& yÓ1×1Ñ1ö
 +Ø"5°aÑ"8×"AÑ"A˜Ü/PÐQVÐXdÐfmÓ/n×)nÐ)n˜Ü+2Ø#Ø"0Ø#&§9¡9×#3Ñ#3Ø,/¯I©I×,EÑ,Eñ	,Ð(ô +Ð+;Ô<Ü*×7Ò7¸¿	¹	¿¹ÐIY×I_ÑI_Ô`ØŸ	™	×1Ñ1×8Ñ8Ð9IÔJøð8ð	Ø3<¯_¨_™NøÜ)×4Ñ4ó "Ø!Ü(ó Ø#2×#N×#NØ %Ø3B×3YÑ3YØ +Ð=Qð 4Zð 4÷ .ð .�Nûðúð 5I˜Ô1Ø"×3Ñ3°C¸ÓH×HÑHØ#Ÿ|™|Ñ7Ð7Ñ7øô &×0Ñ0ó =ð  1Ñ<Ð<Ð<Ø×-Ñ-¨cÐ3DÔEØ"×4Ñ4°S¸!Ó<×<Ö<ûð=úð *¨!Ñ,×:Ñ:Ó<×<Ò<øÐ)¨!Ñ,×:Ñ:Ó<×<Ò<ÿsx  ‰e£N2 ¶N/·N2 ¿C)eÄ)'T! ÅTÅT! ÅeÅ#TÅ$.eÆU Æ$U1 Æ;U.Æ<U1 Ç AeÈX/ ÈeÈ(X,È) eÉ	YÉ
eÉ!Y É*eÉ;\ ÊY%Ê*\ Ê7Y(Ê8B\ ÍY. ÍY+ÍY. Í"\ Í>[Í?\ ÎeÎ)\Î*eÎ/N2 Î2TÏB)TÑ0Q3Ñ1+TÒR<Ò"TÒ5R8Ò6TÒ<SÓS
ÓSÓ"TÓ9S<Ó:TÔeÔTÔeÔT! ÔeÔ!(UÕ	UÕ
UÕeÕ
U+ÕU&Õ U1 Õ&U+Õ+U1 Õ1X)Ö'X$Ö,V/Ö-4X$×"X×'X$×:W=×;X$ØXØX
ØXØX$ØeØ$X)Ø)eØ/Y
ÙYÙY
Ù
eÙ
Y"ÙYÙY"Ù"]  Ù%\ Ù(\ Ù+Y. Ù.[Ú%Z=Ú1Z4Ú2Z=Ú7[ Ú=[Û[ Û\ Û\Û,\Ü\Ü	\Ü\ Ü\Ü\ ÜeÜ\=Ü6\9Ü7\=Ü=eÝ eÝd5Ý#]&Ý$+d5Þ^ÞBd5à1`=à6`9à7`=à<cà=bá%bâ b
âbâcâbâcâd5â/b2â0d5ãdã,däd
ädäd5ädäd5äeä.d1ä/eä5eåeåeåeåec                óB  ^ • [         R                  [        [        4   " UT R                  R
                  UT R                  R                  [        T 5      T R                  R                  T R                  R                  T R                  R                  U 4S jU 4S jS9
$ )z@Build an AgentStream from the given stream response and context.c                 ó0   >• T R                   R                  $ r‡   )r‘   rµ   r×  s   €rv   r±   Ú6ModelRequestNode._build_agent_stream.<locals>.<lambda>Å  s   ø€  S§Y¡Y×%7Ò%7r    c                 ó0   >• T R                   R                  $ r‡   )r‘   rƒ   r×  s   €rv   r±   r#  Æ  s   ø€ °·	±	×0MÒ0Mr    )
Ú_raw_stream_responseÚ_output_schemaÚ_model_request_parametersÚ_output_validatorsÚ_run_ctxÚ_usage_limitsÚ_tool_managerÚ_root_capabilityÚ_metadata_getterÚ_event_stream_buffer_getter)rA   ÚAgentStreamr~   ri   r?  rü   rý   re   rù   r  r   )r  Ústream_responser·  s   `  rv   rí  Ú$ModelRequestNode._build_agent_streamµ  sv   ø€ ô ×!Ñ!¤%¬ (Ò+Ø!0ØŸ8™8×1Ñ1Ø&>Ø"Ÿx™x×9Ñ9Ü& sÓ+ØŸ(™(×/Ñ/ØŸ(™(×/Ñ/Ø ŸX™X×5Ñ5Ü7Ü(Mñ
ð 	
r    c              ƒ  óÖ  ^^#   • U R                   b  U R                   $  U R                  USS9I S h  v•N u  p#pEmS mSUU4S jjn[#        UUUUS9nUR                  R$                  Ul        UR                  R&                  n	  U	R(                  (       a  U	R+                  TUUS9I S h  v•N n
OU" U5      I S h  v•N n
 X€l        [        R                  " UR
                  R                  5        U R                  X5      I S h  v•N $  N×! [        R                   aÃ  n[	        UR
                  R                  UR
                  R                  UR                  R                  UR                  R                  S9UR                  l        [        R                  " UR
                  R                  5        U R                  XR                   5      I S h  v•N  s S nA$ S nAff = f GN< GN.! [        R                   a  nUR                   n
 S nAGNQS nAf[        R,                   a    e [.         a6  nU	R0                  (       d  e U	R3                  TX†S9I S h  v•N  n
 S nAGN£S nAff = f! [        R,                   ac  nTb<  [        R                  " UR
                  R                  5        U R5                  UT5        U R7                  X5      I S h  v•N  s S nA$ S nAff = f GNá7f)	NFræ  rè  c              “  ód   >#   • SU4S jjn[        U R                  U TUS9I S h  v•N nUmU$  N7f)Nc                ó
   >• U mg r‡   r°   )r¿  ró  s    €rv   rº  ÚJModelRequestNode._make_request.<locals>.model_handler.<locals>.on_progressè  s	   ø€ à$,Ñ!r    )r¹  rP  rº  )r¿  r   rÚ   rÛ   )rÄ  r’   )rð  rº  r¿  ró  rP  s      €€rv   Úmodel_handlerÚ5ModelRequestNode._make_request.<locals>.model_handlerà  s<   øé € ÷-ô +Ø—‘¨wÀKÐ]hñ÷ ˆHð !)ÐØˆOñ	ùs   ƒ"0¥.¦	0rù  rú  rþ  rÿ  )rÞ  r  r>   r  r  r‘   r�   r³   r?  rñ   rò   rï   r=   rì  rB   r  r¿  r,   r  r   r  r  r  rÍ   r  r  r  r  rß  )r¾   r  r’   r¶  r·  r�   r  r6  r¹  r   rÏ   ró  rP  s              @@rv   râ  ÚModelRequestNode._make_requestÉ  s…  ùé € ð �<‰<Ñ#Ø—<‘<Ðð	@Øbf×bwÑbwØ˜uð cxð c÷ ]ÑYˆEÐ#;Èkð =AÐ÷	ð 	ô$ .ØØ$Ø)Ø%=ñ	
ˆð $'§8¡8×#4Ñ#4ˆÔ ØŸ(™(×2Ñ2ˆð	8ðØ"×:×:Ø+:×+MÑ+MØ#Ø(7Ø -ð ,Nð ,÷ &‘Nñ ,9¸Ó+I×%I‘Nð$ %4Ô!Ü×)Ò)¨#¯)©)¯/©/Ô:à×*Ñ*¨3Ó?×?Ð?ñQ]øô ×*Ñ*ó 		@ä)AØ—	‘	×)Ñ)Ø—	‘	× Ñ Ø #§¡× 8Ñ 8Ø&)§h¡h×&DÑ&Dñ	*ˆC�H‰HÔ&ô ×-Ò-¨c¯i©i¯o©oÔ>Ø×.Ñ.¨s·J±JÓ?×?Ð?Õ?ûð		@úòT&ò &JøÜ×.Ñ.ó ,Ø!"§¡–ûÜ×(Ñ(ó ØÜó Ø&×B×BØØ'6×'MÑ'MØ°ð (Nð (÷ "ð "–ûðûô ×$Ñ$ó 	8ð !Ñ,Ü"×1Ò1°#·)±)·/±/ÔBØ×%Ñ% cÐ+<Ô=Ø×/Ñ/°Ó7×7Ð7Õ7ûð	8úò @ùs  „K)ŸD ²D
³D »AK)Â%G, Â*G&Â+G, Â/K)Â0G, Â;G)Â<G, Ã AK)ÄK&ÄK)Ä
D ÄG#Ä B3GÇGÇGÇG#ÇK)ÇG#Ç#K)Ç&G, Ç)G, Ç,I)È HÈI, ÈK)È!I)È3%I$ÉIÉI$ÉI, É"K)É$I)É)I, É,K#Ê AKËKËKËK#ËK)ËK#Ë#K)c             ƒ  óø  #   • U R                   b  U R                  XS9I S h  v•N $ [        5       U R                  l        U R
                  (       d=  [        U R                  UR                  R                  UR                  R                  S9  UR                  R                  R                  U R                  5        UR                  =R                  S-  sl        [        U5      I S h  v•N   [        U5        [        U5        [!        U5      n[#        UUR                  R$                  UR&                  R(                  R*                  S9nUR&                  R(                  R-                  U5      I S h  v•N UR&                  l        [/        U5        [1        X5      I S h  v•N nU(       a(  [2        R4                  R7                  U5      =(       d    S nU(       a  [2        R4                  R9                  U5      OS U R                  l        UR                  R                  S S (       dL  U R                  R<                  (       d1  U R                  R:                  (       d  [>        R@                  " S5      e[C        X5      I S h  v•N nUR&                  RE                  U5      =(       d
    [G        5       nXcl$        [K        UR&                  RL                  UR                  R                  S S  UUS9nUR&                  RN                  Ul'        X'l(        [S        URT                  5      nXpl+        UR&                  RX                  R[                  UU5      I S h  v•N nXpl+        URL                  n	URT                  n
URH                  nUR\                  n[S        U
5      S:X  a  [>        R@                  " S	5      e[_        U
S   [2        R`                  5      (       d  [>        R@                  " S
5      e[        U
S   UR                  R                  UR                  R                  S9  [c        U R                  URd                  5        U R
                  (       a9  U R                  UR&                  l3        [S        U
5      S-
  UR&                  l4        OUUR&                  Rh                  b>  UR&                  Rh                  U[S        U
5      -
  -
  nUS:¼  a  UOS UR&                  l4        X¡R                  R                  S S & [        U5        [k        U
UR                  R                  UR&                  Rf                  UR&                  Rh                  S9UR&                  l6        [o        U
SS9n
[q        XZ5      nU	Rs                  X¥5      nXÊLa  [o        USS9n
OUn
U(       a  URu                  S5      OS UR                  l;        XQR                  l<        UR                  Rz                  nUR&                  R|                  R~                  (       Ga!  [�        U5      n[ƒ        S […        U
5       5       5      nUR†                  =(       d    0 Ru                  [ˆ        5      n[‹        U5      (       a  [�        U5      O0 nU	R�                  X¦U5      I S h  v•N nUR†                  =(       d    0 Ru                  [ˆ        5      n[‹        U5      (       a8  UR‘                  5        VVs0 s H  u  nnUU;  d  UU   U:w  d  M  UU_M     snnO0 nU(       a£  [ƒ        S […        UR                  R                  5       5       5      nUULao  UR†                  =(       d    0 UlC        UR†                  Ru                  [ˆ        5      n[‹        U5      (       d  0 nUUR†                  [ˆ        '   UR“                  U5        [•        UU	R–                  U	R˜                  U	Rš                  S9nUb  URœ                  OS UlO        UR¡                  U5        UR&                  R|                  R£                  UR¤                  5        UR&                  R|                  R§                  U5        X–=(       d    S XZU4$  GN= GNx GNð GNÆ GNæ GN GNæs  snnf 7f)Nræ  ©r³   r›   r8   ©r8  r9  rÂ   z9No message history, user prompt, or instructions providedrù  r   z"Processed history cannot be empty.z1Processed history must end with a `ModelRequest`.rè  Tr3  Ú
max_tokensc              3  óh   #   • U  H(  n[        U[        R                  5      (       d  M$  Uv •  M*     g 7fr‡   ©r�   rÇ   rA  ©r~  rž   s     rv   r€  Ú4ModelRequestNode._prepare_request.<locals>.<genexpr>Æ  s&   é € ð $Ú'9˜G¼ZÈÔQZ×QgÑQg×=h—‘Ò'9ùó   ‚#2©	2c              3  óh   #   • U  H(  n[        U[        R                  5      (       d  M$  Uv •  M*     g 7fr‡   r>  r?  s     rv   r€  r@  Þ  s)   é € ð 'â#F˜Ü! '¬9×+AÑ+A×B÷ ‘GÚ#FùrA  )Ú
model_nameÚprovider_api_urlÚprovider_name)Tr7  Ú_prepare_resume_requestr'   r6  Ú	timestampr:  r%   r‘   r³   r›   r�   rE  r­   Ú_select_modelÚ_refresh_loaded_capability_idsÚ_refresh_discovered_tool_namesre   r   r¬   r?  r  rG  rH  rØ  rJ  rÇ   rv  Úsortedrw  r-  rÊ   r>   r£   r¡  rø   rW   r¶  r,   r’   r  rç  r¥   r?   rß  r   Úbefore_model_requestr·  r�   rA  rx  rT  rñ   rò   r  rï   r>  Ú_with_outgoing_reveal_stateÚprepare_messagesry   r·   r¸   rB   rù   Úcount_tokens_before_requestr   Únextrš   rµ   Ú_PYDANTIC_AI_METADATA_KEYr&   ré   Úcount_tokensr“  r[  rG   rC  Úbase_urlÚsystemÚtotal_pricerª  r¨  Úcheck_per_request_input_tokensÚinput_tokensÚcheck_before_request)r¾   r  rç  rP  rT  r·  r¶  r¹  Úmessages_before_processingr’   r?   ÚshiftedÚpreparedrB   Úoutgoing_requestÚraw_outgoing_namespace_beforeÚoutgoing_namespace_beforeÚcounted_usageÚoutgoing_namespaceÚkeyÚvalueÚupdatesÚdurable_requestÚdurable_namespaceÚcounted_prices                            rv   r  Ú!ModelRequestNode._prepare_request  sÏ  é € ð ×!Ñ!Ñ-Ø×5Ñ5°cÐ5ÐO×OÐOä!(£ˆ�‰ÔØ×.×.Ü˜dŸl™l°3·9±9×3CÑ3CÐUX×U^ÑU^×UnÑUnÒoØ�	‰	×!Ñ!×(Ñ(¨¯©Ô6à�	‰	×Ò˜aÑÕä˜CÓ × Ð ä& sÔ+ä& sÔ+ä'¨Ó,ˆÜØØ—)‘)×/Ñ/ØŸ™×-Ñ-×AÑAñ
ˆð '*§h¡h×&;Ñ&;×&HÑ&HÈÓ&U× Uˆ�‰Ôä! #Ô&ô #4°CÓ"E×EÐÞÜ )× 9Ñ 9× @Ñ @ÐARÓ S× [ÐW[ÐÞYj¤I×$=Ñ$=×$BÑ$BÐCTÔ$UÐptˆ�‰Ô!ð �y‰y×(Ñ(¨¨"Ö-°d·l±l×6H×6HÐQU×Q]ÑQ]×Qj×QjÜ×&Ò&Ð'bÓcÐcä)DÀSÓ)\×#\Ð ØŸ™×4Ñ4°[ÓA×TÄ]Ã_ˆØ%3Ô"ä-Ø—(‘(—.‘.Ø—Y‘Y×.Ñ.©qÐ1Ø)Ø%=ñ	
ˆð $'§8¡8×#4Ñ#4ˆÔ Ø$-Ô!Ü%(¨×)AÑ)AÓ%BÐ"Ø$3Ô!Ø #§¡× 8Ñ 8× MÑ MØØó!
÷ 
ˆð %4Ô!Ø×%Ñ%ˆØ"×+Ñ+ˆØ(×7Ñ7ˆØ#2×#KÑ#KÐ äˆx‹=˜AÓÜ×&Ò&Ð'KÓLÐLä˜( 2™,¬	×(>Ñ(>×?Ñ?Ü×&Ò&Ð'ZÓ[Ð[ô 	˜( 2™,¨s¯y©y×/?Ñ/?ÐQT×QZÑQZ×QjÑQjÒkô 	! §¡Ð/G×/YÑ/YÔZà×*×*ð (,§|¡|ˆC�H‰HÔ$Ü-0°«]¸QÑ->ˆC�H‰HÕ*Ø�X‰X×+Ñ+Ñ7ð —h‘h×4Ñ4Ð8RÔUXÐYaÓUbÑ8bÑcˆGØ8?À1»©WÈ$ˆC�H‰HÔ*à'/�	‰	×!Ñ!¡!Ð$ô 	' sÔ+ô &>ØØ�I‰I×ÑØŸH™H×4Ñ4Ø"%§(¡(×"@Ñ"@ñ	&
ˆ�‰Ô"ô *¨(ÈÑNˆô $?Ð?WÓ#bÐ ð ×)Ñ)¨(ÓMˆð Ò#Ü-¨hÈTÑR‰HàˆHæHV N×$6Ñ$6°|Ô$DÐ\`ˆ�	‰	Ô!Ø2J�	‰	Ô/Ø—	‘	—‘ˆØ�8‰8× Ñ ×<×<Ð<ä˜U“OˆEä#ñ $Ü'/°Ô'9ó$ó  Ðð .>×-FÑ-F×-LÈ"×,QÑ,QÔRkÓ,lÐ)ä7BÐC`×7aÑ7a”Ð2Ô3Ðgið &ð #(×"4Ñ"4°XÐOgÓ"h×hˆMð #3×";Ñ";×"A¸r×!FÑ!FÔG`Ó!aÐô Ð1×2Ñ2ð '9×&>Ñ&>Ô&@ôâ&@™
˜˜UØÐ";Ó;Ð?XÐY\Ñ?]ÐafÑ?fó �C˜’JÙ&@óð ð ö Ü"&ñ 'ä#+¨C¯I©I×,EÑ,EÔ#Fó'ó #�ð
 #Ð*:Ò:Ø/>×/GÑ/G×/MÈ2�OÔ,Ø(7×(@Ñ(@×(DÑ(DÔE^Ó(_Ð%Ü&Ð'8×9Ñ9Ø,.Ð)ØN_˜×0Ñ0Ô1JÑKØ%×,Ñ,¨WÔ5ô .ØØ ×+Ñ+Ø!&§¡Ø#Ÿl™lñ	ˆMð ?LÑ>W ×!:Ò!:Ð]aˆMÔØ�J‰J�}Ô%à�H‰H×!Ñ!×@Ñ@À×A[ÑA[Ô\à�‰×Ñ×2Ñ2°5Ô9à×,¨Ð.FÐR]Ð]Ð]òe Pò 	!ò  !Vò
 Fò $]ò
òb iùóùsš   ‚ a:¢a£Ca:Ã*a"Ã+B
a:Å5a%Å6,a:Æ"a(Æ#C"a:Êa+ÊCa:Ía.ÍL2a:Úa1ÚAa:Ûa4Û5a4Û<E$a:á"a:á%a:á(a:á+a:á.a:á1a:á4a:c             ƒ  óH  #   • U R                   c   eUR                  =R                  S-  sl        [        U5        [	        U5        [        U5      n[        UUR                  R                  UR                  R                  R                  S9nUR                  R                  R                  U5      I Sh  v•N UR                  l	        [        U5        [        UR                  R                  5      nU(       a  [        R                   " US9/OSn[#        X5      I Sh  v•N nUR                  R%                  U5      =(       d
    ['        5       nXsl        [+        UR                  R,                  UR                  R                  SS UUS9nUR                  R.                  Ul        X(l        X€l        UR                  R4                  R7                  X85      I Sh  v•N nX€l        UR,                  n	UR8                  n
UR(                  nUR:                  nU
(       a4  [=        U
S   =n[        R>                  5      (       a  UR                  S:X  d  [@        RB                  " S5      e[E        Xj5      nU
SS n[G        [I        U5      S-
  SS5       HH  n[=        XÍ   =n[        RJ                  5      (       d  M(  XáR                  l&        XÑR                  l'          O   [Q        U5      =(       d    UR                  RL                  nUb  [S        XöRT                  5        XÁR                  R                  SS& [        U5        [W        UUR                  RX                  UR                  RL                  UR                  RN                  S	9UR                  l-        U(       a  UR]                  S
5      OSUR                  l/        XaR                  l0        UR                  Rb                  Re                  UR                  Rf                  5        X—=(       d    SXjU4$  GNb GNû GNA7f)u‚  Prepare a request that resumes a turn the provider paused mid-flight.

Unlike `_prepare_request`, the `message_history` already ends in the suspended
`ModelResponse` (there is no new `ModelRequest` to append). The request messages keep
that suspended tail â€” the innermost `model_request`/`model_request_stream` helpers
split it off as the continuation seed, so it also crosses a durable-execution
boundary as part of the messages. Instructions are rehydrated from the recorded
`ModelRequest` rather than re-evaluated, since a continuation completes the same
logical turn and providers (e.g. Anthropic) require the exact prior history back.
Nr8   r;  ©rD  rù  rÂ   r�   zFProcessed history must end with a suspended `ModelResponse` to resume.rè  r<  )4r7  r‘   r­   rI  rJ  re   r   r¬   r?  r  rG  rH  rØ  Ú_get_history_instructionsr�   rÇ   rv  r¡  rø   rW   r¶  r,   r’   r  rç  rß  r   rL  r?   r·  r�   rÈ   r>   r£   rM  Úranger¥   rA  rñ   rò   Ú _get_history_instructions_sourcerx  rT  r  r³   rï   ry   r·   r¸   rù   rX  rB   )r¾   r  rç  rP  r-  rT  r·  r¶  r¹  r’   r?   r�   r»  Úindexrž   Úinstructions_targets                   rv   rF  Ú(ModelRequestNode._prepare_resume_requestû  sE  é € ð, ×%Ñ%Ñ1Ð1Ð1à�	‰	×Ò˜aÑÕä& sÔ+Ü& sÔ+ä'¨Ó,ˆÜØØ—)‘)×/Ñ/ØŸ™×-Ñ-×AÑAñ
ˆð
 '*§h¡h×&;Ñ&;×&HÑ&HÈÓ&U× Uˆ�‰Ôä! #Ô&ä0°·±×1JÑ1JÓKˆÞQ]œY×6Ò6¸|ÑLÑMÐcgÐä)DÀSÓ)\×#\Ð ØŸ™×4Ñ4°[ÓA×TÄ]Ã_ˆØ%3Ô"ô .Ø—(‘(—.‘.Ø—Y‘Y×.Ñ.©qÐ1Ø)Ø%=ñ	
ˆð $'§8¡8×#4Ñ#4ˆÔ Ø$-Ô!Ø$3Ô!Ø #§¡× 8Ñ 8× MÑ MÈkÓ k×kˆØ$3Ô!Ø×%Ñ%ˆØ"×+Ñ+ˆØ(×7Ñ7ˆØ#2×#KÑ#KÐ ö Ü¨°©Ð4˜9´i×6MÑ6M×NÑNØ—‘ ;Ó.ä×&Ò&Ð'oÓpÐpä#>Ð?WÓ#bÐ ð
 !  "˜ˆô
 œ3˜}Ó-°Ñ1°2°rÖ:ˆEÜ ]Ñ%9Ð9˜'¼9×;QÑ;Q×RÓRØ+2—‘Ô(Ø16—‘Ô.Ùñ	 ;ô ?¸}ÓM×iÐQT×QYÑQY×QiÑQiÐØÑ*Ü$Ð%8×:dÑ:dÔeð
 (5�	‰	×!Ñ!¡!Ð$ô
 	' sÔ+ä%=ØØ�I‰I×ÑØŸH™H×4Ñ4Ø"%§(¡(×"@Ñ"@ñ	&
ˆ�‰Ô"ö IW N×$6Ñ$6°|Ô$DÐ\`ˆ�	‰	Ô!Ø2J�	‰	Ô/Ø�‰×Ñ×2Ñ2°3·9±9·?±?ÔCà×,¨Ð.FÐR]Ð]Ð]òg !Vò $]ò lùs@   ‚B5P"Â7PÂ8A)P"Ä!PÄ"B<P"ÇPÇCP"Ê;EP"ÐP"ÐP"c              ƒ  ó6  #   • [        X!R                  R                  UR                  R                  S9  [	        U5      nU R
                  c   S5       eU R
                  nUR                  Ul         UR                  R                  R                  X4US9I S h  v•N nU R                  X5        [        U5      U l        U R                  $  N1! [        R                   a5  nU R                  X5        U R                  X5      I S h  v•N  s S nA$ S nAff = f7f)Nr:  z8last_request_context must be set before _finish_handling)r¹  r¿  )r%   r‘   r³   r›   re   rß  r¶  r?  r   Úafter_model_requestr>   r  r  r  rd   rÞ  )r¾   r  r¿  rP  r¹  r  s         rv   r  Ú!ModelRequestNode._finish_handlings  sø   é € ô
 	˜(¯9©9×+;Ñ+;ÈSÏYÉY×MfÑMfÒgä'¨Ó,ˆØ×(Ñ(Ñ4ÐpÐ6pÓpÐ4Ø×3Ñ3ˆØ%4×%CÑ%CˆÔ"ð	8Ø ŸX™X×5Ñ5×IÑIØÀxð Jð ÷ ˆHð 	×Ñ˜cÔ,ô % XÓ.ˆŒà�|‰|Ðñøô ×$Ñ$ó 	8à×!Ñ! #Ô0Ø×/Ñ/°Ó7×7Ð7Õ7ûð	8üsT   ‚A/DÁ2'C ÂCÂC Â-DÃC ÃDÃ!%DÄD	ÄDÄDÄDÄDÄDc              ƒ  óZ  #   • [        U[        5      (       a�  Un[        U[        R                  5      (       a  UR                  $ [        U[        R
                  5      (       a  UeUR                  R                  nUR                  (       d  UeUR                  X#US9I Sh  v•N $ U$  N7f)z³Resolve a wrap_model_request result, handling SkipModelRequest and errors.

Returns ModelResponse on success.
Raises ModelRetry if the result or on_model_request_error raises it.
rþ  N)
r�   rÍ   r>   r  r¿  r  r?  r   r  r  )r¾   r  rP  r¹  r  r  r   s          rv   r  Ú%ModelRequestNode._resolve_wrap_result�  s‘   é € ô �m¤Y×/Ñ/ØˆCÜ˜#œz×:Ñ:×;Ñ;Ø—|‘|Ð#Ü˜#œz×4Ñ4×5Ñ5Ø�	Ø!Ÿh™h×6Ñ6ˆOØ"×>×>Ø�	Ø(×?Ñ?ÀÐtwÐ?Ðx×xÐxØÐñ yùs   ‚B B+Â"B)Â#B+c                ó¼  • [        XR                  R                  U R                  R                  S9  [	        U5        [
        R                  " U R                  R                  UR                  5        U R                  R                  (       aª  U R                  R                  R                  U R                  R                  5        U R                  R                  R                  U R                  R                  SS9  U R                  R                  R                  UR                  R                  5        U R                  R                  R                  U5        g)z<Append a model response to history, updating usage tracking.r:  Fr¦  N)r%   r‘   r³   r›   rH   r=   r  rB   r?  rù   r©  r«  rV  rW  r�   rE  )r  r¿  s     rv   r  Ú!ModelRequestNode._append_response§  sÕ   € ô 	˜(¯9©9×+;Ñ+;ÈSÏYÉY×MfÑMfÒgÜ˜8Ô$Ü×'Ò'¨¯	©	¯©¸¿¹ÔHØ�8‰8× × Ø�H‰H×!Ñ!×.Ñ.¨s¯y©y¯©Ô?à�H‰H×!Ñ!×,Ñ,¨S¯Y©Y¯_©_ÐW\Ð,Ñ]ð �H‰H×!Ñ!×@Ñ@ÀÇÁ×A\ÑA\Ô]Ø�	‰	×!Ñ!×(Ñ(¨Õ2r    c              ƒ  ó
  #   • UR                   R                  UR                  R                  US9  [        R
                  " UR                  S9n[        [        [        4   " [        R                  " U/S95      nX@l        U$ 7f)zŒBuild a retry ModelRequestNode from a ModelRetry exception.

Increments the retry counter and creates a new request with a RetryPromptPart.
©r×   ri  r5  )r‘   rØ   r?  rÖ   rÇ   r^  rž   rc   r~   r7   rA  rÞ  )r¾   r  r×   ÚmÚ
retry_nodes        rv   r  Ú"ModelRequestNode._build_retry_nodeº  sj   é € ð 	�	‰	×&Ñ& s§x¡x×'BÑ'BÈ%Ð&ÑPÜ×%Ò%¨e¯m©mÑ<ˆÜ%¤e¬[Ð&8Ò9¼)×:PÒ:PÐXYÐWZÑ:[Ó\ˆ
Ø!ŒØÐùs   ‚BB)r  rÞ  rß  )r  rn  rÚ   úHCallToolsNode[DepsT, NodeRunEndT] | ModelRequestNode[DepsT, NodeRunEndT])r  ú:GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, T]]rÚ   z,AsyncGenerator[result.AgentStream[DepsT, T]])r  r}  r0  zmodels.StreamedResponser·  úmodels.ModelRequestParametersrÚ   zresult.AgentStream[DepsT, T])r  rn  rç  rÛ  rÚ   zytuple[models.Model, ModelSettings | None, models.ModelRequestParameters, list[_messages.ModelMessage], RunContext[DepsT]])r  rn  r¿  r   rÚ   r|  )
r  rn  rP  ro  r¹  r,   r  z#_messages.ModelResponse | ExceptionrÚ   r   )r  ú:GraphRunContext[GraphAgentState, GraphAgentDeps[Any, Any]]r¿  r   rÚ   rÛ   )r  rn  r×   zexceptions.ModelRetryrÚ   z$ModelRequestNode[DepsT, NodeRunEndT])rÝ   rÞ   rß   rà   rá   rå   r:  r7  r   rÞ  r  rß  rU  r   r‚   Ústaticmethodrí  râ  r  rF  r  r  r  r  r$   rq  rê   r°   r    rv   rc   rc   µ  s  ‡ áeà#Ó#Ø',Ð Ó,àÓà8<ÐÐ5Ó<ð]ñ `eØ˜¨ñ`€GÐ\ó ñ  5¨u¸eÑD€K�ÓDÙ7<À%ÈeÐ]aÑ7bÐÐ4Óbð-ØWð-à	Qô-ð ðZ=àGðZ=ð 
6óZ=ó ðZ=ðx ð
ØGð
à0ð
ð #@ð
ð 
&ó	
ó ð
ð&O@ØWðO@à	QôO@ðb_^àQð_^ð ð	_^ð

ô_^ðBv^àQðv^ð ð	v^ð

ôv^ðpàQðð *ðð 
Rô	ð8àQðð 'ðð -ð	ð
 ;ðð 
!ôð0 ð3ØGð3à)ð3ð 
ó3ó ð3ð$àQðð %ðð 
.ô	ð ,ƒHr    rc   c                  óª  • \ rS rSr% SrS\S'   SrS\S'   SrS\S	'    SrS
\S'    \	" SSSS9r
S\S'   \	" SSSS9rS\S'   \	" SSSS9rS\S'       S!S jr\    S"S j5       r    S#S jr    S#S jr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*S jr\rS rg)+rd   iÌ  zcThe node that processes a model response, and decides whether to end the run or make a new request.r   rÏ   Nz6dict[str, DeferredToolResult | Literal['skip']] | NonerY  z dict[str, dict[str, Any]] | NonerZ  rí   r)  F)ro   rÝ  r  z0AsyncIterator[_messages.AgentStreamEvent] | Noner  zRModelRequestNode[DepsT, NodeRunEndT] | End[result.FinalResult[NodeRunEndT]] | NoneÚ
_next_noderÜ   Ú_stream_errorc              ƒ  ór  #   • U R                  U5       IS h  v•N    S S S 5      IS h  v•N   U R                  b  U R                  $ U R                  b/  U R                  R                  U R                  R                  5      e[
        R                  " S5      e N€ Nq! , IS h  v•N  (       d  f       N†= f7f)Nz6the stream should set `self._next_node` before it ends)r‚   r‚  rƒ  Úwith_tracebackÚ__traceback__r>   rá  rã  s     rv   rU  ÚCallToolsNode.runä  s†   é € ð —;‘;˜s×#Õ#Ø÷ $×#à�?‰?Ñ&Ø—?‘?Ð"ð ×ÑÑ)Ø×$Ñ$×3Ñ3°D×4FÑ4F×4TÑ4TÓUÐUÜ×&Ò&Ð'_Ó`Ð`÷ $×#×#Ò#üsB   ‚B7˜B™B7œBžB7©BªA0B7ÂB7ÂB4Â#B&Â$B4Â0B7c               óè   #   • U R                  U5      n U7v •  U  Sh  v•N nM   N
 [        USS5      nUb  U" 5       I Sh  v•N    gg! [        USS5      nUb  U" 5       I Sh  v•N    f f = f7f)z]Process the model response and yield events for the start and end of each function tool call.NrÎ  )Ú_wrapped_streamÚgetattr)r¾   r  r‚   r   rÎ  s        rv   r‚   ÚCallToolsNode.streamò  s„   é € ð
 ×%Ñ% cÓ*ˆð	Ø‹Lñ !'÷ �fÙñ ô <CÀ6È8ÐUYÓ;ZˆFØÑ!Ù“h—’ð "øô <CÀ6È8ÐUYÓ;ZˆFØÑ!Ù“h—’ð "üsM   ‚A2•A œ) '¡)¤A §)©A ªA2ÁAÁA2ÁA/Á'A*Á(A/Á/A2c                ó  • U R                   cu  [        U5      n[        U[        U R	                  U5      UR
                  R                  5      5      n[        UR                  R                  R                  X#S95      U l         U R                   $ )a�  This node's events, wrapped in the capability chain exactly once.

`run()` enters `stream()` itself, so a caller that already streamed this node under
`agent.iter()` makes that the second entry. The wrapper has to be built once and reused:
rebuilding it would run every capability's `wrap_run_event_stream` again over an exhausted
stream, duplicating whatever setup or teardown it does outside its own iteration.
)r‚   )r  re   rK   r…   Ú_run_streamr‘   rƒ   Úaiterr?  r   Úwrap_run_event_stream)r¾   r  rP  Úinners       rv   r‰  ÚCallToolsNode._wrapped_stream  s~   € ð ×(Ñ(Ñ0Ü+¨CÓ0ˆKÜ)ØÔ6°t×7GÑ7GÈÓ7LÈcÏiÉi×NkÑNkÓlóˆEô -2Ø—‘×(Ñ(×>Ñ>¸{Ð>ÐYó-ˆDÔ)ð ×,Ñ,Ð,r    c               óÐ   ^ ^^#   • TR                   R                  mSUUU 4S jjn U" 5         S h  v•N nU7v •  M   N
 g ! [         a    e [         a  nUT l        e S nAff = f7f)Nc            	    óH  >#   • TR                   R                  S:X  a  [        R                  " S5      eTR                   R                  (       + n U (       + =(       a&    [        S TR                   R                   5       5      nU (       + =(       a4    U(       + =(       a&    [        S TR                   R                   5       5      nU (       d  U(       d  U(       Gaâ  TR                   R                  S:X  a7  [        R                  " STR                  R                  =(       d    S S35      eU (       d  U(       aä  TR                   R                  S	:X  aÊ  TR                   R                  =(       d    0 n[        R                  R                  TR                   /5      R                  5       nUR                  S
5      =n(       a  SU S3nO@UR                  S5      =n(       a  SU S3nO!UR                  S5      =n(       a  SU< 3nOSn[        R                  " XdS9eTR                   (       aŽ  [#        T5      n [$        R&                  " TR(                  R*                  UTTR(                  R,                  S9I S h  v•N n	TR/                  T[0        R2                  " [5        [6        U	5      5      / 5      Tl        g SnSn/ n/ nTR                   R                   GH†  n[I        U[        RJ                  5      (       a  X¿RL                  -  nM3  [I        U[        RN                  5      (       a  URQ                  U5        Me  [I        U[        RR                  5      (       a  URQ                  URL                  5        M¡  [I        U[        RT                  5      (       a  SnMÄ  [I        U[        RV                  5      (       a  Må  [I        U[        RX                  5      (       a  GM  [I        U[        RZ                  5      (       a%  URL                  (       a  XÏRL                  -  nGMH  GMK  [I        U[        R\                  5      (       a  X¿RL                  -  nGM{  [_        U5        GM‰     U(       d	  U(       a  Un / nU(       a@  TR(                  R`                  S:X  a  X¾4OS nTRc                  TUUS9  S h  v•N nU7v •  M  TRd                  (       a  URQ                  S5        OWTR(                  Rf                  Rh                  b%  TR(                  Rf                  Rh                  (       a  URQ                  S5        TRj                  (       aK  [m        S U 5       S 5      =n(       a   TRo                  TU5      I S h  v•N Tl        g URQ                  S5        TRp                  =n(       a:  U(       a!  TRs                  TUU5      I S h  v•N Tl        g URu                  SS5        [        Rv                  " SS Ry                  U5       S!3S"9n[;        U5      e GN˜! [:         as  n
TR                  R=                  TR(                  R>                  U
S9  [@        [B        [6        4   " [        RD                  " U
RF                  /S95      Tl         S n
A
g S n
A
ff = f GNä
 g  GN# NÙ! [:         as  n
TR                  R=                  TR(                  R>                  U
S9  [@        [B        [6        4   " [        RD                  " U
RF                  /S95      Tl         S n
A
g S n
A
ff = f7f)#Nr�   z‰Cannot handle a suspended model response as a completed turn. Resume it by running the agent with this message history and no new prompt.c              3  ó†   #   • U  H7  n[        U[        R                  5      =(       a    UR                  (       + v •  M9     g 7fr‡   )r�   rÇ   ÚTextPartrD  ©r~  Úps     rv   r€  ÚACallToolsNode._run_stream.<locals>._run_stream.<locals>.<genexpr>0  s/   é € ð 6ÚMfÈ”
˜1œi×0Ñ0Ó1×C¸!¿)¹)´mÔCÒMfùs   ‚?Ac              3  óÈ   #   • U  HX  n[        U[        R                  5      =(       d2    [        U[        R                  5      =(       a    UR                  (       + v •  MZ     g 7fr‡   )r�   rÇ   ÚThinkingPartr•  rD  r–  s     rv   r€  r˜  6  sH   é € ð â6˜ô ˜q¤)×"8Ñ"8Ó9×r¼jÈÌI×L^ÑL^Ó>_×>qÐhi×hqÑhqÔdqÔrÚ6ùs   ‚A A"rÃ   rÅ   rÆ   z­) exceeded before any response was generated. Increase the `max_tokens` model setting, or simplify the prompt to result in a shorter response that will fit within the limit.Úcontent_filterrÉ   z*Content filter triggered. Finish reason: 'Ú'Úblock_reasonz)Content filter triggered. Block reason: 'Úrefusalz#Content filter triggered. Refusal: zContent filter triggered.)Úbody©r   rP  Úschemarý   rx  r5  r¢   rl   ©Úresponse_outputz$include your response in a tool callzcall a toolc              3  óh   #   • U  H(  n[        U[        R                  5      (       d  M$  Uv •  M*     g 7fr‡   ©r�   rÇ   ÚBinaryImage©r~  Úfiles     rv   r€  r˜  ±  s"   é € Ð%h²u¨tÄ
È4ÔQZ×QfÑQf×@g§d¡d²uùrA  zreturn an imager   zreturn textzPlease z or Ú.ri  )=rÏ   r‘   r>   r£   rÊ   ÚallrÉ   rÕ   r·   Úprovider_detailsrÇ   ÚModelMessagesTypeAdapterÚ	dump_jsonÚdecodery   ÚContentFilterErrorÚallows_noneÚ_build_output_run_contextr;   Úrun_none_process_hooksr?  r   rý   Ú_handle_final_resultrA   ÚFinalResultr   r7   r‚  rM   rØ   rÖ   rc   r~   rA  Ú
tool_retryr�   r•  rD  rË   rE  ÚFilePartÚNativeToolCallPartÚNativeToolReturnPartrš  ÚCompactionPartÚ
SpeechPartr   rû   Ú_handle_tool_callsrs  r  rÔ  rš  rP  Ú_handle_image_responseÚtext_processorÚ_handle_text_responseÚinsertr^  rw  )Úis_emptyÚis_blank_text_onlyÚis_thinking_onlyÚdetailsrŸ  Úreasonrž   rž  rP  Úresult_datar  ÚtextÚcompaction_textrI  ÚfilesrQ  Úalternativesr£  r„   Úimager½  ry  r  rü   r¾   s                         €€€rv   r�  Ú.CallToolsNode._run_stream.<locals>._run_stream!  sã  øé € Ø×"Ñ"×(Ñ(¨KÓ7ô !×*Ò*ðbóð ð
  ×.Ñ.×4Ñ4Ô4ˆHð &.¤÷ "´#ñ 6ØMQ×M`ÑM`×MfÒMfó6ó 3Ðð ”÷ Ø*Ô*÷äñ à!×0Ñ0×6Ò6óó ð ö Ö-×1Að ×&Ñ&×4Ñ4¸Ó@Ü$×<Ò<Ø-¨c¯i©i×.GÑ.G×.]ÐK]Ð-^ð  _Lð  Móð ö
 Ö 2¸×8KÑ8K×8YÑ8YÐ]mÓ8mØ"×1Ñ1×BÑB×HÀb�GÜ$×=Ñ=×GÑGÈ×I\ÑI\ÐH]Ó^×eÑeÓg�Dà!(§¡¨_Ó!=Ð=�vÕ=Ø$NÈvÈhÐVWÐ"X™Ø#*§;¡;¨~Ó#>Ð>˜Õ>Ø$MÈfÈXÐUVÐ"W™Ø$+§K¡K°	Ó$:Ð:˜Õ:Ø$GÈÁ{Ð"S™à"=˜ä$×7Ò7¸ÑKÐKð !×,×,Ü";¸CÓ"@�KðÜ,3×,JÒ,JØ'*§x¡x×'?Ñ'?Ø(3Ø#0Ø.1¯h©h×.HÑ.Hñ	-÷ '˜ð +/×*CÑ*CØ¤×!3Ò!3´D¼ÀkÓ4RÓ!SÐUWó+˜œð ð ˆDØ ˆOØ79ˆJØ35ˆEà×+Ñ+×1Õ1�Ü˜d¤I×$6Ñ$6×7Ñ7ØŸL™LÑ(’DÜ ¤i×&<Ñ&<×=Ñ=Ø×%Ñ% dÖ+Ü ¤i×&8Ñ&8×9Ñ9Ø—L‘L §¡Ö.Ü ¤i×&BÑ&B×CÑCð ’DÜ ¤i×&DÑ&D×EÑEáÜ ¤i×&<Ñ&<×=Ñ=ÚÜ ¤i×&>Ñ&>×?Ñ?Ø—|—|Ø'¯<©<Ñ7›ò $ä ¤i×&:Ñ&:×;Ñ;ð
 ŸL™LÑ(“Dä  ×&ñ7 2ö> žOØ&�ð-uð +-�ÞØ7:·x±x×7LÑ7LÐPWÓ7W t¡mÐ]a�OØ'+×'>Ñ'>¸sÀJÐ`oÐ'>Ñ'p÷ $˜eØ#�à"×*×*Ø ×'Ñ'Ð(NÕOØ—X‘X×*Ñ*×0Ñ0Ñ8¸C¿H¹H×<QÑ<Q×<W×<Wð !×'Ñ'¨Ô6à ×-×-Ü $Ñ%h±uÓ%hÐjnÓ oÐo�uÕoØ04×0KÑ0KÈCÐQVÓ0W×*W˜œØØ ×'Ñ'Ð(9Ô:à%2×%AÑ%AÐA�>ÕAÞØ04×0JÑ0JÈ3ÐPTÐVdÓ0e×*e˜œØØ ×'Ñ'¨¨=Ô9ô
 ×-Ò-Ø% f§k¡k°,Ó&?Ð%@ÀÐBñ�ô % QÓ'Ð'òM'øô *ó ØŸ	™	×6Ñ6°s·x±x×7RÑ7RÐZ[Ð6Ñ\Ü*:¼5Ä+Ð;MÒ*NÜ%×2Ò2¸!¿,¹,¸ÑHó+˜Ÿ˜ð ûðúò@$Ð'pàò +Xñ +føô "ó uØ—	‘	×.Ñ.¨s¯x©x×/JÑ/JÐRSÐ.ÑTÜ"2´5¼+Ð3EÒ"FÄy×G]ÒG]Ðef×eqÑeqÐdrÑGsÓ"t�—‘ûðuüsÓ   ƒH7\"È;AX É=XÉ>>X Ê<F:\"Ñ79Z" Ò0ZÒ4ZÒ5ZÒ8CZ" Õ:ZÕ;	Z" Ö\"ÖAZ" ×Z ×	Z" ×\"×AZ" ØX Ø
ZØ"A)ZÚ\"ÚZÚ\"ÚZÚZ" Ú\"ÚZ" Ú Z" Ú"
\Ú,A)\Ü\"Ü\Ü\")rÚ   ú)AsyncIterator[_messages.AgentStreamEvent])r?  rü   r�   r‰   rƒ  )r¾   r  r�  r„   r  rü   s   ``   @rv   r�  ÚCallToolsNode._run_stream  sj   úé € ð Ÿ™×.Ñ.ˆ÷d	uñ d	uðL
	Ù*œ}÷ �eØ•ñ™}øäó 	ð Üó 	Ø!"ˆDÔØûð	üsF   …!A&§A ®A ²>³A ¶A ¾A Á A ÁA&ÁA#ÁAÁA#Á#A&r¢  c              ó8  ^^#   • [        T5        [        T5      n[        R                  " TR                  R
                  U R                  5      n[        [        [        U5      5      TR                  R                  -
  [        [        U5      5      TR                  R                  -
  S9n[        UTR                  R                  TR                  R                   R"                  US9nTR                  R                   R%                  U5      I S h  v•N TR                  l        TR                  R                   R&                  c   eUTR                  R                   R&                  l        S nUb7  [+        UU4S jU 5       5      (       a  Uu  p‰U R-                  TX‰S9I S h  v•N n/ n
[/        SS9n [1        TR                  R                   UU R2                  U R4                  UTU
US9  S h  v•N nU7v •  M   Në NZ N
 Oƒ! [6         av    TR                  R
                  R9                  [        R:                  " [=        U
5      TR                  R>                  TR                  R@                  [C        5       SS	95        e f = fU(       a  US
   nU RE                  TXz5      U l#        g U RH                  b/  U
R9                  [        RJ                  " U RH                  5      5        [L        [N        [P        4   " [        R:                  " U
S95      U l#        g 7f)N)r  r  )r8  r9  Ú_anchored_evidencec              3  ó¶   >#   • U  HN  nTR                   R                  R                  UR                  5      =mS L =(       d    TR                  S:H  v •  MP     g 7f)NÚfunction)r?  r  Úget_tool_defÚ	tool_namer}  )r~  Úcallr  r›  s     €€rv   r€  Ú3CallToolsNode._handle_tool_calls.<locals>.<genexpr>	  sQ   øé € ð /
â"�ð Ÿ™×.Ñ.×;Ñ;¸D¿N¹NÓKÐKˆXÐPTÐT×sÐX`×XeÑXeÐisÑXsÔsÚ"ùs   ƒAA)rÆ  rÈ  r8   )Úmaxlen)r  rI  rY  rZ  Úfinal_resultr  Úoutput_partsÚoutput_final_resultrŽ   )rÊ   r³   r›   rG  r‘   r   r5  ))rJ  re   rÇ   Ú$_post_compaction_window_for_responser‘   r�   rÏ   rI   Ú	frozensetr0   r?  r  rD   r  r   r¬   r  rG  rH  r  rÏ  rª  Ú_process_response_outputr   r"   rY  rZ  r‰   rE  rA  rã   r³   r›   r'   r³  r‚  r)  rC  rc   r~   r7   )r¾   r  rI  r£  rP  Úevidence_windowÚanchored_evidencer×  rÆ  rÈ  rØ  rÙ  r„   r›  s    `           @rv   r»  Ú CallToolsNode._handle_tool_callsÓ  s°  ùé € ô 	' sÔ+ä'¨Ó,ˆÜ#×HÒHØ�I‰I×%Ñ% t×':Ñ':ó
ˆô -Ü"+Ô,KÈOÓ,\Ó"]Ø�h‰h×,Ñ,ñ#-ä"+Ô,FÀÓ,WÓ"XØ�h‰h×,Ñ,ñ#-ñ
Ðô ØØ—)‘)×/Ñ/ØŸ™×-Ñ-×AÑAØ0ñ	
ˆð '*§h¡h×&;Ñ&;×&HÑ&HÈÓ&U× Uˆ�‰Ôð �x‰x×$Ñ$×(Ñ(Ñ4Ð4Ð4Ø7Hˆ�‰×Ñ×!Ñ!Ô4ð  @DˆØÑ&¬3õ /
á"ó/
÷ ,
ñ ,
ð *‰KˆDØ!%×!>Ñ!>¸sÈÐ!>Ð![×[ˆLà9;ˆÜFKÐSTÁoÐð"	ô  2Ø ŸX™X×2Ñ2Ø%Ø"&×"8Ñ"8Ø#'×#:Ñ#:Ø)ØØ)Ø$7ò	 ÷ 
�eð •ñg !Vñ@ \ñ
ñ 	 øô ó 	ð �I‰I×%Ñ%×,Ñ,Ü×&Ò&Ü˜|Ó,ØŸ9™9×+Ñ+Ø$'§I¡I×$=Ñ$=Ü%›iØ'ñôð ð'	úö* Ø.¨qÑ1ˆLØ"×7Ñ7¸¸\ÓXˆD�Oð ×ÑÑ+Ø×#Ñ#¤I×$<Ò$<¸T×=MÑ=MÓ$NÔOä.¬u´kÐ/AÒBÄ9×CYÒCYÐ`lÑCmÓnˆD�Oùsi   „DLÄG>ÄBLÆ%H Æ&LÆ68H Ç.HÇ2HÇ3HÇ6H Ç>LÈ LÈHÈH ÈLÈB JÊBLc             ƒ  ó�  #   • UR                   R                  n UR                  (       a3  [        S U 5       S5      =n(       a  U R	                  X5      I Sh  v•N $ UR
                  =n(       a@  [        U[        R                  5      (       a!  U(       a  U R                  XU5      I Sh  v•N $ g NX N! [         a     gf = f7f)u  Build the response's non-tool output result (an image, or schema-validated text), or `None`.

Used under `end_strategy='early'` to decide whether a response that also contains function tool calls
already carries a final result. Images take precedence over text, matching the order the no-tool-calls
path handles them in.

Only text that's validated against a schema can preempt tool calls â€” i.e. the object output processor
used by [`NativeOutput`][pydantic_ai.output.NativeOutput],
[`PromptedOutput`][pydantic_ai.output.PromptedOutput], and a bare structured type (auto mode). There
the model was told to produce the final output as its text, so text that validates is a deliberate
final result. Plain, unstructured text output (`str`, [`TextOutput`][pydantic_ai.output.TextOutput], or
a `str` fallback in a larger schema) accepts *any* text, so the model's preamble â€” which it emits with
no signal that we'd treat it as final â€” must not silently win and skip the tools.

Returns `None` when the response carries no usable output â€” e.g. schema-validated text or an image that
fails validation â€” so the caller runs the tool calls instead. Unlike a failed output *tool* call, this
doesn't consume an output retry or surface a retry prompt: running the tools is the correction.
c              3  óh   #   • U  H(  n[        U[        R                  5      (       d  M$  Uv •  M*     g 7fr‡   r¥  r§  s     rv   r€  Ú9CallToolsNode._process_response_output.<locals>.<genexpr>d	  s!   é € Ð!d²5¨4¼JÀtÌY×MbÑMb×<c§$¡$²5ùrA  N)r?  rü   rš  rP  Ú_process_image_responser½  r�   r;   ÚBaseObjectOutputProcessorÚ_process_text_responserM   )r¾   r  rÆ  rÈ  rü   rÊ  r½  s          rv   rÜ  Ú&CallToolsNode._process_response_outputH	  s°   é € ð2 Ÿ™×.Ñ.ˆð	Ø×)×)Ü Ñ!d±5Ó!dÐfjÓkÐk�5ÕkØ!%×!=Ñ!=¸cÓ!I×IÐIà#0×#?Ñ#?Ð?�Õ?Ü˜~¬w×/PÑ/P×QÑQÞà!×8Ñ8¸ÀNÓS×SÐSð ñ Jñ TøÜó 	Ùð	üsY   ‚Cš?B6 ÁB2ÁB6 ÁCÁAB6 Â,B4Â-B6 Â0CÂ2B6 Â4B6 Â6
CÃ CÃCÃCc              ƒ  ób   #   • U R                  XR                  XU5      I S h  v•N / 5      $  N	7fr‡   )r³  rå  )r¾   r  rÆ  r½  s       rv   r¾  Ú#CallToolsNode._handle_text_responsep	  s0   é € ð ×(Ñ(¨×4OÑ4OÐPSÐ[iÓ4j×.jÐlnÓoÐoÑ.jùs   ‚!/£-
¤
/c           	   ƒ  ó  #   • [        U5      nUR                  R                  n[        R                  " UUUUR                  R
                  UUR                  R                  S9I S h  v•N n[        R                  " U5      $  N7f)N)rÆ  rP  r   r¡  rý   )	r±  r?  rü   r;   Úrun_output_with_hooksr   rý   rA   r´  )r¾   r  rÆ  r½  rP  r¡  rÅ  s          rv   rå  Ú$CallToolsNode._process_text_responsex	  ss   é € ô 0°Ó4ˆØ—‘×'Ñ'ˆä#×9Ò9ØØØ#Ø—x‘x×/Ñ/ØØ!Ÿh™h×8Ñ8ñ
÷ 
ˆô ×!Ò! +Ó.Ð.ñ
ùs   ‚A&BÁ(BÁ)Bc              ƒ  ó`   #   • U R                  XR                  X5      I S h  v•N / 5      $  N	7fr‡   )r³  rã  )r¾   r  rÊ  s      rv   r¼  Ú$CallToolsNode._handle_image_responseŒ	  s-   é € ð
 ×(Ñ(¨×4PÑ4PÐQTÓ4\×.\Ð^`ÓaÐaÑ.\ùs   ‚ .¢,
£
.c              ƒ  ó  #   • [        U5      nUR                  R                  n[        R                  " UUR                  R
                  UUUR                  R                  S9I S h  v•N n[        R                  " U5      $  N7f)Nr   )	r±  r?  rü   r;   Úrun_image_process_hooksr   rý   rA   r´  )r¾   r  rÊ  rP  r¡  rÅ  s         rv   rã  Ú%CallToolsNode._process_image_response“	  sp   é € ô
 0°Ó4ˆØ—‘×'Ñ'ˆÜ#×;Ò;ØØ—x‘x×/Ñ/Ø#ØØ!Ÿh™h×8Ñ8ñ
÷ 
ˆô ×!Ò! +Ó.Ð.ñ
ùs   ‚A%BÁ'BÁ(Bc           	     óþ   • UR                   R                  nU(       aV  UR                  [        R                  " UUR                   R
                  UR                   R                  [        5       S95        [        U5      $ )N)rÊ   r³   r›   rG  )	r‘   r�   rE  rÇ   rA  r³   r›   r'   r3   )r¾   r  r×  Útool_responsesr?   s        rv   r³  Ú"CallToolsNode._handle_final_result¤	  sa   € ð —9‘9×,Ñ,ˆö Ø�O‰OÜ×&Ò&Ø(ØŸ9™9×+Ñ+Ø$'§I¡I×$=Ñ$=Ü%›iñ	ôô �<Ó Ð r    )r‚  rƒ  r  )r  rn  rÚ   úKModelRequestNode[DepsT, NodeRunEndT] | End[result.FinalResult[NodeRunEndT]])r  rn  rÚ   z9AsyncGenerator[AsyncIterator[_messages.AgentStreamEvent]])r  rn  rÚ   rÌ  )r  rn  rI  zlist[_messages.ToolCallPart]r£  z0tuple[str, list[_messages.BinaryContent]] | NonerÚ   rÌ  )r  rn  rÆ  r™   rÈ  zlist[_messages.BinaryContent]rÚ   z&result.FinalResult[NodeRunEndT] | None)r  rn  rÆ  r™   r½  ú(_output.BaseOutputProcessor[NodeRunEndT]rÚ   rô  )r  rn  rÆ  r™   r½  rõ  rÚ   úresult.FinalResult[NodeRunEndT])r  rn  rÊ  ú_messages.BinaryImagerÚ   rô  )r  rn  rÊ  r÷  rÚ   rö  )r  rn  r×  rö  rò  z list[_messages.ModelRequestPart]rÚ   ú$End[result.FinalResult[NodeRunEndT]])rÝ   rÞ   rß   rà   rá   rå   rY  rZ  r)  r   r  r‚  rƒ  rU  r   r‚   r‰  r�  r»  rÜ  r¾  rå  r¼  rã  r³  r$   rq  rê   r°   r    rv   rd   rd   Ì  s4  ‡ ámà+Ó+ØPTÐÐMÓTØ;?ÐÐ8Ó?ØDØ@D€KÐ=ÓDðñ RWØ˜5 uñRÐÐNó ñ fkØ˜5 uñf€JÐbó ñ +0¸À5ÈuÑ*U€MÐ'ÓUðaØWðaà	Tôað ðØWðà	Bóó ðð(-ØWð-à	2ô-ð(vØWðvà	2ôvðz MQñsoàQðsoð 1ðsoð
 Jðsoð 
3õsoðj&àQð&ð ð	&ð
 -ð&ð 
0ô&ðPpàQðpð ðpð Að	pð
 
Uôpð/àQð/ð ð/ð Að	/ð
 
)ô/ð(bàQðbð %ðbð 
Uô	bð/àQð/ð %ð/ð 
)ô	/ð"!àQð!ð 6ð!ð 9ð	!ð
 
.ô!ð, ,ƒHr    rd   c                  ó6   • \ rS rSr% SrS\S'       SS jrSrg)	ÚSetFinalResulti½	  z^A node that immediately ends the graph run after a streaming response produced a final result.rö  r×  c              ƒ  ó4   #   • [        U R                  5      $ 7fr‡   )r3   r×  rã  s     rv   rU  ÚSetFinalResult.runÃ	  s   é € ô �4×$Ñ$Ó%Ð%ùs   ‚r°   N)r  rn  rÚ   rø  )rÝ   rÞ   rß   rà   rá   rå   rU  rê   r°   r    rv   rú  rú  ½	  s    ‡ áhà1Ó1ð&ØWð&à	-÷&r    rú  c              ƒ  ó  #   • U R                   R                  nUb.  U R                   R                  U R                  R                  :X  a  g U R                   R
                  nUc   e[        R                  " UU R                   R                  U R                   R                  U R                  R                  [        U R                  R                  S S 5      U R                  R                  S9nU R                   R                  X5      I S h  v•N u  pEU R                   R                  U5      I S h  v•N   X@R                   l	        XPR                   l        U R                  R                  U R                   l        g  No NL7f)NrÂ   )r  r?  r’   r­   r?   rB   )r?  rô   rõ   r‘   r­   r  r@   ÚModelSelectionContextrì   r’   rã   r�   rB   rö   r÷   r  )r  Úselectorr  Úselection_ctxr’   r  s         rv   rH  rH  É	  s  é € Ø�x‰x×&Ñ&€HØÑ˜3Ÿ8™8×;Ñ;¸s¿y¹y×?QÑ?QÓQØà�H‰H�N‰N€EØÑÐÐÜ×0Ò0ØØ�X‰X×ÑØ�h‰h�n‰nØ—‘×#Ñ#ô �c—i‘i×/Ñ/°°Ð4Ó5Ø�i‰i�o‰oñ
€Mð  ŸH™H×<Ñ<¸XÓU×U�O€EØ
�(‰(×
Ñ
˜uÓ
%×%Ð%Ø‡H�H„NØ ‡H�HÔØ'*§y¡y×'9Ñ'9€C‡H�HÕ$ñ	 VÙ%ùs%   ‚DFÄE=Ä$FÄ2E?Ä3AFÅ?Fc                ó0  • [         [           " S 0 SU R                  R                  _SU R                  R                  _SU R                  R
                  _SU R                  R                  _SU R                  R                  _SU R                  R                  _SU R                  R                  _SU R                  R                  _S	S
_SU R                  R                  _SU R                  R                  S
L=(       a     U R                  R                  R                  _SU R                  R                  (       a   U R                  R                  R                  O[         _SU R                  R"                  _SU R                  R$                  _SU R                  R&                  _SU R                  R(                  _SU R                  R*                  _SU R                  R,                  _SU R                  R.                  _SU R                  R0                  _SU R                  R2                  _SU R                  R4                  _SU R                  R6                  _SU R                  R8                  _SU R                  R:                  _SU R                  R<                  _SU R                  R>                  _SU R                  R@                  _SU R                  RB                  _6n[E        U R                  RF                  U5      n[I        XS9nU$ )!zEBuild a `RunContext` object from the current agent graph run context.r?  r  r’   Ú	_model_idrB   rù   rî   r?   rÿ   Nr  Útrace_include_contentÚinstrumentation_versionr­   r³   r›   rµ   r  r   r  r  r  r¹   Ú_cancellationÚ_durable_operationsÚ_run_capabilities_by_idÚ_event_stream_bufferÚ_pending_immediate_dispatchesÚ_event_stream_replacementsÚ_mcp_tool_defs_cache)rÿ   r°   )%r[   r~   r?  rì   r  r’   r  r‘   rB   rù   rî   r�   r  r	  Úinclude_contentÚversionr   r­   r³   r›   rµ   r  r   r  r  r  r¹   r  r  r  rƒ   r  r  r»   Úbuild_validation_contextrÿ   r   )r  rP  rÿ   s      rv   re   re   â	  s¢  € äœUÒ#ò !Ø�X‰X×Òð!à�h‰h�nŠnð!ð �h‰h�nŠnð!ð —(‘(×#Ò#ð	!ð
 �i‰i�oŠoð!ð —X‘X×*Ò*ð!ð �x‰x�Šð!ð —‘×*Ò*ð!ñ  ð!ð �x‰x�Šð!ð "Ÿh™h×?Ñ?ÀtÐK÷ >Ø�H‰H×-Ñ-×=Ñ=øð!ð �8‰8×,×,ð !$§¡× AÑ A× IÒ Iä,øð!ð  —‘×#Ò#ð!!ð" �y‰y×Òð#!ð$ Ÿ	™	×1Ò1ð%!ð& —‘×#Ò#ð'!ð( —X‘X×*Ò*ð)!ð* Ÿ™×0Ò0ð+!ð, —X‘X×*Ò*ð-!ð. "Ÿh™h×<Ò<ð/!ð0 "Ÿh™h×<Ò<ð1!ð2 Ÿ™×3Ò3ð3!ð4 —h‘h×+Ò+ð5!ð6  ŸH™H×7Ò7ð7!ð8 !$§¡× ?Ò ?ð9!ð: !ŸY™Y×:Ò:ð;!ð< '*§h¡h×&KÒ&Kð=!ð> $'§8¡8×#EÒ#Eð?!ð@ !ŸY™Y×:Ò:ðA!€KôD 2°#·(±(×2MÑ2MÈ{Ó[Ðô ˜+ÑM€KØÐr    c           
     ó®   • [         R                  " U UR                  UR                  UR                  UR
                  UR                  UR                  S9$ )zOBuild a `RunCancelled` carrying a detached snapshot of the run's current state.)r?   rï   rB   rµ   r³   r›   )r>   ÚRunCancelledr�   rï   rB   rµ   r³   r›   )rž   r‘   r?  s      rv   Úrun_cancelled_snapshotr  
  sJ   € ô ×"Ò"ØØ×&Ñ&Ø×0Ñ0Ø�k‰kØ—‘Ø�|‰|Ø×-Ñ-ñð r    c                óŽ  • [        S U R                  R                  R                  5        5       5      (       d  g[	        U R
                  R                  U R                  R                  R                  5       5      nU R                  R                  R                  5         U R                  R                  R                  U5        g)zORefresh the history-derived loaded capability ids from the current graph state.c              3  ó<   #   • U  H  oR                   S L v •  M     g7f)TN)r”  )r~  r   s     rv   r€  Ú1_refresh_loaded_capability_ids.<locals>.<genexpr>)
  s   é € ÐaÒB`°J×'Ñ'¨4Õ/ÒB`ùs   ‚N)r‘  r?  r  ÚvaluesrF   r‘   r�   Úkeysr  Úclearr[  )r  r  s     rv   rI  rI  !
  s‰   € ô ÑaÀ#Ç(Á(×BWÑBW×B^ÑB^ÔB`Óa×aÑaØä<¸S¿Y¹Y×=VÑ=VÐX[×X`ÑX`×XmÑXm×XrÑXrÓXtÓuÐð ‡H�H×"Ñ"×(Ñ(Ô*Ø‡H�H×"Ñ"×)Ñ)Ð*?Õ@r    c                óÔ   • [        U R                  R                  5      nU R                  R                  R                  5         U R                  R                  R                  U5        g)zORefresh the history-derived discovered tool names from the current graph state.N)r1   r‘   r�   r?  r  r  r[  )r  r  s     rv   rJ  rJ  4
  sH   € ä2°3·9±9×3LÑ3LÓMÐð ‡H�H×"Ñ"×(Ñ(Ô*Ø‡H�H×"Ñ"×)Ñ)Ð*?Õ@r    c               ó²   • U Vs0 s H  oDR                   UR                  _M     nnX#-
  nU  Vs1 s H  owU;   d  M
  XW   U;  d  M  UiM     sn$ s  snf s  snf )ue  Drop reveals for tools this run doesn't define, and those whose owning capability isn't active yet.

History outlives configuration, so it can name a tool the current run has no definition for. Such
a name can't be revealed â€” there is no schema to show â€” and every consumer already guards on
membership in the definitions, so dropping it here changes nothing observable; what it buys is
that `revealed_tool_names` is a subset of `function_tools`' names by construction, and a future
consumer can't be caught out by an entry that resolves to nothing.

The ordering a run holds to is load, then reveal, then call: a capability's instructions and
hooks come as a bundle, and its tools should not reach the model ahead of the runbook for using
them. A reveal says a schema *may* be shown; it cannot stand in for the load.

Not a trust boundary, and not trying to be one. Any history the model could plausibly have
produced is honoured â€” fabricating a coherent `load_capability` exchange is equivalent to the
model having called it, and history integrity is the deployment's job. What is rejected is a
history no legitimate run could have produced: a capability tool revealed with no load behind it
describes a world that never existed, and honouring it would put the run in a state its own
rules forbid â€” including advertising a tool `ToolManager` will refuse to run.

Only *deferred* capabilities gate their tools this way. An always-on capability's search-gated
tool is revealed by discovery alone, which is why this needs `deferred_capability_ids` read from
the capability instances rather than a guess from the tool definitions.
)ÚnamerŸ  )Ú
discoveredr„  rƒ  r  r›  Úowner_by_nameÚinactive_capability_idsr  s           rv   r–  r–  =
  se   € ñ< LZÓZÊ>¸x—]‘] H×$:Ñ$:Ò:É>€MÐZð
 6ÑMÐÙ'ÓxšZ�T°=Ñ+@‹DÀ]ÑEXÐ`wÑEw�D™ZÑxÐxùò [ùò ys   … A¯	A¼AÁAc                óv   • [        U [        [        U5      U R                  U R                  [        U5      S9S9$ )u&  Make per-request reveal state match the history that will be sent to the model.

Gated on the same availability rule as the run-level state: a reveal naming a tool whose
deferred capability this history does not show as loaded is dropped, so the model is never
offered a tool it has not been properly given â€” and never one `ToolManager` would refuse to
run. An always-on capability's search-gated tools are unaffected: they carry no load marker by
design, and `deferred_capability_ids` is read from the capability instances, so they are not
in it.
r‚  )r…  )r   r–  r1   r„  rƒ  rE   )Ú
parametersr?   s     rv   rM  rM  d
  s>   € ô ØÜ0Ü" 8Ó,Ø×%Ñ%Ø$.×$FÑ$FÜ";¸HÓ"Eñ	
ñð r    c                ó€   • [        U 5      (       a-  [        [        [        [           /[
        4   U 5      nU" U5      $ U $ )zTBuild a Pydantic validation context, potentially from the current agent run context.)Úcallabler   r	   r[   r~   r   )Úvalidation_ctxrP  Úfns      rv   r  r  {
  s=   € ô
 �×ÑÜ”(œJ¤uÑ-Ð.´Ð3Ñ4°nÓEˆÙ�+‹ÐàÐr    c                ó   • U R                   R                  R                  b   U R                   R                  R                  O
[        U 5      n[	        UU R
                  R                  U R                   R                  S9$ )a¢  Build a RunContext with global output retry info for output validation.

Starts from `tool_manager.ctx` (when available) so per-tool retry counts
(`ctx.retries[name]`) populated by `for_run_step` propagate to output hooks
like `prepare_output_tools` and output validators. Then overrides `retry`
and `max_retries` with the **output** budget (`max_output_retries`),
distinct from the tool budget on `tool_manager.ctx`.
r;  )r?  r  r  re   r   r‘   r¬   rÖ   )r  rt  s     rv   r±  r±  ‡
  sa   € ð ),¯©×(=Ñ(=×(AÑ(AÑ(Mˆ3�8‰8× Ñ ×$Ò$ÔSdÐehÓSi€DÜØØ�i‰i×+Ñ+Ø—H‘H×/Ñ/ñð r    c                  ó.   • \ rS rSr% S\S'   SrS\S'   Srg)	Ú_RunMessagesiš
  rª   r?   FrÛ  r<  r°   N)rÝ   rÞ   rß   rà   rå   r<  rê   r°   r    rv   r&  r&  š
  s   ‡ à*Ó*Ø€Dˆ$Ör    r&  ÚvarzContextVar[_RunMessages]Ú_messages_ctx_varc               #  ó´   #   • / n [         R                  [        U 5      5      n U v •  [         R                  U5        g! [         R                  U5        f = f7f)aà  Context manager to access the messages used in a [`run`][pydantic_ai.agent.AbstractAgent.run], [`run_sync`][pydantic_ai.agent.AbstractAgent.run_sync], or [`run_stream`][pydantic_ai.agent.AbstractAgent.run_stream] call.

Useful when a run may raise an exception, see [model errors](../agent.md#model-errors) for more information.

Examples:
```python
from pydantic_ai import Agent, capture_run_messages

agent = Agent('test')

with capture_run_messages() as messages:
    try:
        result = agent.run_sync('foobar')
    except Exception:
        print(messages)
        raise
```

!!! note
    If you call `run`, `run_sync`, or `run_stream` more than once within a single `capture_run_messages` context,
    `messages` will represent the messages exchanged during the first call only.

    Contexts can be nested: each `capture_run_messages` context captures the runs for which it is the
    innermost active context. A run started inside a nested context is captured by that nested context,
    not by any enclosing one, so wrapping a nested agent run (e.g. inside a tool) in its own
    `capture_run_messages` lets you inspect that inner run's messages independently.

If a run is interrupted by an exception or cancellation while streaming a response or executing
tool calls, the partial [`ModelResponse`][pydantic_ai.messages.ModelResponse] or
[`ModelRequest`][pydantic_ai.messages.ModelRequest] is still captured here with
`state='interrupted'`, so consumers can detect and inspect partial state.
N)r(  rr   r&  rs   )r?   ru   s     rv   rf   rf   £
  sK   é € ðD .0€Hô ×!Ñ!¤,¨xÓ"8Ó9€Eð'ØŠä×Ñ Õ&øÔ×Ñ Õ&üs   ‚!A¤> ¨A¾AÁAc                 ó*   • [         R                  5       $ r‡   )r(  ry   r°   r    rv   r;  r;  Ï
  s   € Ü× Ñ Ó"Ð"r    c                ó`  • [        U =(       d    S[        [        [        [        4   [
        [        [        4   [        R                  [           SS9nUR                  UR                  UR                  5      R                  [
        [        [        4   5      UR                  [
        [        [        4   5      UR                  [        [        [        4   5      UR                  [        [        [        4   5      UR                  [        [        [        4   5      5        UR!                  SS9$ )zDBuild the execution [Graph][pydantic_graph.Graph] for a given agent.r^   F)r  Ú
state_typeÚ	deps_typeÚ
input_typeÚoutput_typeÚauto_instrument)Úvalidate_graph_structure)r5   r`   ra   r~   r   rb   rA   r´  ÚaddÚ	edge_fromÚ
start_nodeÚtor  rc   rd   rú  Úbuild)r  r-  r/  Úgs       rv   Úbuild_agent_graphr8  Ó
  sÞ   € ô 	Ø�_�WÜ"Ü ¤¬ Ñ0Ü!¤%¬ .Ñ1Ü×&Ñ&¤wÑ/Øñ	€Að ‡E�EØ	�‰�A—L‘LÓ!×$Ñ$¤^´E¼7°NÑ%CÓDØ	�‰Œ~œe¤W˜nÑ-Ó.Ø	�‰Ô¤¤w Ñ/Ó0Ø	�‰Œ}œU¤G˜^Ñ,Ó-Ø	�‰Üœ5¤'˜>Ñ*ó	
ôð �7‰7¨Eˆ7Ð2Ð2r    c                ó  • UR                    Vs0 s H,  o"R                  (       d  M  UR                  UR                  _M.     nnU(       d  U $ Sn/ nU R                   H�  n[	        U[
        R                  5      (       a]  UR                  cP  UR                  UR                  5      =nb2  [
        R                  R                  XgS9nUR                  U5        SnM  UR                  U5        M’     U(       a	  [        XS9$ U $ s  snf )u1  Promote each base `ToolCallPart` in the response to its typed subclass via `ToolDefinition.tool_kind`.

Lives here rather than in each model adapter so adapter authors emit base
`ToolCallPart`s freely and the framework owns the typed-identity translation. Streaming
parts are typed up-front by `ModelResponsePartsManager` via the same lookup; this
function handles the non-streaming `Model.request()` return path. Either path produces
the same typed end state â€” `isinstance(part, ToolSearchCallPart)` is true from the
moment the call is emitted by the model.
F)Ú	tool_kindTr5  )r„  r:  r  rÊ   r�   rÇ   rË   ry   rÓ  Únarrow_typerE  r   )	r¿  r·  ÚtdÚtool_kind_by_nameÚchangedÚ	new_partsrQ  r:  Úpromoteds	            rv   r¸  r¸  ó
  sê   € ð )A×(OÒ(Oó<Ú(O "×S_ÕS_Óˆ�‰�—‘ÒÑ(Oð ð <ö Øˆà€GØ35€IØ—”ˆä�tœY×3Ñ3×4Ñ4Ø—‘Ñ&Ø/×3Ñ3°D·N±NÓCÐC�ÑPä ×-Ñ-×9Ñ9¸$Ð9ÐTˆHØ×Ñ˜XÔ&ØŠGà×Ñ˜TÖ"ñ ö 29Œ7�8Ñ-ÐF¸hÐFùò'<s
   �D§Dc                óh   • [        U 5       H  u  p#UR                  U:X  d  M  Us  $    [        U 5      $ )z^Return the index of the first message for the current run, or len(messages) if none are found.)Ú	enumerater³   r¥   )r?   r³   rm  rž   s       rv   r¤   r¤     s0   € ä# HÖ-‰ˆØ�>‰>˜VÕ#ØŠLñ .ô ˆx‹=Ðr    c               ó  • UbY  [        U 5       H  u  pEXRL d  M  US-   s  $    [        [        U 5      S-
  SS5       H  n[        X   U5      (       d  M  US-   s  $    Ub  SUs=::  a  [        U 5      :  a   US-   $   [	        X5      $ )uZ  Return the first index that should be included in `new_messages()`.

When resuming from `message_history` without a new user prompt, the trailing
`ModelRequest` is prior context even though the framework stamps it with the current
`run_id` for adapter bookkeeping, so it must be excluded. A capability or history processor
can mutate the message list before this runs, so the resumed request is located by trying
progressively looser fallbacks, each robust to a different kind of mutation:

1. Object identity (`is`) â€” survives reordering, insertion, and removal of *other* messages.
2. Value match (`_is_same_request`) â€” survives loss of identity (e.g. a deep-copying
   processor) as long as the request's fields are unchanged.
3. Position (`resumed_request_index`, pinned while preparing the request) â€” survives an
   in-place rebuild that changes the request's fields (e.g. system-prompt reinjection),
   which defeats both matches above.

Falling back to the first message carrying the current `run_id` is the last resort. Note the
layers cover different *single* mutations: a rebuild that also shifts the request's position
by adding/removing messages after it on the same step defeats all three, and detection falls
back to `run_id` (which includes the resumed request); this is rarer than any layer's own
blind spot and no built-in capability triggers it.
r8   rÂ   r   )rB  rk  r¥   Ú_is_same_requestr¤   )r?   r³   rñ   rò   rm  rž   s         rv   r  r    s™   € ð8 Ñ"Ü'¨Ö1‰NˆEØÔ)Ø˜q‘yÒ ñ 2ô œ3˜x›=¨1Ñ,¨b°"Ö5ˆEÜ ¡°×AÓAØ˜q‘yÒ ñ 6ð Ñ(¨QÐ2GÕ-WÌ#ÈhË-Ô-WØ$ qÑ(Ð(ð .Xô ˜xÓ0Ð0r    c                ó>  • [        U [        R                  5      (       d  gXL a  gU R                  UR                  :H  =(       aY    U R                  UR                  :H  =(       a9    U R
                  UR
                  :H  =(       a    U R                  UR                  :H  $ )NFT)r�   rÇ   rA  rÊ   rG  r-  rµ   )rž   r6  s     rv   rD  rD  H  s…   € Ü�gœy×5Ñ5×6Ñ6ØØÒØð 	�‰˜Ÿ™Ñ&÷ 	1Ø×Ñ ×!2Ñ!2Ñ2÷	1à× Ñ  G×$8Ñ$8Ñ8÷	1ð ×Ñ × 0Ñ 0Ñ0ð	r    Ú#pydantic_ai_synthesized_tool_returnc                óÌ  • 0 n0 n[        U 5       GH  u  p4[        U[        R                  5      (       aŽ  UR                   H|  n[        U[        R
                  5      (       d  M$  UR                  UR                  5      =n(       a'  UR                  US   / 5      R                  US   5        X54XR                  '   M~     M³  [        U[        R                  5      (       d  MÔ  UR                   H1  n[        U5      (       d  M  UR                  UR                  S5        M3     GM     UR                  5        H&  u  pxUR                  U/ 5      R                  U5        M(     U$ )u4  Find tool calls that will never receive a result, keyed by the index of their response.

Matching is an ordered walk: a tool result (`_is_tool_result_part` â€” a `ToolReturnPart` or
*tool-bound* `RetryPromptPart`; plain validation feedback doesn't answer a call even if its
`tool_call_id` collides) only answers a call that is open (produced by an earlier response and
not already answered) at that point. An out-of-place result â€” one preceding its call, a
duplicate, or one reusing the ID of an already-answered call â€” doesn't mask a genuinely
dangling call.
r   r8   N)rB  r�   rÇ   rÈ   rÊ   rË   ry   r_  Ú
setdefaultrE  rA  Ú_is_tool_result_partr�   r  )	r?   Ú
open_callsÚdangling_by_responserm  rž   rQ  ÚshadowedÚresponse_indexrÔ  s	            rv   Ú _dangling_tool_calls_by_responserN  [  s#  € ð AC€JØDFÐÜ# H×-‰ˆÜ�gœy×6Ñ6×7Ñ7ØŸœ�Ü˜d¤I×$:Ñ$:×;Ó;Ø#-§>¡>°$×2CÑ2CÓ#DÐD�xÕDð -×7Ñ7¸À¹ÀRÓH×OÑOÐPXÐYZÑP[Ô\Ø5:°M�J×0Ñ0Ó1ó &ô ˜¤×!7Ñ!7×8Ó8ØŸœ�Ü'¨×-Ó-Ø—N‘N 4×#4Ñ#4°dÖ;ô &ñ .ð !+× 1Ñ 1Ö 3ÑˆØ×'Ñ'¨¸Ó;×BÑBÀ4ÖHñ !4àÐr    c                óÆ   ^ • [        U 4S j[        [        T R                  5      S-
  SS5       5       S5      n[	        T / T R                  SU QUQT R                  US QS9$ )uú   Insert synthesized returns after the request's existing tool results (if any).

They go ahead of user-facing parts â€” including a plain (non-tool-bound) `RetryPromptPart`,
which renders as user text â€” matching where providers expect tool results.
c              3  ól   >#   • U  H)  n[        TR                  U   5      (       d  M"  US -   v •  M+     g7f)r8   N)rI  rÊ   )r~  Ú
part_indexr6  s     €rv   r€  Ú._insert_synthesized_returns.<locals>.<genexpr>‚  s/   øé € ð 	
âC�
Ü# G§M¡M°*Ñ$=×>ó ˆJ˜ŽNÚCùs   ƒ!4¨4r8   rÂ   r   Nr5  )rP  rk  r¥   rÊ   r   )r6  ÚsynthesizedÚ	insert_ats   `  rv   Ú_insert_synthesized_returnsrU  y  so   ø€ ô ô	
ä#¤C¨¯©Ó$6¸Ñ$:¸BÀÔCó	
ð
 	
ó€Iô �7Ð"h G§M¡M°*°9Ð$=Ð"hÀÐ"hÈgÏmÉmÐ\eÐ\fÐNgÐ"hÑiÐir    c                ó¢   • [        U [        R                  5      =(       d/    [        U [        R                  5      =(       a    U R                  SL$ )aö  Whether a part is a regular (locally-executed) tool result answering a `ToolCallPart`.

A `RetryPromptPart` with no `tool_name` is validation feedback rendered as a plain user message,
not a tool result, so it doesn't need (or have) a matching tool call. `NativeToolReturnPart` (a
sibling `BaseToolReturnPart` subclass) is intentionally excluded: native/builtin results are
co-located with their call in one `ModelResponse` and shaped by each model's own serializer, so
the pipeline leaves them alone.
N)r�   rÇ   r]  r^  rÓ  )rQ  s    rv   rI  rI  Œ  s<   € ô �dœI×4Ñ4Ó5÷ Ü�4œ×2Ñ2Ó3×R¸¿¹ÈdÐ8Rðr    c                óœ  • [        5       n/ nSn[        U 5       GH  u  pEUR                   H?  n[        U[        R
                  5      (       d  M$  UR                  UR                  5        MA     UR                   Vs/ s H'  n[        U5      (       a  UR                  U;  a  M%  UPM)     nn[        U5      [        UR                  5      :X  a  UR                  U5        MÈ  SnU(       d6  [        U[        R                  5      (       d  Mò  U[        U 5      S-
  :X  d  GM  UR                  [        XWS95        GM"     U(       a  U$ U $ s  snf )a  REMOVE regular tool results whose call is missing.

A `ToolReturnPart` or tool-bound `RetryPromptPart` (in a `ModelRequest`) whose `tool_call_id`
never appeared as a regular `ToolCallPart` in any preceding `ModelResponse` is "orphaned".
Providers reject a tool result without a matching tool call (Anthropic rejects a `tool_result`
with no `tool_use`; OpenAI Responses raises `No tool call found for function call output`).
Orphans arise from context eviction dropping the response that made the call, from a result
placed before its call in a hand-built history, or from adapter round-trips.

This operates only on regular, locally-executed tool call/result pairing across message
boundaries. Native/builtin parts (`NativeToolCallPart`/`NativeToolReturnPart`) are left untouched:
they're produced and resulted by the provider inline and shaped by each model's own serializer,
and a native result can even arrive in a *later* response (e.g. Anthropic tool search), so the
core pipeline must not treat them as droppable.

Removal, not reordering: a result that precedes its call could in principle be moved after it,
but that crosses message boundaries and reorders content, so the fundamentally-invalid result is
dropped instead (its now-unanswered call is later synthesized a result by
`_repair_dangling_tool_calls`). If dropping empties an interior `ModelRequest` the request is
dropped; if it empties the last message an empty `ModelRequest` is kept so the history still ends
on a request. Returns the input unchanged when there are no orphans.
FTr8   r5  )rr   rB  rÊ   r�   rÇ   rË   r2  r_  rI  r¥   rE  rA  r   )r?   Úseen_call_idsÚrepairedr>  rm  rž   rQ  Ú
kept_partss           rv   Ú_drop_orphaned_tool_resultsr[  œ  s  € ô. "›e€MØ-/€HØ€GÜ# H×-‰ˆØ—M”MˆDÜ˜$¤	× 6Ñ 6×7Ó7Ø×!Ñ! $×"3Ñ"3Ö4ñ "ð
  Ÿšó
â%�Ü(¨×.Ñ.°4×3DÑ3DÈMÑ3Y÷ Ù%ð 	ð 
ô
 ˆz‹?œc '§-¡-Ó0Ó0Ø�O‰O˜GÔ$ÙØˆÞœ* W¬i×.DÑ.D×EÓEÈ%ÔSVÐW_ÓS`ÐcdÑSdÖJdØ�O‰OœG GÑ>×?ñ .ö  ˆ8Ð, HÐ,ùò
s   Á=$E	Â%E	Fr3  c               óŠ  ^ • [        T 5      nU(       dB  [        U 4S j[        [        T 5      S-
  SS5       5       S5      nUb  UR	                  US5        U(       d  T $ / n/ n[        T 5       GH&  u  pg[        U[        R                  5      (       aº  U(       a%  UR                  [        R                  " US95        / nUR                  U5      =n(       ac  U H]  n	UR                  [        R                  " U	R                  [        R                  U	R                  [         S0UR"                  SS95        M_     UR                  U5        Mß  [        U[        R                  5      (       d  GM  U(       a  [%        Xu5      n/ nUR                  U5        GM)     U(       a#  UR                  [        R                  " US95        U$ )	uÿ  Repair tool calls that are missing a matching result ("dangling" tool calls).

A run that was cancelled or crashed mid-tool-execution â€” or a hand-built history â€” can contain
`ToolCallPart`s with no matching `ToolReturnPart`/`RetryPromptPart` in a later `ModelRequest`.
Providers reject histories with dangling tool calls, so before a request is sent, every dangling
tool call gets a synthesized `ToolReturnPart` â€” marked with `SYNTHESIZED_TOOL_RETURN_METADATA_KEY`
in its `metadata` â€” inserted after the existing tool returns of the immediately following
`ModelRequest`, or as a new `ModelRequest` when no request follows.

This includes a call whose args string was cut off mid-stream (unparsable JSON): the call is
kept verbatim and closed out like any other dangling call, never removed. Malformed args are
already sendable â€” serializers degrade them gracefully (see `ToolCallPart.args_as_dict` and
`ToolCallPart.args_as_json_str`), as the tool-call retry flow relies on â€” and removing the call
would disturb the response's shape, e.g. leaving a thinking-only response whose signature was
computed over a turn that included the call.

The last `ModelResponse` is only repaired when `repair_last_response` is set: its tool calls
are the live frontier that run resumption and `deferred_tool_results` may still answer, and a
trailing unparsable-args call is left for local args validation to turn into a retry prompt.

Matching is an ordered walk: a result only answers a call that is open (produced by an earlier
response and not already answered) at that point. An out-of-place result â€” one preceding its
call, a duplicate, or one reusing the ID of an already-answered call â€” doesn't mask a genuinely
dangling call; such orphaned results themselves are not repaired.

The repair is deterministic and idempotent: synthesized parts derive their timestamp from the
response they repair and contain no wall-clock or random data, so repairing the same history
twice (or on every run) yields the same output and never churns provider prompt-cache prefixes.
If there is nothing to repair, the input list is returned unchanged. Repair is silent â€” like
the other pipeline passes â€” with the `SYNTHESIZED_TOOL_RETURN_METADATA_KEY` marker as the
mechanism for inspecting what was synthesized.
c              3  óp   >#   • U  H+  n[        TU   [        R                  5      (       d  M'  Uv •  M-     g 7fr‡   )r�   rÇ   rÈ   )r~  rm  r?   s     €rv   r€  Ú._repair_dangling_tool_calls.<locals>.<genexpr>ï  s.   øé € ð â=�EÜ˜h u™o¬y×/FÑ/F×G÷ ‘Ú=ùs   ƒ&6­	6r8   rÂ   Nr5  TrŽ   )rÓ  rD  r_  rµ   rG  Úoutcome)rN  rP  rk  r¥   r�   rB  r�   rÇ   rÈ   rE  rA  ry   r]  rÓ  ÚINTERRUPTED_TOOL_RETURN_CONTENTr_  Ú$SYNTHESIZED_TOOL_RETURN_METADATA_KEYrG  rU  )
r?   r4  rK  Úlast_response_indexrY  rS  rm  rž   ÚdanglingrÔ  s
   `         rv   rB  rB  É  s|  ø€ ôF <¸HÓEÐÞÜ"ôä"¤3 x£=°1Ñ#4°b¸"Ô=óð
 ó
Ðð Ñ*Ø ×$Ñ$Ð%8¸$Ô?ÞØˆà-/€HØ24€KÜ# H×-‰ˆÜ�gœy×6Ñ6×7Ñ7Þð —‘¤	× 6Ò 6¸[Ñ IÔJØ �à/×3Ñ3°EÓ:Ð:ˆxÕ:Û$�DØ×&Ñ&Ü!×0Ò0Ø&*§n¡nÜ$-×$MÑ$MØ)-×):Ñ):Ü&JÈDÐ%QØ&-×&7Ñ&7Ø$1ñö	ñ %ð �O‰O˜GÖ$Ü˜¤×!7Ñ!7×8Ô8ÞÜ5°gÓK�Ø �Ø�O‰O˜G×$ñ3 .ö6 Ø�‰œ	×.Ò.°[ÑAÔBà€Or    c                ó€  • / nU  GH´  n[        U5      S:”  a  US   OSn[        U[        R                  5      (       Gaª  U(       GaŽ  [        U[        R                  5      (       Gan  UR                  (       a,  UR                  (       a  UR                  UR                  :X  Ga1  / UR
                  QUR
                  QnUR                  [        R                  S9  SnUR                  =(       d    0 R                  [        5      nUR                  =(       d    0 R                  [        5      n[        U5      (       d  [        U5      (       a0  [        0 [        U5      (       a  UO0 E[        U5      (       a  UO0 E0n[        R                  " UUR                  =(       d    UR                  UR                  =(       d    UR                  US9nX�S'   GMÐ  UR                  U5        GMä  [        U[        R                  5      (       d  GM  U(       a–  [        U[        R                  5      (       aw  UR                  cj  UR                   c]  UR"                  cP  UR                  cC  UR                   c6  UR"                  c)  [%        U/ UR
                  QUR
                  QS9nX�S'   GM£  UR                  U5        GM·     U$ )uü  Normalize the history's shape by merging consecutive same-role messages into one.

Neither adds nor removes content â€” it only combines adjacent `ModelRequest`s (or adjacent
synthetic `ModelResponse`s) that providers expect as a single turn, and within a merged request
hoists tool results ahead of user-facing parts (where providers require them). Runs last, after
the repair passes have settled call/result pairing, so it operates on a valid history and never
separates a result from the call it answers.
r   rÂ   N)ra  )rÊ   r-  rG  rµ   r5  )r¥   r�   rÇ   rA  r-  rÊ   ÚsortÚ_tool_results_first_sort_keyrµ   ry   rQ  r&   rG  rE  rÈ   r´  rE  rC  r   )	r?   Úclean_messagesrž   rN  rÊ   rµ   Úlast_namespaceÚ	namespaceÚmerged_messages	            rv   Ú_merge_consecutive_messagesrk    sB  € ð 46€NÜˆÜ-0°Ó-@À1Ó-D�~ bÒ)È$ˆä�gœy×5Ñ5×6Ò6çÜ˜|¬Y×-CÑ-C×DÒDð %×1×1Ø"×/×/Ø#×0Ñ0°G×4HÑ4HÔHð >˜,×,Ñ,Ð=¨w¯}©}Ð=�Ø—
‘
œy×EÑE�
ÑFØ26�Ø".×"7Ñ"7×"=¸2×!BÑ!BÔC\Ó!]�Ø$×-Ñ-×3°×8Ñ8Ô9RÓS�	Ü˜~×.Ñ.´+¸i×2HÑ2Hä1ð 4Ü1<¸^×1LÑ1L™~ÐRTð4ä,7¸	×,BÑ,B™yÈð4ð �Hô "+×!7Ò!7ØØ!-×!:Ñ!:×!R¸g×>RÑ>RØ%×/Ñ/×I°<×3IÑ3IØ%ñ	"�ð &4˜rÔ"à×%Ñ% g×.Ü˜¤×!8Ñ!8×9Ô9æÜ˜|¬Y×-DÑ-D×EÑEà ×5Ñ5Ñ=Ø ×.Ñ.Ñ6Ø ×+Ñ+Ñ3Ø×0Ñ0Ñ8Ø×)Ñ)Ñ1Ø×&Ñ&Ñ.ä!(¨Ð=b¸|×?QÑ?QÐ=bÐT[×TaÑTaÐ=bÑ!c�Ø%3˜rÔ"à×%Ñ% g×.ño ðp Ðr    c               óD   • [        U 5      n [        XS9n [        U 5      n U $ )u�  Make the message history provider-valid and normalize its shape, out of the box.

An ordered pipeline of pure `list[ModelMessage] -> list[ModelMessage]` passes over regular,
locally-executed tool call/result pairing across message boundaries. Following the principle
"massage the history however we can to make the model API accept it, and drop only what's
fundamentally unsendable", each pass ADDs (synthesizes) or REMOVEs content, never silently
dropping anything a provider could accept. Native/builtin parts are left entirely untouched:
they're produced and resulted by the provider inline and shaped by each model's own serializer
(which handles their own dangling/empty-id cases), and a native result can even arrive in a
later response, so the core pipeline must not touch them. Ordering matters:

1. `_drop_orphaned_tool_results` (REMOVE) â€” first, so an orphaned result can't survive into the
   merge (which would hoist it to the front of a request) and so dropping it can expose a call
   that then needs a synthesized result in pass 2.
2. `_repair_dangling_tool_calls` (ADD synthesized results) â€” the matching-graph repair; runs
   before the merge changes message boundaries. Frontier-gated by `repair_last_response` so
   the last response's still-answerable calls are left alone.
3. `_merge_consecutive_messages` (normalize) â€” last, once call/result pairing is valid, so it
   never separates a result from its call.
r3  )r[  rB  rk  )r?   r4  s     rv   r>  r>  c  s'   € ô. +¨8Ó4€HÜ*¨8Ñ_€HÜ*¨8Ó4€HØ€Or    )rt   ÚAgentGraphSleepFuncrÚ   zGenerator[None])r|   ÚfloatrÚ   rÛ   )r‚   rÌ  rƒ   rº   rÚ   rÌ  )rŠ   z	Task[Any]rÚ   rÛ   )r’   ró   r“   r‰   r”   r   rÚ   z_messages.ModelResponseState)rœ   r  r�   z'Sequence[_messages.ModelMessage] | NonerÚ   r™   )r  zeBaseNode[GraphAgentState, GraphAgentDeps[T, Any], result.FinalResult[S]] | End[result.FinalResult[S]]rÚ   zTypeGuard[AgentNode[T, S]])r  zAgentNode[T, S]r  z6GraphRunContext[GraphAgentState, GraphAgentDeps[T, S]]rÚ   rÛ   )r’   ró   rÚ   rÛ   )r  rn  rP  ro  rÚ   ú&list[_messages.InstructionPart] | None)r6  rÚ  rT  ro  rÚ   rÛ   )r  rn  rT  ro  rÚ   r~  )r?   rª   rÚ   zCtuple[list[_messages.ModelMessage], _messages.ModelResponse | None])rP  úRunContext[Any]r¬  z_usage.RequestUsagerÚ   rÛ   )r’   ró   rP  rp  r±  rÜ  rÚ   rÛ   )
r’   ró   r¹  r,   rP  rp  rº  z)Callable[[_messages.ModelResponse], None]rÚ   r   )r’   ró   r¹  r,   rP  rp  rÚ   z'AsyncGenerator[models.StreamedResponse])r  r  rÚ   rÛ   )r  ú<GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, Any]]rÚ   rÛ   )r  rq  rÚ   ro  )rž   r™   r‘   r`   r?  zGraphAgentDeps[Any, Any]rÚ   zexceptions.RunCancelled)
r  zIterable[str]r„  zIterable[ToolDefinition]rƒ  r  r  r  rÚ   r  )r  r~  r?   rª   rÚ   r~  )r"  rþ   rP  ro  rÚ   r   )rÚ   z'Generator[list[_messages.ModelMessage]])rÚ   r&  )r  r  r-  ztype[DepsT]r/  zOutputSpec[OutputT]rÚ   zsGraph[GraphAgentState, GraphAgentDeps[DepsT, OutputT], UserPromptNode[DepsT, OutputT], result.FinalResult[OutputT]])r¿  r   r·  r~  rÚ   r   )r?   z Sequence[_messages.ModelMessage]r³   r™   rÚ   r«   )
r?   rª   r³   r™   rñ   rð   rò   r¶   rÚ   r«   )rž   z_messages.ModelMessager6  rÚ  rÚ   rÛ  )r?   rª   rÚ   z'dict[int, list[_messages.ToolCallPart]])r6  rÚ  rS  zlist[_messages.ToolReturnPart]rÚ   rÚ  )rQ  z8_messages.ModelRequestPart | _messages.ModelResponsePartrÚ   z?TypeGuard[_messages.ToolReturnPart | _messages.RetryPromptPart])r?   rª   rÚ   rª   )r?   rª   r4  rÛ  rÚ   rª   )ËÚ
__future__r   Ú_annotationsrz   râ   r�  rê  r   Úcollectionsr   Úcollections.abcr   r   r   r	   r
   r   r   Ú
contextlibr   r   Úcontextvarsr   Úcopyr   r   r   Útypingr   r   r   r   r   r   Úopentelemetry.tracer   Útyping_extensionsr   r   Úpydantic_ai._history_processorr   Úpydantic_ai._instrumentationr   r   r   rj  r    rl  r!   Úpydantic_ai._tool_executionr"   Úpydantic_ai._utilsr#   r$   r%   r&   r'   Úpydantic_ai._uuidr(   Ú!pydantic_ai.capabilities.abstractr)   r*   Úpydantic_ai.modelsr+   r,   Úpydantic_ai.native_toolsr-   Ú%pydantic_ai.native_tools._tool_searchr.   Úpydantic_ai.tool_managerr/   Ú!pydantic_ai.toolsets._tool_searchr0   r1   Úpydantic_graphr2   r3   r4   r5   r6   Úpydantic_graph.basenoder7   r¢   r9   r:   r;   r<   r=   r>   r?   rÇ   r@   rA   rB   ræ   Ú_cancelrC   Ú_deferred_capabilitiesrD   rE   rF   Ú_genai_pricesrG   rH   Ú_run_contextrI   rJ   rK   rL   rM   Úmodels._continuationrN   rO   rP   rQ   rR   rS   rT   rz  rU   rV   ÚsettingsrW   rÔ  rX   rY   rZ   r[   r\   Ú toolsets._instruction_collectionr]   r  r^   Úmodels.instrumentedr_   Ú__all__ri   rj   r$  ÚNoneTyperQ  rú   rn  rm  rp   rå   rw   r}   r~   r   r…   r‹   r•   r—   rg   rh   Ú	dataclassr`   ra   r´  r  r  r"  r'  rb   rJ  rx  r¡  r¤  r®  r²  rÄ  rÐ  rØ  rc   rd   rú  rH  re   r  rI  rJ  r–  rM  r  r±  r&  r(  rf   r;  r8  r¸  r¤   r  rD  ra  rN  rU  rI  r[  rB  rk  r>  r°   r    rv   Ú<module>r”     sï  ðÞ 2ã Û Û Û Ý Ý ß m× mÑ mß :Ý "Ý ß &ß H× Hå &ß 3å ;÷õ õ ;ß vÕ vÝ #ß O÷õ 8Ý @Ý 0÷÷ OÕ NÝ /÷÷ ÷ õ %÷ñ ÷
 Aß mÓ mÝ &÷
÷ ñ ÷ ,Ý #÷õ õ KæÝÝ<ð€ñ ˆCƒL€ÙˆCƒL€Ù�‹:€Ø-Ð ØÐ7Ñ8€ððB  ˜w¨	°$©Ð7Ñ8Ð Ø =á=GØ#Øñ>Ð Ð:ó ð ó(ó ð(ô6#ñ 	�Ó€Ù
�)Ó
€ð)Ø5ð)à9ð)ð /ô)ô$ðØðàðð %ðð "ô	ð. $)Ð �.Ó (ðRðØðà<ðð 	ôð6Øðà<ðð 	ôðD ×Ó˜tÑ$÷RIð RIó %ðRIðj ×Ó˜tÑ$ôb�W˜U KÐ/Ñ0ó bó %ðbôJ�˜¨.¸À¸Ñ*DÀf×FXÒFXÐYdÑFeÐeÑfô ð'Ø
oð'àô'ð Ø
ðà	?ðð 
ôô2
ð ×Òôo,�Y˜u kÐ1Ñ2ó o,ó ðo,ðdØ	Mðà"ðð ,ôð(QØ#ðQØ8^ðQà	ôQð NØ	MðNà=ðNð #ôNð|Ø*ðàHôô ]ð*ØðØ&5ðØ=[ðà	ôðA"ØðA"ð )ðA"ð !ð	A"ð
 ;ðA"ð ôA"ðH ð:Øð:ð )ð:ð !ð	:ð
 -ó:ó ð:ôzð2 ×ÒôS,�y ¨Ð!3Ñ4ó S,ó ðS,ðl ×Òôm,�I˜e [Ð0Ñ1ó m,ó ðm,ð` ×Òô&�Y˜u kÐ1Ñ2ó &ó ð&ô:ô2-ð`ØðØ(ðØ0HðàôôAô&Að$yØð$yà,ð$yð &ð	$yð
 $ð$yð ô$yðNØ-ðØ9Uðà"ôð.	Ø<ð	à"ð	ð 	ô	ðØ	Eðàôð& ×Ò÷ð ó ðñ
 /9¸Ó.?Ð Ð+Ó ?ð ó('ó ð('ôV#ð3Ø
ð3àð3ð %ð3ðô	3ð@GØ%ðGØA^ðGàôGôDð(1Ø*ð(1àð(1ð 3ð	(1ð
 &ð(1ð 	ô(1ôVð (MÐ $Ø nô ð<jØ#ðjØ2Pðjàôjð&Ø
BðàDôô *-ð\ MRñRØ*ðRØEIðRà!õRôjBðL MRñØ*ðØEIðà!ör    