ó
    °"³j¢ ã                  óh  • S SK Jr  S SKrS SKrS SKrS SKJr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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&  S SK'J(r(  SSK)J*r*J+r+J,r-J.r.  SSK/J0r0  SSK+J1r1J2r2  SSK3J4r4J5r5J6r6J7r7J8r8  \(       a  SSK9J:r:J;r;  \" S5      r<\" S5      r=      S3S jr>Sr?Sr@SrASrBSrCSrDSrE      S4S jrF        S5S jrGS6S  jrHSS!.       S7S" jjrI\R”                   " S# S$\\(   5      5       rK\L\-Rš                  \-Rœ                  -  \-Rž                  -     rP\K\(   \Q\P\R\\-R¦                     -  S-  4   -  \+R¨                  -  \+Rª                  -  rVSS%.       S8S& jjrW      S9S' jrXS:S( jrYSS).                 S;S* jjrZ\R”                   " S+ S,\\<\(4   \5      5       r[\R”                   " S- S.\[\<\(4   5      5       r\\R”                   " S/ S0\[\<\(4   5      5       r]\R”                   " S1 S2\[\<\(4   5      5       r^g)<é    )ÚannotationsN)ÚABCÚabstractmethod)ÚdefaultdictÚdeque)ÚAsyncIteratorÚ	AwaitableÚCallableÚ	CoroutineÚIteratorÚSequence)Údeepcopy)ÚTYPE_CHECKINGÚAnyÚGenericÚLiteralÚcast)ÚTypeVarÚassert_never)ÚEventStreamBuffer)Úcancel_and_drain)ÚToolManagerÚValidatedToolCall)ÚGraphRunContext)ÚNodeRunEndTé   )Ú_outputÚ
exceptionsÚmessagesÚresult)ÚLoadCapabilityCallPart)ÚToolFailedErrorÚToolRetryError)ÚDeferredToolRequestsÚDeferredToolResultÚToolApprovedÚ
ToolDeniedÚToolKind)ÚGraphAgentDepsÚGraphAgentStateÚDepsTÚTaskResultTc               óÊ  #   • [        U[        5      (       dL  U (       aD  [        R                  " U [        R                  S9I Sh  v•N u  p U H  nU7v •  M
     U (       a  MD  gUR
                  n[        R                  " 5       nUR                  U5         U (       aþ  U(       a  UR                  S5      7v •  U(       a  M  UR                  5         [        R                  " UR                  5       5      n [        R                  " 1 U kUi[        R                  S9I Sh  v•N u  p'UR                  5         UR                  U5        U Vs1 s H  o3ULd  M	  UiM     n nU(       a  UR                  S5      7v •  U(       a  M  U H  nU7v •  M
     U (       a  Mþ  UR                  U5        g GNi N�! UR                  5         f = fs  snf ! UR                  U5        f = f7f)an  Yield tasks as they complete, interleaving run events buffered while waiting.

Buffered events (e.g. `ctx.emit` from a running tool) are yielded as soon as they land,
so stream consumers see a progress event while the emitting tool is still running instead of
at the tool's completion. Events buffered before a task completion is yielded come first, so
an event emitted inside a tool body always precedes that tool's result event.

A buffer that can't signal appends (a plain list revived from graph-state persistence) degrades
to plain completion-order waiting, with buffered events surfacing at stream position instead.
)Úreturn_whenNr   )Ú
isinstancer   ÚasyncioÚwaitÚFIRST_COMPLETEDÚwaitersÚEventÚappendÚpopÚclearÚensure_futureÚcancelÚdiscardÚremove)ÚpendingÚevent_stream_bufferÚdoneÚtaskr3   ÚsignalÚsignal_waitÚnot_dones           ÚX/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/_tool_execution.pyÚ_iter_completed_or_bufferedrD       s€  é € ô Ð)Ô+<×=Ñ=ÞÜ")§,¢,¨wÄG×D[ÑD[Ñ"\×\‰MˆDÛ�Ø•
ñ ÷ ˆgð 	à!×)Ñ)€GÜ�]Š]‹_€FØ‡N�N�6ÔðÞÞ%Ø)×-Ñ-¨aÓ0Ó0÷ &Ð%ð �L‰LŒNô .5×-BÒ-BÀ6Ç;Á;Ã=Ó-QˆKð%Ü'.§|¢|Ð4K°gÐ4K¸{Ð4KÔY`×YpÑYpÑ'q×!q‘�à×"Ñ"Ô$Ø�L‰L˜Ô%Ù(0ÓLª ÀÐ4K—t©ˆGÐLÞ%Ø)×-Ñ-¨aÓ0Ó0÷ &Ð%ã�Ø•
ñ ÷' ˆgð, 	�‰�vÕò? ]ñ* "røà×"Ñ"Õ$üâLøð 	�‰�vÕüsx   ‚AG#ÁF.ÁG#Á#3G#Â)G Ã4G Ã7*F3 Ä!F1Ä"F3 Ä(%G ÅGÅGÅ$G ÆG ÆG#Æ1F3 Æ3GÇG ÇG Ç G#zFinal result processed.zTOutput not used as the final result - addressing tool retries from this round first.z<Output tool not used - a final result was already processed.zSOutput tool processed, but its value will not be the final result of the agent run.z8Output tool not used - output function execution failed.z0Output tool not used - output failed validation.z9Tool not executed - a final result was already processed.c                ó^   • [         R                  " U R                  SU 3U R                  SS9$ )u–  The failed return that isolates a sub-agent's self-cancellation from the calling run.

A sub-agent run awaited inside a tool cancelled *itself* (`cancel()` on its own context).
`cancel()` cancels the run it belongs to, not the caller â€” and a `RunCancelled` seen inside a
tool body is always a nested run's, since the calling run's own cancellation arrives as
`CancelledError` and only becomes `RunCancelled` at the run's outer edge. So the caller isolates
it: a failed tool return its model can react to, rather than tearing the whole run (or realtime
session) down. A delegate tool that *wants* the caller cancelled too can catch `RunCancelled`
and call `ctx.cancel()` itself; whole-tree cancellation is spelled with a shared
`CancellationToken`. Shared by the graph path (`_call_tool`) and
`realtime._session._unsettled_call_return` so the two can't drift. See
https://github.com/pydantic/pydantic-ai/issues/7199.
z!The sub-agent run was cancelled: Úfailed©Ú	tool_nameÚcontentÚtool_call_idÚoutcome©Ú	_messagesÚToolReturnPartrH   rJ   )ÚcallÚerrors     rC   Úcancelled_sub_agent_returnrQ   ^   s4   € ô  ×#Ò#Ø—.‘.Ø3°E°7Ð;Ø×&Ñ&Øñ	ð ó    c               óò  • [        U [        5      (       a8  [        R                  " UR                  U R
                  UR                  SS9SS4$ [        U [        R                  5      (       a"  [        [        R                  [           U 5      nO�[        U [        5      (       aQ  [        S [        [        [           U 5       5       5      (       a%  [        R                  " SUR                  < S35      e[        R                  [           " [        [        U 5      S9nUR                  nUbW  [        U[        5      (       d,  [        U[         5      (       a  [        S U 5       5      (       a  [        R                  " S	5      e[        R                  " UR                  UR                  UR"                  UR$                  US
9n[        R                  R'                  U5      UR(                  =(       d    SU4$ )a$  Translate a settled function-tool result into normalized history, optional user content, and tool reveals.

The third element is the validated [`ToolReturn.tools`][pydantic_ai.messages.ToolReturn.tools] request;
the caller decides how (or whether) those tools can be revealed on its surface.
ÚdeniedrG   Nc              3  óV   #   • U  H  n[        U[        R                  5      v •  M!     g 7f©N)r/   rM   Ú
ToolReturn)Ú.0Úitems     rC   Ú	<genexpr>Ú)build_tool_return_part.<locals>.<genexpr>�   s$   é € ð /Ú;W°4Œ
�4œ×-Ñ-×.Ð.Ò;Wùs   ‚')zThe return value of tool zT contains invalid nested `ToolReturn` objects. `ToolReturn` should be used directly.)Úreturn_valuec              3  óL   #   • U  H  n[        U[        5      (       + v •  M     g 7frV   )r/   Ústr)rX   Únames     rC   rZ   r[   ›   s"   é € ÐHuÒotÐgkÌZÐX\Ô^aÓMb×IbÑIbÒotùs   ‚"$z�`ToolReturn.tools` must be a list of tool names; pass a list of strings instead of a bare string, non-sequence value, or non-string elements.)rH   rJ   rI   ÚmetadataÚ	tool_kind)r/   r'   rM   rN   rH   ÚmessagerJ   rW   r   r   ÚlistÚanyr   Ú	UserErrorÚtoolsr^   r   r\   r`   Únarrow_typerI   )Útool_resultrO   ra   Útool_returnrf   Úreturn_parts         rC   Úbuild_tool_return_partrk   v   s«  € ô �+œz×*Ñ*ä×$Ò$ØŸ.™.Ø#×+Ñ+Ø!×.Ñ.Ø ñ	ð Øð	
ð 		
ô �+œy×3Ñ3×4Ñ4Üœ9×/Ñ/´Ñ4°kÓB‰Ü	�K¤×	&Ñ	&¬3ñ /Ü;?ÄÄSÁ	È;Ô;Wó/÷ ,ñ ,ô ×"Ò"Ø'¨¯©Ñ'9ð :4ð 5ó
ð 	
ô
  ×*Ñ*¬3Ò/¼TÄ#À{Ó=SÑTˆà×Ñ€EØÑÜ�5œ#×Ñ¤j°¼×&AÑ&AÄSÑHuÑotÓHu×EuÑEuä×"Ò"ðBó
ð 	
ô
 ×*Ò*Ø—.‘.Ø×&Ñ&Ø×(Ñ(Ø×%Ñ%Øñ€Kô ×#Ñ#×/Ñ/°Ó<¸k×>QÑ>Q×>YÐUYÐ[`Ð`Ð`rR   c                óÜ   • [        5       n/ nU  HY  nUR                  U;   a+  UR                  U;  a  UR                  UR                  5        UR                  UR                  5        M[     U$ )zaReturn duplicate `tool_call_id` values, in the order each ID is first encountered as a duplicate.)ÚsetrJ   r5   Úadd)ÚcallsÚseenÚ
duplicatesrO   s       rC   Ú_duplicate_tool_call_idsrr   ¬   sa   € ä“U€DØ€JÛˆØ×Ñ Ó$¨×):Ñ):À*Ó)LØ×Ñ˜d×/Ñ/Ô0Ø�‰�×"Ñ"Ö#ñ ð ÐrR   ©Ú
args_validc             #  óh   #   • [         R                  " XS9v •  [         R                  " U5      v •  g7f)zPYield `OutputToolCallEvent` and `OutputToolResultEvent` for an output tool call.rs   N)rM   ÚOutputToolCallEventÚOutputToolResultEvent)rO   Úpartrt   s      rC   Ú_emit_output_tool_eventsry   ·   s)   é € ô ×
'Ò
'¨Ñ
DÒDÜ
×
)Ò
)¨$Ó
/Ó/ùs   ‚02c                  ó\   • \ rS rSr% SrS\S'   SrS\S'   SrS\S	'   SrS
\S'   Sr	S\S'   Sr
g)Ú_OutputCallResultéÂ   u‡  Result of validating and executing one output tool call.

Exactly one of `final_result` (success), `retry_part` (validation/execution retry),
or `raise_exc` (max retries exceeded â€” re-raised by the caller only if no other output
produced a valid result) is set. `args_valid` carries the validation outcome for event
emission and to distinguish validation failures from execution failures.
ú_messages.ToolCallPartrO   Núbool | Nonert   ú&result.FinalResult[NodeRunEndT] | NoneÚfinal_resultz _messages.RetryPromptPart | NoneÚ
retry_partzBaseException | NoneÚ	raise_exc© )Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__Ú__annotations__rt   r€   r�   r‚   Ú__static_attributes__rƒ   rR   rC   r{   r{   Â   s:   ‡ ñð !Ó Ø"€J�Ó"Ø;?€LÐ8Ó?Ø37€JÐ0Ó7Ø&*€IÐ#Ö*rR   r{   ©Úactivating_capability_idc               ó*  • UR                   nU  H�  nUR                  =(       d    0 R                  U5      nUc  M,  UR                  R                  =nc  MG  Uc  ML  Xb:w  d  MS  XcR
                  ;  d  Md  [        R                  " SU< SU< S35      e   g)ue  Reject `ToolReturn.tools` names owned by a capability that hasn't been loaded.

A capability-owned tool must be revealed by loading its capability: `load_capability`
activates the whole bundle â€” instructions, hooks, model settings â€” while a bare name
reveal would surface the tool with its capability's hooks skipped. `load_capability` passes for
the capability it is *activating* â€” named by `activating_capability_id`, so it stays subject to
the same rule for every other capability's tools and cannot smuggle one through. That is what
lets the loader stop marking the capability loaded mid-step to get past a guard aimed at user
tools.

Gated on *availability*, not loadedness: an always-on capability is never
`load_capability`-ed, so testing `loaded_capability_ids` rejected its own search-gated tool
with an error naming a load the developer cannot perform.
Nz!`ToolReturn.tools` cannot reveal z: it belongs to capability z], which must be loaded with `load_capability` so its instructions and hooks activate with it.)Úctxrf   ÚgetÚtool_defÚcapability_idÚactive_capability_idsr   re   )rf   Útool_managerrŒ   Úrun_ctxr_   Útoolset_toolr‘   s          rC   Ú#_reject_unloaded_capability_revealsr–   ß   s–   € ð" ×Ñ€GÛˆØ$×*Ñ*×0¨b×5Ñ5°dÓ;ˆàÓ$Ø".×"7Ñ"7×"EÑ"EÐE�ÓRØÓ#ØÕ9Ø×%BÑ%BÕBä×&Ò&Ø3°D±8Ð;VØ Ñ#ð $;ð;óð ò rR   c                ól  • [        U 5       H   nX   n[        U5       HŠ  u  pE[        U[        R                  5      (       d  M&  UR
                   Vs/ s H  ofU;  d  M
  UPM     nnU(       a7  UR                  U5        XuR
                  :w  a  [        R                  " XWS9X4'   OX4	   Mž     M¢     gs  snf )u*  Keep only the first emitted-history reveal of each tool name across a step's tool calls.

Tool calls execute concurrently and author their availability deltas at completion time, so
deduplicating there would tie the emitted history to task scheduling: parallel siblings that
reveal the same name would race for the delta. Prune at assembly instead, in model call
(index) order â€” the first call to name a tool in history owns its reveal, later duplicates
are dropped, and already-discovered names from earlier steps are removed the same way.
`discovered_tool_names` is updated here so the durable set always matches the emitted deltas
deterministically. Must run exactly once per executor pass: it is not idempotent (a second
pass would see every name as already discovered and drop the deltas it just kept).
)Útools_addedN)	ÚsortedÚ	enumerater/   rM   ÚToolAvailabilityDeltaPartr˜   ÚupdateÚdataclassesÚreplace)Úparts_by_indexÚdiscovered_tool_namesÚindexÚpartsÚirx   r_   Únewly_discovereds           rC   Ú_prune_duplicate_tool_revealsr¥     s¡   € ô ˜Ö'ˆØÑ%ˆÜ  Ö'‰GˆAÜ˜$¤	× CÑ C×DÓDØ59×5EÒ5EÓ#kÒ5E¨TÐUjÑIj§DÑ5EÐ Ð#kÞ#Ø)×0Ñ0Ð1AÔBØ'×+;Ñ+;Ó;Ü#.×#6Ò#6°tÑ#Z˜™øà˜Úó (ò (ùò $ls   Á	B1ÁB1c               óè   • / n/ nU  HO  nU" U5      (       a.  U(       a  UR                  U5        / nUR                  U/5        M>  UR                  U5        MQ     U(       a  UR                  U5        U$ )a   Split `indices` into execution segments around barrier tools.

Each barrier index becomes a single-element segment; consecutive non-barrier indices form a
parallel segment. Segments run in order, so a barrier completes before later tools start and
starts only after earlier tools finish.
)r5   )ÚindicesÚ
is_barrierÚsegmentsÚcurrentr£   s        rC   Ú_segment_by_barriersr«     se   € ð !#€HØ€GÛˆÙ�a�=‰=ÞØ—‘ Ô(Ø�Ø�O‰O˜Q˜CÖ à�N‰N˜1Öñ ö Ø�‰˜Ô Ø€OrR   )Úoutput_final_resultc          
    ól  #   • Uc	  [        SS9nUR                  R                  nUS:X  a  [        n	O%US:X  a  [        n	OUS:X  a  [
        n	O[        U5        W	" U UUUUUUS9n
U
R                  5         Sh  v•N nU7v •  M   N
 U
R                  (       a  UR                  U
R                  5        gg7f)uÓ  Process a model response's tool calls, honoring the `end_strategy`.

Output and function tools are classified by kind and executed per strategy:

- `'early'`: output tools run sequentially in emission order and stop at the first
  success; function tools run **only if every output tool failed** (so the model can
  correct on the next round). Once an output succeeds, all function tools are stubbed
  as not executed.
- `'graceful'` (default): tools run in the order the model emitted them â€” function
  tools that precede an output tool complete before it runs. Output tools run
  sequentially and stop at the first success; subsequent output tools are skipped
  (their side effects don't run). Function tools run in parallel within each segment.
- `'exhaustive'`: every tool runs in parallel; the first valid output by emission order
  becomes the final result while the rest still execute. Only `sequential=True` tools
  (function or, via `ToolOutput(sequential=True)`, output) act as barriers.

A `sequential=True` tool is a barrier: tools emitted before it complete first, it runs
alone, and tools emitted after it start only once it finishes. The run-scoped
`parallel_execution_mode('sequential')` turns every tool into its own barrier.

Under `'graceful'`/`'exhaustive'`, the **retry-wins** invariant applies: if any
function/unknown tool produces a `RetryPromptPart`, `final_result` is suppressed so the
model addresses the retries on the next round. Output-tool retries don't trigger this
("first valid output wins"). Retry-wins doesn't apply when `final_result` was passed in
by `Agent.run_stream` (the streamed output is already committed) or under `'early'`
(function tools never run alongside a successful output).

Deferred tools (`external`, `unapproved`) without supplied results are collected during
the walk and resolved as a single batch at the end of the step.

Because async iterators can't have return values, we use `output_parts` and
`output_final_result` as output arguments.
Nr   )ÚmaxlenÚ
exhaustiveÚearlyÚgraceful)r“   Ú
tool_callsÚtool_call_resultsÚtool_call_metadatarŽ   Úoutput_partsr€   )
r   ÚdepsÚend_strategyÚ_ExhaustiveProcessorÚ_EarlyProcessorÚ_GracefulProcessorr   Úrunr€   r5   )r“   r²   r³   r´   r€   rŽ   rµ   r¬   r·   Úprocessor_classÚ	processorÚevents               rC   Úprocess_tool_callsr¿   3  sµ   é € ðX Ñ"Ü#¨1™oÐØ—8‘8×(Ñ(€LØ�|Ó#ÜH\‰Ø	˜Ó	 Ü)‰Ø	˜Ó	#Ü,‰ä�\Ô"ÙØ!ØØ+Ø-ØØ!Ø!ñ€Ið !—}‘}”÷ ˆeØ�ñ�à××Ø×"Ñ" 9×#9Ñ#9Õ:ð ùs*   ‚A1B4Á3BÁ7BÁ8BÁ;B4ÂBÂ/B4c                  óô  • \ rS rSr% SrS\S'   S\S'   S\S'   S	\S
'   S\S'   S\S'   S\S'   \R                  " SS9rS\S'   \R                  " SS9r	S\S'   \R                  " SS9r
S\S'   \R                  " SS9rS\S'   \R                  " SS9rS\S'   \R                  " SS9rS\S'   \R                  " SS9rS\S'   \R                  " SS9rS \S!'   \R                  " SSS"9rS \S#'   \R                  " S$SS"9rS%\S&'   \R                  " S'SS"9rS(\S)'   \R                  " SS9rS*\S+'   \R                  " SS9rS,\S-'   SFS. jrSGS/ jrSGS0 jrSGS1 jrSHS2 jr\SHS3 j5       rSIS4 jr        SJS5 jrSKS6 jrSLS7 jrSMS8 jr       SNS9 jr!      SOS: jr"        SPS; jr#    SQS< jr$      SRS= jr%            SSS> jr&            STS? jr'SUS@ jr(SFSA jr)SHSB jr*SHSC jr+SHSD jr,SEr-g')VÚ_ToolCallProcessoriy  at  Executes one model response's tool calls for a single step, honoring the `end_strategy`.

Holds the step's inputs plus the mutable result state (`final_result`, `retry_wins_triggered`)
that the per-strategy methods build up. `output_parts` is appended to in place so partially
completed work survives an exception (partial capture in `CallToolsNode._handle_tool_calls`).

Each `end_strategy` is a concrete subclass (`_EarlyProcessor`, `_GracefulProcessor`,
`_ExhaustiveProcessor`) that implements `_run_strategy`; everything else (classification,
output/function-tool execution, retry-wins, deferred resolution) is shared here.
úToolManager[DepsT]r“   úlist[_messages.ToolCallPart]r²   ú6dict[str, DeferredToolResult | Literal['skip']] | Noner³   ú dict[str, dict[str, Any]] | Noner´   úDGraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, NodeRunEndT]]rŽ   ú list[_messages.ModelRequestPart]rµ   r   r€   F)Úinitz#list[ToolKind | Literal['unknown']]Ú
call_kindszAdict[ToolKind | Literal['unknown'], list[_messages.ToolCallPart]]Útool_calls_by_kindúdict[str, DeferredToolResult]Úcalls_to_run_resultsz)tuple[ToolKind | Literal['unknown'], ...]Úexecutable_function_kindsú	list[int]Úfunction_indicesÚoutput_indicesz!_output.OutputSchema[NodeRunEndT]ÚschemaÚboolÚfinal_result_was_set_externally)ÚdefaultrÈ   Úretry_wins_triggeredr   ÚintÚoutput_retries_incrementNz_messages.ToolReturnPart | NoneÚwinning_output_partúEdict[Literal['external', 'unapproved'], list[_messages.ToolCallPart]]Údeferred_callsúdict[str, dict[str, Any]]Údeferred_metadatac                óÖ  • U R                   S LU l        [        [        5      U l        0 U l        [        [        5      n/ nU R                   Ha  nU R                  R                  UR                  5      nU(       a  UR                  OSnUR                  U5        X   R                  U5        Mc     X l        Xl        U R                  Gb6  SU l        [!        U R                  USS9 VVs/ s H  u  p5XPR                  ;   d  M  UPM     nnn[#        U5      =n(       a  [$        R&                  " SU 35      e[)        U R                  R+                  5       5      nU Vs1 s H  o3R,                  iM     n	nU R                   Vs1 s H  o3R,                  iM     n
nX˜s=::  a  U
::  d  O  [$        R&                  " SU	 SU 35      eU R                  R/                  5        VVs0 s H  u  p¼US:w  d  M  X¼_M     snnU l        OS	U l        0 U l        [3        [5        U R                  5      5       Vs/ s H  oÐR7                  U5      (       d  M  UPM     snU l        [3        [5        U R                  5      5       Vs/ s H  oÐR;                  U5      (       d  M  UPM     snU l        U R>                  R@                  RB                  U l"        g s  snnf s  snf s  snf s  snnf s  snf s  snf )
NÚunknown)ÚfunctionrÞ   ÚexternalÚ
unapprovedT)ÚstrictzvTool call results cannot be matched unambiguously because the message history contains duplicate tool_call_id values: zMTool call results need to be provided for all deferred tool calls. Expected: z, got: Úskip)rß   rÞ   )#r€   rÓ   r   rc   rÚ   rÜ   r²   r“   Úget_tool_defrH   Úkindr5   rÉ   rÊ   r³   rÍ   Úziprr   r   re   rm   ÚkeysrJ   ÚitemsrÌ   ÚrangeÚlenÚis_executable_functionrÏ   Úis_executable_outputrÐ   rŽ   r¶   Úoutput_schemarÑ   )ÚselfrÊ   rÉ   rO   r�   rå   Úeligible_callsÚduplicate_idsÚresult_tool_call_idsÚeligible_call_idsÚresponse_tool_call_idsÚcall_idÚvaluer£   s                 rC   Ú__post_init__Ú _ToolCallProcessor.__post_init__«  sœ  € Ø/3×/@Ñ/@ÈÐ/LˆÔ,Ü)¬$Ó/ˆÔØ!#ˆÔô alÔlpÓ`qÐØ:<ˆ
Ø—O”OˆDØ×(Ñ(×5Ñ5°d·n±nÓEˆHÞ$,�8—=’=°)ˆDØ×Ñ˜dÔ#ØÑ$×+Ñ+¨DÖ1ñ	 $ð
 %ŒØ"4Ôð ×!Ñ!Ò-ð ._ˆDÔ*ô #& d§o¡o°zÈ$Ò"Oôâ"O‘J�DØ×9Ñ9Ñ9÷ Ù"Oð ñ ô !9¸Ó HÐHˆ}ÕHÜ ×*Ò*ð6Ø6C°_ðFóð ô $' t×'=Ñ'=×'BÑ'BÓ'DÓ#EÐ Ù?MÓ Nº~°t×!2Ô!2¹~ÐÐ NØDHÇOÂOÓ%TÂO¸D×&7Ô&7ÁOÐ"Ð%TØ%ÕWÐAWÕWÜ ×*Ò*ð!Ø!2Ð 3°7Ð;OÐ:PðRóð ð
 6:×5KÑ5K×5QÑ5QÔ5Sô)Ú5S¡> 7ÐW\Ð`fÑWf“�’Ñ5Sò)ˆDÕ%ð .EˆDÔ*Ø(*ˆDÔ%ä,1´#°d·o±oÓ2FÔ,GÓ jÒ,G q×KfÑKfÐgh×Ki§Ñ,GÑ jˆÔÜ*/´°D·O±OÓ0DÔ*EÓfÒ*E Q×IbÑIbÐcd×IeŸqÑ*EÑfˆÔØ—h‘h—m‘m×1Ñ1ˆ�ùó=ùò !OùÚ%Tùó)ùò !kùÚfs<   Ã*KÄKÅKÆKÇ!KÇ1KÈ/K!ÉK!É:K&ÊK&c                óx   • U R                   S L =(       d&    U R                  U   R                  U R                  ;   $ rV   )r³   r²   rJ   rÌ   ©rî   r¡   s     rC   Ú_is_resume_eligibleÚ&_ToolCallProcessor._is_resume_eligibleå  s3   € à×%Ñ%¨Ð-×q°·±ÀÑ1G×1TÑ1TÐX\×XqÑXqÑ1qÐqrR   c                óV   • U R                   U   S:H  =(       a    U R                  U5      $ )NÚoutput)rÉ   rú   rù   s     rC   rì   Ú'_ToolCallProcessor.is_executable_outputé  s&   € Ø�‰˜uÑ%¨Ñ1×U°d×6NÑ6NÈuÓ6UÐUrR   c                ój   • U R                   U   U R                  ;   =(       a    U R                  U5      $ rV   )rÉ   rÍ   rú   rù   s     rC   rë   Ú)_ToolCallProcessor.is_executable_functionì  s-   € Ø�‰˜uÑ%¨×)GÑ)GÑG×kÈD×LdÑLdÐejÓLkÐkrR   c               ó.  #   • U R                   R                  R                  R                  b‘  U R                  (       a€  [        U R                   R                  R                  5      nU=R                  [        U R                  5      -  sl        U R                   R                  R                  R                  U5        U R                  5         Sh  v•N nU7v •  M   N
 U R                  5         U R                  5         Sh  v•N  nU7v •  M  
 g7f)zNRun the configured strategy, then apply retry-wins and resolve deferred calls.N)rŽ   r¶   Úusage_limitsÚtool_calls_limitrÏ   r   ÚstateÚusager²   rê   Úcheck_before_tool_callÚ_run_strategyÚ_apply_retry_winsÚ_finalize_deferred)rî   Úprojected_usager¾   s      rC   r»   Ú_ToolCallProcessor.runï  sÉ   é € ð �8‰8�=‰=×%Ñ%×6Ñ6ÑBÀt×G\×G\Ü& t§x¡x§~¡~×';Ñ';Ó<ˆOà×&Ò&¬#¨d×.CÑ.CÓ*DÑDÕ&Ø�H‰H�M‰M×&Ñ&×=Ñ=¸oÔNà×-Ñ-Ô/÷ 	�%Ø�Kñ	Ð/ð 	×ÑÔ Ø×2Ñ2Ô4÷ 	ð 	�%Ø�Kñ 5ùsB   ‚CDÃC!ÃCÃC!ÃDÃC!Ã!!DÄDÄD	ÄDÄ
Dc                ó   • [         e)zRExecute this strategy's tool calls, building up `final_result` and `output_parts`.)ÚNotImplementedError)rî   s    rC   r  Ú _ToolCallProcessor._run_strategyÿ  s
   € ô "Ð!rR   c                óV   • [         R                  " UR                  UUR                  S9$ )z[Build a status `ToolReturnPart` for an output tool call (success or skip). No side effects.©rH   rI   rJ   rL   )rî   rO   rI   s      rC   Ú_status_partÚ_ToolCallProcessor._status_part  s(   € ä×'Ò'Ø—n‘nØØ×*Ñ*ñ
ð 	
rR   c             #  ój   #   • U R                   R                  U5        [        XUS9 Sh  v•N   g N7f)z^Append an output tool's return/retry `part` to `output_parts` and emit its call/result events.rs   N)rµ   r5   ry   )rî   rO   rx   rt   s       rC   Ú_record_output_partÚ&_ToolCallProcessor._record_output_part  s+   é € ð 	×Ñ× Ñ  Ô&Ü+¨DÀ:ÑN×NÓNùs   ‚)3«1¬3c              ƒ  ó\  #   • U R                   R                  R                  n U R                  R	                  XR
                  S9I Sh  v•N nUR                  (       dd  UR                  c   e[!        UR                  ["        5      (       d   eU =R$                  S-  sl        [        USUR                  R&                  S9$  U R                  R)                  X0R
                  S9I Sh  v•N n[,        R.                  " X�R                  UR0                  5      n	[        US	U	S
9$  NÛ! [        R                   a¦  nU R                  R                  (       a/  U R                  R                  R                  UR                  5      OSnUb  UR                  OUn[        R                  " SU S35      nUR                  =(       d    UUl        [        USUS9s SnA$ SnAff = f Nù! [        R                   ar  nUR*                  (       a  UR*                  R                  OUn[        R                  " SU S35      nUR                  =(       d    UUl        [        US	US9s SnA$ SnAf["         a4  nU =R$                  S-  sl        [        US	UR&                  S9s SnA$ SnAff = f7f)a,  Validate and execute an output tool call, returning a structured result.

The caller interprets the result against the winner (first valid output by emission
order) and emits events. `output_retries_increment` accumulates retry-budget increments
so the caller can apply them after a parallel batch settles, avoiding interleaved race
writes. `UnexpectedModelBehavior` (max retries exceeded) is captured into `raise_exc`
rather than raised inline so the caller can decide whether to re-raise (no other output
produced a valid result) or absorb it as a skip.
)rÑ   Nz!Exceeded maximum output retries (Ú)F)rO   rt   r‚   r   )rO   rt   r�   T©rO   rt   r€   )rŽ   r¶   Úmax_output_retriesr“   Úvalidate_output_tool_callrÑ   r   ÚUnexpectedModelBehaviorrf   r�   rH   Úmax_retriesÚ	__cause__r{   rt   Úvalidation_errorr/   r#   r×   Ú
tool_retryÚexecute_output_tool_callÚtoolr    ÚFinalResultrJ   )
rî   rO   r  Ú	validatedÚer!  r  ÚwrappedÚresult_datar€   s
             rC   Ú_run_output_tool_callÚ(_ToolCallProcessor._run_output_tool_call  s?  é € ð "ŸX™XŸ]™]×=Ñ=Ðð		UØ"×/Ñ/×IÑIÈ$×WbÑWbÐIÐc×cˆIð ×#×#Ø×-Ñ-Ñ9Ð9Ð9ô
 ˜i×8Ñ8¼.×IÑIÐIÐIØ×)Ò)¨QÑ.Õ)Ü$¨$¸5ÈY×MgÑMg×MrÑMrÑsÐsð		ZØ%)×%6Ñ%6×%OÑ%OÐPY×bmÑbmÐ%OÐ%n×nˆKô ×)Ò)¨+·~±~Àt×GXÑGXÓYˆÜ  d°tÈ,ÑWÐWñA døÜ×1Ñ1ó 	UØBF×BSÑBS×BY×BY�4×$Ñ$×*Ñ*×.Ñ.¨t¯~©~Ô>Ð_cˆDð /3Ñ.>˜$×*Ò*ÐDVˆKÜ ×8Ò8Ð;\Ð]hÐ\iÐijÐ9kÓlˆGØ !§¡× 0¨qˆGÔÜ$¨$¸5ÈGÑTÕTûð	Uúñ(  oøÜ×1Ñ1ó 	TØ8A¿¿˜)Ÿ.™.×4Ò4ÐL^ˆKÜ ×8Ò8Ð;\Ð]hÐ\iÐijÐ9kÓlˆGØ !§¡× 0¨qˆGÔÜ$¨$¸4È7ÑSÕSûÜó 	ZØ×)Ò)¨QÑ.Õ)Ü$¨$¸4ÈAÏLÉLÑYÕYûð	Züs£   ‚!J,¤&D( Á
D&ÁD( ÁA5J,Ã&G' Ã+G%Ã,G' Ã06J,Ä&D( Ä(G"Ä<BGÇG"ÇJ,ÇG"Ç"J,Ç%G' Ç'J)Ç;A'I(É"J)É#J,É(J)É5)J$ÊJ)ÊJ,Ê$J)Ê)J,c              #  óŠ   #   • U R                  U[        5      U l        U R                  XR                  SS9 Sh  v•N   g N7f)zÎRecord the winning output's 'processed' status part and emit its events.

Tracks the part directly (`winning_output_part`) so `_apply_retry_wins` can replace it
in `output_parts` without scanning the list.
Trs   N)r  Ú_FINAL_RESULT_PROCESSEDrØ   r  )rî   rO   s     rC   Ú_emit_winning_outputÚ'_ToolCallProcessor._emit_winning_outputG  s=   é € ð $(×#4Ñ#4°TÔ;RÓ#SˆÔ Ø×+Ñ+¨D×2JÑ2JÐW[Ð+Ð\×\Ó\ùs   ‚9A»A¼Ac               óÊ  #   • U R                   bB  U R                   R                  UR                  :X  a  U R                  U5       H  nU7v •  M
     gU R                   b3  U R                  U[        5      nU R                  XSS9 H  nU7v •  M
     gU R                  U5      I Sh  v•N nUR                  bc  U R                  R                  =R                  U R                  -  sl
        U R                  R                  R                  5         UR                  eUR                   b  UR                   U l         U R                  XDR                   SLS9 H  nU7v •  M
     g Nº7f)zPRun a single output tool call (or stub it if a final result was already chosen).Nrs   ©Ú	is_winner)r€   rJ   r+  r  Ú'_OUTPUT_SKIPPED_FINAL_ALREADY_PROCESSEDr  r'  r‚   rŽ   r  Úoutput_retries_usedr×   Úcheck_incomplete_tool_callÚ_emit_settled_output)rî   rO   r¾   rx   Úrs        rC   Ú_run_outputÚ_ToolCallProcessor._run_outputP  s"  é € à×ÑÑ(¨T×->Ñ->×-KÑ-KÈt×O`ÑO`Ó-`Ø×2Ñ2°4Ö8�Ø•ò 9à×ÑÑ*Ø×$Ñ$ TÔ+RÓSˆDØ×1Ñ1°$ÈÐ1ÓN�Ø•ò Oð ×0Ñ0°Ó6×6ˆAØ�{‰{Ñ&Ø—‘—‘×2Ò2°d×6SÑ6SÑSÕ2Ø—‘—‘×9Ñ9Ô;Ø—k‘kÐ!Ø�~‰~Ñ)Ø$%§N¡N�Ô!Ø×2Ñ2°1ÇÁÐVZÐ@ZÐ2Ó[�Ø•ò \ñ 7ùs   ‚B$E#Â&E!Â'B;E#c             #  óˆ  #   • UR                   bo  U(       a$  U R                  UR                  5       Sh  v•N   gU R                  UR                  [        5      nU R                  UR                  USS9 Sh  v•N   gUR                  b8  U R                  UR                  UR                  UR                  S9 Sh  v•N   gUR                  c   eUR                  (       a  [        O[        nU R                  UR                  U5      nU R                  UR                  X1R                  S9 Sh  v•N   g GN NÂ N N7f)zLAppend the message-history part and emit events for a settled output result.NTrs   )r€   r+  rO   r  Ú_OUTPUT_NOT_FINAL_RESULTr  r�   rt   r‚   Ú_OUTPUT_EXECUTION_FAILEDÚ_OUTPUT_VALIDATION_FAILED)rî   r4  r/  rx   rb   s        rC   r3  Ú'_ToolCallProcessor._emit_settled_outputd  s  é € ð �>‰>Ñ%ÞØ×4Ñ4°Q·V±VÓ<×<Ñ<ð ×(Ñ(¨¯©Ô1IÓJ�Ø×3Ñ3°A·F±F¸DÈTÐ3ÐR×RÑRØ�\‰\Ñ%Ø×/Ñ/°·±¸¿¹ÐQR×Q]ÑQ]Ð/Ð^×^Ñ^ð —;‘;Ñ*Ð*Ð*Ø23·,·,Õ.ÔD]ˆGØ×$Ñ$ Q§V¡V¨WÓ5ˆDØ×/Ñ/°·±¸ÏÉÐ/ÐV×VÑVò =ñ
 Sá^ñ WùsH   ‚3EµD9¶AEÁ9D<Á:AEÂ>D>Â?A4EÄ3E Ä4EÄ<EÄ>EÅ Ec              óø  #   • U GH  nU R                   R                  UR                  5      nUb0  [        U[        5      (       d  [
        R                  " U5      7v •  M\   [        U[        5      (       aQ  U R                  (       a%  U R                  R                  UR                  5      OSnU R                  X4US9I Sh  v•N nO$U R                  R                  U5      I Sh  v•N n XbUR                  '   [
        R                  " X6R                   S97v •  GM     g N^ N<! [        R                   a>    U R                  R                  R                  5         [
        R                  " USS97v •  e f = f7f)u=  Validate a batch of function/unknown calls, emitting their `FunctionToolCallEvent`s.

Populates `validated_calls`. On resume, a supplied result that isn't a `ToolApproved`
(e.g. `ToolDenied`, `ModelRetry`) short-circuits inside `_call_tool`, so no validation is
needed â€” the event is emitted without args-validity.
N©Úapprovedr`   Frs   )rÌ   r�   rJ   r/   r&   rM   ÚFunctionToolCallEventr´   Ú_validate_approved_callr“   Úvalidate_tool_callr   r  rŽ   r  r2  rt   )rî   ro   Úvalidated_callsrO   Údeferred_resultr`   r#  s          rC   Ú_validate_function_callsÚ+_ToolCallProcessor._validate_function_calls|  s,  é € ô ˆDØ"×7Ñ7×;Ñ;¸D×<MÑ<MÓNˆOØÑ*´:¸oÌ|×3\Ñ3\Ü×5Ò5°dÓ;Ó;Ùð	Ü˜o¬|×<Ñ<ØQU×Qh×Qh˜t×6Ñ6×:Ñ:¸4×;LÑ;LÔMÐnr�HØ&*×&BÑ&BÀ4ÐltÐ&BÐ&u× u‘Ià&*×&7Ñ&7×&JÑ&JÈ4Ó&P× P‘Ið
 2;˜D×-Ñ-Ñ.Ü×1Ò1°$×CWÑCWÑXÖXò! ñ !vá PøÜ×5Ñ5ó Ø—‘—‘×9Ñ9Ô;Ü×5Ò5°dÀuÑMÓMØðüsP   ‚AE:Á"A D%ÃD!ÃD%ÃE:ÃD%Ã&D#Ã'D%Ã+6E:Ä!D%Ä#D%Ä%AE7Å7E:c             ƒ  ó®   #   • UnUR                   b  [        R                  " XR                   S9nU R                  R	                  USUS9I Sh  v•N $  N7f)z¨Validate an approved tool call, applying any handler-supplied `override_args`.

Shared by the upfront function-call validation and the inline deferred-resolution path.
N)ÚargsTr=  )Úoverride_argsr�   rž   r“   rA  )rî   rO   r>  r`   Úvalidate_calls        rC   r@  Ú*_ToolCallProcessor._validate_approved_call—  sT   é € ð ˆØ×!Ñ!Ñ-Ü'×/Ò/°×;QÑ;QÑRˆMØ×&Ñ&×9Ñ9¸-ÐRVÐaiÐ9Ðj×jÐjÑjùs   ‚AAÁAÁAc               óF  #   • U(       d  g0 nU R                  XS9  Sh  v•N nU7v •  M   N
 [        U R                  5      nU R                  UU R                  UU R
                  U R                  S9  Sh  v•N  nU7v •  M  
 U R                  US  H†  n[        U[        R                  5      (       d  M$  UR                  c  M3  U R                  R                  UR                  5      nUb  UR                  OSnU R                  XWS9(       d  M  SU l        Mˆ     g7f)zSValidate a batch of function/unknown calls upfront, then execute via `_call_tools`.N©rB  ©r³   rB  rÚ   rÜ   rÞ   ©rå   T)rD  rê   rµ   Ú_call_toolsrÌ   rÚ   rÜ   r/   rM   ÚRetryPromptPartrH   r“   rä   rå   Ú_is_retry_wins_triggerrÕ   )rî   ro   rB  r¾   Úbeforerx   r�   rå   s           rC   Ú_run_function_callsÚ&_ToolCallProcessor._run_function_calls§  s  é € ö ØØ?AˆØ×8Ñ8¸Ð8Ñ`÷ 	�%Ø�Kñ	Ð`ô �T×&Ñ&Ó'ˆØ×+Ñ+ØØ"×7Ñ7Ø+Ø×.Ñ.Ø"×4Ñ4ð ,ñ 
÷ 	ð 	�%ð �Kð
ð ×%Ñ% f gÓ.ˆDÜ˜$¤	× 9Ñ 9×:Ó:¸t¿~¹~Ó?YØ×,Ñ,×9Ñ9¸$¿.¹.ÓI�Ø(0Ñ(<�x—}’}À)�Ø×.Ñ.¨tÐ.×?Ð?Ø04�DÖ-ò /ùsK   ‚D!œ. ,¡.¤D!¬.®AD!Á5BÁ9A<Á:BÁ>8D!Â:D!Ã	AD!ÄD!c          	   ƒ  ó  #   • [        U[        5      (       a  UnUR                  nOS nUn Ub  [        U[        5      (       a3  Ub%  U R                  R                  U5      I S h  v•N nGO0[        S5      e[        U[        5      (       a  UnGO[        U[        R                  5      (       a@  [        R                  " UR                  UR                  UR                  SS9n[        U5      e[        U[        R                   5      (       a?  [        R"                  " UR                  UR                  UR                  S9n[%        U5      e[        U[        R"                  5      (       a-  UR                  Ul        UR                  Ul        [%        U5      eUn U R                  R/                  UR                  5      n[1        UUU(       a  UR2                  OS S9u  pšnU	/nU(       aŸ  [        R4                  R7                  U5      n[9        UU R                  [        U[:        5      (       a  UR<                  OS S9  UR?                  [        R@                  " [C        [D        RG                  U5      5      UR                  S95        XÊ4$  GN)! [$         a  nUR&                  /S 4s S nA$ S nAf[         a  nUR(                  /S 4s S nA$ S nAf[        R*                   a  n[-        XG5      /S 4s S nA$ S nAff = f7f)NzExpected validated tool callrF   rG   )rI   rH   rJ   )rO   ra   r‹   )r˜   rJ   )$r/   r   rO   r&   r“   Úexecute_tool_callÚRuntimeErrorr'   r   Ú
ToolFailedrM   rN   rH   rb   rJ   r"   Ú
ModelRetryrP  r#   r  Útool_failedÚRunCancelledrQ   rä   rk   ra   ÚToolCallPartrg   r–   r!   r‘   r5   r›   rc   ÚdictÚfromkeys)rî   Ú	tool_callÚtool_call_resultr#  rO   rh   Úmr$  r�   rj   Útool_user_contentrf   r¢   Únarrowed_calls                 rC   Ú
_call_toolÚ_ToolCallProcessor._call_toolÄ  s�  é € ô �iÔ!2×3Ñ3Ø!ˆIØ—>‘>‰DàˆIØˆDð"	?ØÑ'¬:Ð6FÌ×+UÑ+UØÑ(Ø(,×(9Ñ(9×(KÑ(KÈIÓ(V×"V’Kä&Ð'EÓFÐFÜÐ,¬j×9Ñ9Ø.’ÜÐ,¬j×.CÑ.C×DÑDÜ×,Ò,Ø"Ÿn™nØ,×4Ñ4Ø!%×!2Ñ!2Ø$ñ	�ô & aÓ(Ð(ÜÐ,¬j×.CÑ.C×DÑDÜ×-Ò-Ø,×4Ñ4Ø"Ÿn™nØ!%×!2Ñ!2ñ�ô
 % QÓ'Ð'ÜÐ,¬i×.GÑ.G×HÑHØ-1¯^©^Ð Ô*Ø04×0AÑ0AÐ Ô-Ü$Ð%5Ó6Ð6à.‘ð ×$Ñ$×1Ñ1°$·.±.ÓAˆÜ0FØØÞ,4�h×(Ò(¸$ñ1
Ñ-ˆ¨ð &1 MˆÞÜ%×2Ñ2×>Ñ>¸tÓDˆMÜ/ØØ×!Ñ!ä3=¸mÔMc×3dÑ3d�M×/Ò/Ðjnò	ð �L‰LÜ×3Ò3Ü $¤T§]¡]°5Ó%9Ó :È×IZÑIZñôð
 Ð'Ð'ò #Wøô4 ó 	(Ø—L‘L�> 4Ð'Õ'ûÜó 	)Ø—M‘M�? DÐ(Õ(ûÜ×&Ñ&ó 	?Ü.¨tÓ7Ð8¸$Ð>Õ>ûð	?üs�   ‚)L¬9J Á%JÁ&J Á*LÁ,"J ÂLÂDJ ÆC3LÊJ Ê
K?ÊJ/Ê)K?Ê*LÊ/K?Ê<KË
K?ËLËK?Ë'K:Ë4K?Ë5LË:K?Ë?Lc          
    óþ  ^ ^^^^^^^^#   • 0 m0 m0 m0 m      SUUUU4S jjn    SU UUU4S jjnT R                   R                  5       nUS:H  n	US:H  m[        [        [	        [        T5      5      5      UU U4S jS9n
 U
 Hû  nU Vs0 s H+  oÌ[        R                  " U" U5      TU   R                  S9_M-     nnUR                  5        VVs0 s H  u  pÎXì_M	     nnn [        [        UR                  5       5      T R                  R                  R                  5        S h  v•N n[!        U[        R"                  5      (       d  U7v •  M/  U	(       a  M8  U" UUU   5      I S h  v•N =n(       d  MU  U7v •  M\     [-        TT R                  R.                  R0                  5        [3        T5       H!  nT R4                  R7                  TU   5        M#     T R4                  R7                  [3        T5       Vs/ s H  nTU   PM
     sn5        [3        T5       HG  nTU    H;  n[!        U[8        R:                  5      (       d  M$  [8        R<                  " US
97v •  M=     MI     T R?                  TTTUUS9  g s  snf s  snnf  GNa GN!
 U	(       a.  U H%  nU" XÜ   U5      I S h  v•N  =n(       d  M   U7v •  M'     GMB  GME  ! [        R$                   aP  n['        UR                  5       S[        UR(                  5      S	:w  a  UR(                  S	   OS 06I S h  v•N    e S nAf[*         a!    ['        UR                  5       6 I S h  v•N    e f = fs  snf ! [-        TT R                  R.                  R0                  5        [3        T5       H!  nT R4                  R7                  TU   5        M#     T R4                  R7                  [3        T5       Vs/ s H  nTU   PM
     Os  snf sn5        f = f7f)Nc              “  ó&  >#   •  [         R                  " U 5      (       a
  U I S h  v•N OU R                  5       u  p#UTU'   U(       a  [        R                  " US9T	U'   US   n[        U[        R                  [        R                  -  5      (       d   e[        R                  " XCS9$  N„! [        R                   a  nSTU'   UR                  TU'    S nAg S nAf[        R                   a  nSTU'   UR                  TU'    S nAg S nAff = f7f)N©rI   r   rà   rá   )ÚinspectÚisawaitabler    rM   ÚUserPromptPartr/   rN   rP  ÚFunctionToolResultEventr   ÚCallDeferredr`   ÚApprovalRequired)
Úcoro_or_taskr¡   Ú
tool_partsrb  Ú	tool_partr$  Údeferred_calls_by_indexÚdeferred_metadata_by_indexÚtool_parts_by_indexÚuser_parts_by_indexs
         €€€€rC   Úhandle_call_or_resultÚ=_ToolCallProcessor._call_tools.<locals>.handle_call_or_result$  sú   øé € ð
_ä,3×,?Ò,?À×,MÑ,M˜<×'Ð'ÐS_×SfÑSfÓShñ .�
ð .8Ð# EÑ*Þ$Ü1:×1IÒ1IÐRcÑ1dÐ'¨Ñ.à& q™M�	Ü! )¬Y×-EÑ-EÌ	×HaÑHaÑ-a×bÑbÐbÐbÜ ×8Ò8¸Ñ^Ð^ñ (øä×*Ñ*ó ?Ø1;Ð'¨Ñ.Ø45·J±JÐ*¨5Ö1ûÜ×.Ñ.ó ?Ø1=Ð'¨Ñ.Ø45·J±JÐ*¨5Ö1ûð?üsP   ƒD… B, ¥B*¦B, ¼A.DÂ*B, Â,DÃ CÃDÃDÃ0D	ÄDÄ	DÄDc                ó”   >• TU    nTR                  TR                  UR                  U5      TR                  UR                  5      S9$ )N©r`  )rd  r�   rJ   )r¡   rO   rî   r³   r²   rB  s     €€€€rC   Ú	call_toolÚ1_ToolCallProcessor._call_tools.<locals>.call_tool<  sO   ø€ ð ˜eÑ$ˆDØ—?‘?Ø×#Ñ# D×$5Ñ$5°tÓ<Ø!2×!6Ñ!6°t×7HÑ7HÓ!Ið #ð ð rR   Úparallel_ordered_eventsÚ
sequentialc                óR   >• T=(       d    TR                   R                  TU    5      $ rV   )r“   Úis_sequential)r£   Úglobal_sequentialrî   r²   s    €€€rC   Ú<lambda>Ú0_ToolCallProcessor._call_tools.<locals>.<lambda>R  s&   ø€ Ð!2×!d°d×6GÑ6G×6UÑ6UÐV`ÐabÑVcÓ6dÐ!drR   ©r¨   ©r_   Úmsgr   ©rx   ©rr  rs  rÚ   rÜ   )ro  zªAwaitable[tuple[_FunctionCallParts, str | Sequence[_messages.UserContent] | None]] | asyncio.Task[tuple[_FunctionCallParts, str | Sequence[_messages.UserContent] | None]]r¡   rÖ   Úreturnz$_messages.HandleResponseEvent | None)r¡   rÖ   rˆ  z\Coroutine[Any, Any, tuple[_FunctionCallParts, str | Sequence[_messages.UserContent] | None]]) r“   Úget_parallel_execution_moder«   rc   ré   rê   r0   Úcreate_taskrH   rè   rD   rm   ÚvaluesrŽ   r  r=   r/   ÚTaskÚCancelledErrorr   rG  ÚBaseExceptionr¥   r¶   r    r™   rµ   ÚextendrM   r›   ÚToolAvailabilityDeltaEventÚ_populate_deferred_calls)rî   r²   r³   rB  rÚ   rÜ   rv  rz  ÚmodeÚordered_eventsr©   Úsegmentr¡   Útasks_by_indexr?   Úindex_by_taskrY   r¾   r$  Úkrx   rr  rs  r€  rt  ru  s   ````                 @@@@@rC   rO  Ú_ToolCallProcessor._call_tools  sÎ  ÿøé € ð >@ÐØCEÐØPRÐØGIÐ"ð	_ðdð	_ð ð	_ð 2÷		_ò 	_ð0	Øð	ð
÷	ò 	ð × Ñ ×<Ñ<Ó>ˆØÐ!:Ñ:ˆØ  LÑ0Ðô
 (Ü””s˜:“Ó'Ó(Þdñ
ˆð
/	dÛ#�ápwó"ÚpwÐglœ7×.Ò.©y¸Ó/?ÀjÐQVÑFW×FaÑFaÑbÒbÑpwð ð "ð AO×@TÑ@TÔ@VÔ WÒ@V±° ¢Ñ@V�Ñ Wðô 'BÜ˜N×1Ñ1Ó3Ó4°d·h±h·n±n×6XÑ6Xô'÷ 
,˜dô  *¨$´·±×=Ñ=ð #'�Jß!/ Ù.CÀDÈ-ÐX\ÑJ]Ó.^×(^Ð^˜u×^Ø&+¥ñ% $ôV *Ð*=¸t¿x¹x¿}¹}×?bÑ?bÔcÜÐ 3Ö4�Ø×!Ñ!×(Ñ(Ð)<¸UÑ)CÖDñ 5à×Ñ×$Ñ$ÄfÐM`ÔFaÓ%bÒFaÀÐ&9¸!Ô&<ÑFaÑ%bÔcäÐ/Ö0ˆEØ+¨EÔ2�Ü˜d¤I×$GÑ$G×HÓHÜ#×>Ò>ÀDÑIÕIó 3ñ 1ð
 	×%Ñ%ØØ$;Ø'AØ)Ø/ð 	&ò 	
ùòi"ùó !Xò
,ò )_ð'ö &ó
 &-˜EÙ.CÀNÑDYÐ[`Ó.a×(aÐ(aÐa˜u×aØ&+¥ô &-ò &øô ×-Ñ-ó Ü*¨N×,AÑ,AÓ,CÐqÔVYÐZ[×Z`ÑZ`ÓVaÐefÓVfÈÏÉÐPQÊÐlpÑq×qÑqØûÜ$ó ô
 +¨N×,AÑ,AÓ,CÐD×DÑDØðüò  &cøô *Ð*=¸t¿x¹x¿}¹}×?bÑ?bÔcÜÐ 3Ö4�Ø×!Ñ!×(Ñ(Ð)<¸UÑ)CÖDñ 5à×Ñ×$Ñ$ÄfÐM`ÔFaÓ%bÒFaÀÐ&9¸!Ô&<ÒFaùÔ%bÕcüsú   ‹A8O=Â	M  Â2JÂ?M  ÃJÃ"M  Ã&AKÄ'JÄ+JÄ,JÄ/,KÅKÅ.JÅ/	KÅ<KÆM  ÆA<O=ÈMÈ:O=É3O=ÊM  ÊJÊKÊKÊ-J0Ê.
KÊ<	KËM  ËMËAL*Ì#L&Ì$L*Ì*&MÍMÍMÍM  ÍO=Í A=O:ÏO-Ï,O:Ï:O=c               óŠ   • [        U5       H4  nX   nXBU      R                  U5        X6   nUc  M&  X…UR                  '   M6     g)z;Populate deferred calls and metadata from indexed mappings.N)r™   r5   rJ   )	rî   r²   rr  rs  rÚ   rÜ   r—  rO   r`   s	            rC   r‘  Ú+_ToolCallProcessor._populate_deferred_calls“  sM   € ô Ð/Ö0ˆAØ‘=ˆDØ°1Ñ5Ñ6×=Ñ=¸dÔCØ1Ñ4ˆHØÓ#Ø7? $×"3Ñ"3Ó4ò 1rR   c               óN   • [        U[        R                  5      =(       a    US:H  $ )uã  Whether a settled tool part triggers retry-wins.

A `RetryPromptPart` (a `ModelRetry` or arg-validation failure) from an actual function
tool suppresses an otherwise-valid output, so the model addresses the retry next round.
Retries from unknown/hallucinated tools don't â€” they aren't work that needs to complete
before the output is valid. This single predicate backs both the emission-order paths
(graceful/early) and the parallel exhaustive path so the rule lives in one place.
rß   )r/   rM   rP  )rî   rx   rå   s      rC   rQ  Ú)_ToolCallProcessor._is_retry_wins_trigger¦  s!   € ô ˜$¤	× 9Ñ 9Ó:×Q¸tÀzÑ?QÐQrR   c                ó:  • U R                   (       a  U R                  b  U R                  (       a  gU R                  c   eU R                  R                  U R                  5      n[        R                  " U R                  [        S9U R                  U'   SU l        g)a  Suppress the output result if a function tool retried (graceful + exhaustive).

The suppressed output's `ToolReturnPart` is replaced in `output_parts` so the model
addresses the retry next round. Doesn't apply when the final result was committed
externally (`run_stream`).
Nrh  )	rÕ   r€   rÓ   rØ   rµ   r¡   r�   rž   Ú_RETRY_WINS)rî   Úidxs     rC   r  Ú$_ToolCallProcessor._apply_retry_wins±  s€   € ð ×%×%¨$×*;Ñ*;Ñ*GÐPT×Pt×Ptàð ×'Ñ'Ñ3Ð3Ð3Ø×Ñ×%Ñ% d×&>Ñ&>Ó?ˆÜ!,×!4Ò!4°T×5MÑ5MÔWbÑ!cˆ×Ñ˜#ÑØ ˆÕrR   c               óü   #   • U R                   c   U R                  5         Sh  v•N nU7v •  M  U R                  (       d2  U R                  (       a   U R	                  5         Sh  v•N nU7v •  M  gg NO
 NH N
 g7f)zOStub, collect, or inline-resolve deferred (`external`/`unapproved`) tool calls.N)r³   Ú_collect_deferred_callsr€   rÚ   Ú_resolve_deferred_calls)rî   r¾   s     rC   r	  Ú%_ToolCallProcessor._finalize_deferredÃ  sl   é € ð ×!Ñ!Ñ)Ø#×;Ñ;Ô=÷ �eØ•à× ×  T×%8×%8Ø#×;Ñ;Ô=÷ �eØ•ð &9Ð ñÑ=ñÑ=ùsI   ‚A< A6¤A4¥A6¨:A<Á"A:Á&A8Á'A:Á*
A<Á4A6Á6A<Á8A:Á:A<c           	    óˆ  #   • / U R                   S   QU R                   S   QnU R                  (       a{  [        U R                  R                  [        5      (       dQ  U HJ  nU R
                  R                  [        R                  " UR                  [        UR                  S95        ML     ggU(       aÖ  U HÏ  n U R                  R                  U5      I Sh  v•N n[        R                   " X#R"                  S97v •  UR"                  (       aR  X R                   S   ;   a   U R$                  S   R                  U5        M‹  U R$                  S   R                  U5        M«   U R                  R'                  U5      I Sh  v•N   MÑ     gg N²! [        R                   a    [        R                   " USS97v •  e f = f N=! [(        [*        4 am  n[        U[(        5      (       a  UR,                  OUR.                  nU R
                  R                  U5        [        R0                  " U5      7v •   SnAGM‚  SnAff = f7f)z]Stub deferred calls (a final result was reached) or validate-and-collect them for resolution.rà   rá   r  NFrs   )rÊ   r€   r/   rý   r$   rµ   r5   rM   rN   rH   Ú%_TOOL_SKIPPED_FINAL_ALREADY_PROCESSEDrJ   r“   rA  r   r  r?  rt   rÚ   rV  r#   r"   r  rZ  rl  )rî   ro   rO   r#  r$  rx   s         rC   r¢  Ú*_ToolCallProcessor._collect_deferred_callsÎ  sâ  é € ð
 _�$×)Ñ)¨*Ñ5Ð^¸×8OÑ8OÐP\Ñ8]Ð^ˆØ××ô ˜d×/Ñ/×6Ñ6Ô8L×MÑMÛ!�DØ×%Ñ%×,Ñ,Ü!×0Ò0Ø&*§n¡nÜ$IØ)-×):Ñ):ñöò "ð Nö Û�ðØ&*×&7Ñ&7×&JÑ&JÈ4Ó&P× P�Iô
  ×5Ò5°d×G[ÑG[Ñ\Ó\à×'×'Ø×6Ñ6°zÑBÓBØ×+Ñ+¨JÑ7×>Ñ>¸tÖDà×+Ñ+¨LÑ9×@Ñ@ÀÖFðFØ"×/Ñ/×AÑAÀ)ÓL×LÒLò% ð ñ !QøÜ!×9Ñ9ó Ü#×9Ò9¸$È5ÑQÓQØðúñ MøÜ*¬OÐ<ó FÜ/9¸!¼^×/LÑ/L˜qŸ|š|ÐRS×R_ÑR_˜Ø×)Ñ)×0Ñ0°Ô6Ü'×?Ò?ÀÓE×EÒEûðFüsn   ‚B9IÂ<FÃFÃFÃBIÅ$GÆG ÆGÆIÆFÆ.F=Æ=IÇ GÇH?ÇA!H:È3IÈ:H?È?Ic               ó,  #   • [        / U R                  S   QU R                  S   Q5      =n(       a  [        R                  " SU 35      e[	        U R                  S   U R                  S   U R
                  S9n[        R                  " U5      7v •  U R                  R                  U5      I Sh  v•N nUGb  [        R                  " U5      7v •  UR                  5       n/ U R                  S   QU R                  S   Q Vs/ s H  nUR                  U;   d  M  UPM     nn0 nU Hr  nXER                     n[        U[        5      (       d  M(  UR                  R!                  UR                  5      n	 U R#                  XXU	S9I Sh  v•N XuR                  '   Mt     ['        [(        5      n
0 nU R+                  UUUU
US	9  Sh  v•N nU7v •  M  Ubq  U R6                  R8                  R:                  R<                  (       d  [        R>                  " S
5      e[@        RB                  " [E        [F        U5      SS5      U l$        gg GN—s  snf  NÅ! [        R                   a    [        R$                  " USS97v •  e f = f N»
 UR-                  U5      nU
S   (       d  U
S   (       d  MÚ  Uc
  [	        5       nUR.                  R1                  U
S   5        UR2                  R1                  U
S   5        UR                  R5                  U5        GN@7f)zeResolve collected deferred calls via capability handlers, else set the `DeferredToolRequests` result.rà   rá   zIDeferred tool calls must have unique tool_call_id values; duplicate ids: )ro   Ú	approvalsr`   Nr=  Frs   rM  a  A deferred tool call was present, but `DeferredToolRequests` is not among output types. To resolve this, add `DeferredToolRequests` to the list of output types for this agent, or use a `HandleDeferredToolCalls` capability to handle deferred tool calls inline.)%rr   rÚ   r   r  r$   rÜ   rM   ÚDeferredToolRequestsEventr“   Úresolve_deferred_tool_callsÚDeferredToolResultsEventÚto_tool_call_resultsrJ   r/   r&   r`   r�   r@  r?  r   rc   rO  Ú	remainingro   r�  r©  rœ   rŽ   r¶   rí   Úallows_deferred_toolsre   r    r"  r   r   r€   )rî   rð   Údeferred_tool_requestsÚhandler_resultsÚhandler_tool_call_resultsrO   Úresolved_callsÚhandler_validated_callsÚhandler_resultÚcall_metadataÚnew_deferred_callsÚnew_deferred_metadatar¾   s                rC   r£  Ú*_ToolCallProcessor._resolve_deferred_callsù  s3  é € ô 5ØRˆd×!Ñ! *Ñ-ÐR°×0CÑ0CÀLÑ0QÐRó
ð 
ˆ=õ 
ô ×4Ò4Ø[Ð\iÐ[jÐkóð ô ?SØ×%Ñ% jÑ1Ø×)Ñ)¨,Ñ7Ø×+Ñ+ñ?
Ðô ×1Ò1Ð2HÓIÓIð !%× 1Ñ 1× MÑ MÐNdÓ e×eˆØÒ&Ü×4Ò4°_ÓEÓEØ(7×(LÑ(LÓ(NÐ%ð c˜d×1Ñ1°,Ñ?ÐbÀ$×BUÑBUÐV`ÑBaÑbóâb�DØ×$Ñ$Ð(AÑA÷ Ùbð ð ð LNÐ#Û&�Ø!:×;LÑ;LÑ!M�Ü! .´,×?Ñ?ÙØ /× 8Ñ 8× <Ñ <¸T×=NÑ=NÓ O�ð	ØGK×GcÑGcØÀð Hdð H÷ BÐ+×,=Ñ,=Ó>ñ 'ô  itÜóiÐð @BÐ!Ø#×/Ñ/ØØ";Ø 7Ø1Ø"7ð  0ñ  ÷ �eð •ð "Ñ-Ø—8‘8—=‘=×.Ñ.×D×DÜ ×*Ò*ðjóð ô
 !'× 2Ò 2´4¼ÐE[Ó3\Ð^bÐdhÓ iˆDÕð .òk fùòñBøô "×9Ñ9ó ô $×9Ò9¸$È5ÑQÓQØðúñð  ð &<×%EÑ%EÀoÓ%VÐ"Ø! *×-Ð1CÀL×1QÑ1Qð *Ñ1Ü-AÓ-CÐ*Ø&×,Ñ,×3Ñ3Ð4FÀzÑ4RÔSØ&×0Ñ0×7Ñ7Ð8JÈ<Ñ8XÔYØ&×/Ñ/×6Ñ6Ð7LÖMùs‚   ‚B0LÂ2I	Â3ALÄIÄIÄ$ALÅ8IÆIÆIÆ(LÇJÇJÇ	JÇA>LÉLÉIÉ.JÊLÊJÊ&LÊ.A$L)rÉ   rÌ   rÚ   rÜ   rÍ   r€   rÓ   rÏ   rÐ   rÕ   rÑ   rÊ   rØ   )rˆ  ÚNone)r¡   rÖ   rˆ  rÒ   ©rˆ  ú)AsyncIterator[_messages.AgentStreamEvent])rO   r}   rI   r^   rˆ  ú_messages.ToolReturnPart©rO   r}   rx   z4_messages.ToolReturnPart | _messages.RetryPromptPartrt   r~   rˆ  ú'Iterator[_messages.HandleResponseEvent])rO   r}   rˆ  ú_OutputCallResult[NodeRunEndT])rO   r}   rˆ  r¿  )rO   r}   rˆ  r¼  )r4  rÀ  r/  rÒ   rˆ  r¿  )ro   rÃ   rB  ú#dict[str, ValidatedToolCall[DepsT]]rˆ  r¼  )rO   r}   r>  r&   r`   zdict[str, Any] | Nonerˆ  zValidatedToolCall[DepsT])ro   rÃ   rˆ  r¼  )r_  z1ValidatedToolCall[DepsT] | _messages.ToolCallPartr`  zDeferredToolResult | Nonerˆ  zGtuple[_FunctionCallParts, str | Sequence[_messages.UserContent] | None])r²   rÃ   r³   rË   rB  rÁ  rÚ   rÙ   rÜ   rÛ   rˆ  r¼  )r²   rÃ   rr  z,dict[int, Literal['external', 'unapproved']]rs  z dict[int, dict[str, Any] | None]rÚ   rÙ   rÜ   rÛ   rˆ  rº  )rx   z_messages.ModelRequestPartrå   zToolKind | Literal['unknown']rˆ  rÒ   ).r„   r…   r†   r‡   rˆ   r‰   r�   ÚfieldrÉ   rÊ   rÌ   rÍ   rÏ   rÐ   rÑ   rÓ   rÕ   r×   rØ   rÚ   rÜ   rö   rú   rì   rë   r»   r   r  r  r  r'  r+  r5  r3  rD  r@  rS  rd  rO  r‘  rQ  r  r	  r¢  r£  rŠ   rƒ   rR   rC   rÁ   rÁ   y  sK  ‡ ñ	ð %Ó$Ø,Ó,ØMÓMØ8Ó8Ø	MÓMØ2Ó2Ø8Ó8ð 7B×6GÒ6GÈUÑ6S€JÐ3ÓSØ\g×\mÒ\mØñ]ÐÐYó ð ;F×:KÒ:KÐQVÑ:WÐÐ7ÓWØKV×K\ÒK\ÐbgÑKhÐÐHÓhØ"-×"3Ò"3¸Ñ"?Ð�iÓ?Ø +× 1Ò 1°uÑ =€N�IÓ=Ø0;×0AÒ0AÀuÑ0M€FÐ-ÓMð -8×,=Ò,=À5Ñ,IÐ# TÓIØ!,×!2Ò!2¸5ÀuÑ!MÐ˜$ÓMØ$/×$5Ò$5¸aÀeÑ$LÐ˜cÓLØ;F×;LÒ;LÐUYÐ`eÑ;fÐÐ8ÓfØ\g×\mÒ\mØñ]€NÐYó ð 4?×3DÒ3DÈ%Ñ3PÐÐ0ÓPô82ôtrôVôlôð  ó"ó ð"ô
ð	Oà$ð	Oð Cð	Oð
  ð	Oð 
1ô	Oô,Xô\]ôð(WØ/ðWØ?CðWà	0ôWð0YØ1ðYØGjðYà	2ôYð6kà$ðkð ð	kð
 (ðkð 
"ôkð 5Ø1ð5à	2ô5ð:P(àDðP(ð 4ð	P(ð
 
QôP(ðd{
à0ð{
ð 9ð	{
ð
 =ð{
ð ^ð{
ð 5ð{
ð 
3ô{
ðz@à0ð@ð "Nð	@ð
 %Eð@ð ^ð@ð 5ð@ð 
ô@ô&	Rô!ô$	ô)F÷VVjrR   rÁ   c                  ó"   • \ rS rSrSrSS jrSrg)r¹   iR  zV`'early'`: run all output tools first; run function tools only if every output failed.c           	    óZ  #   • U R                    H/  nU R                  U R                  U   5        S h  v•N nU7v •  M     U R                  R                  =R
                  U R                  -  sl        U R                   Vs/ s H  oR                  U   PM     nnU R                  bQ  U HJ  nU R                  R                  [        R                  " UR                  [        UR                  S95        ML     g U R!                  U5        S h  v•N nU7v •  M   Nç
 GM  s  snf  N
 g 7f)Nr  )rÐ   r5  r²   rŽ   r  r1  r×   rÏ   r€   rµ   r5   rM   rN   rH   r¦  rJ   rS  )rî   r£   r¾   Úfunction_callsrO   s        rC   r  Ú_EarlyProcessor._run_strategyV  sù   é € Ø×$Ô$ˆAà#×/Ñ/°·±ÀÑ0BÔC÷ �eØ•ñ %ð 	�‰�‰×*Ò*¨d×.KÑ.KÑKÕ*à6:×6KÒ6KÓLÒ6K°Ÿ/™/¨!Ô,Ñ6KˆÐLØ×ÑÑ(ã&�Ø×!Ñ!×(Ñ(Ü×,Ò,Ø"&§.¡.Ü EØ%)×%6Ñ%6ñöò 'ð  $×7Ñ7¸ÔG÷ �eØ•ñ%ÓCùò MñÑGùsW   ‚.D+°D´DµD¸AD+ÂD"ÂA1D+ÄD)ÄD'ÄD)ÄD+ÄDÄ	D+Ä'D)Ä)D+rƒ   Nr»  ©r„   r…   r†   r‡   rˆ   r  rŠ   rƒ   rR   rC   r¹   r¹   R  s
   † á`÷rR   r¹   c                  ó"   • \ rS rSrSrSS jrSrg)rº   in  zd`'graceful'`: walk in emission order, running pending function-tool batches before each output tool.c               óø  ^ ^#   • / mSUU 4S jjn[        T R                  5       H[  u  p#T R                  U5      (       a  U" 5         S h  v•N nU7v •  M  T R	                  U5      (       d  MJ  TR                  U5        M]     U" 5         S h  v•N nU7v •  M   NO
 T R                  U5        S h  v•N  nU7v •  M  
 Mž   N3
 T R                  R                  =R                  T R                  -  sl        g 7f)Nc                ón   >#   • T(       a%  Tn / mTR                  U 5        S h  v•N nU7v •  M  g  N
 g 7frV   )rS  )Úbatchr¾   Úpending_functionsrî   s     €€rC   Úflush_pendingÚ7_GracefulProcessor._run_strategy.<locals>.flush_pendingu  s;   øé € æ Ø)�Ø$&Ð!Ø#'×#;Ñ#;¸EÔ#B÷  ˜%Ø•Kð	 !ñ Ñ#Bùs   ƒ5 3¤1¥3¨	5±3³5r»  )
rš   r²   rì   r5  rë   r5   rŽ   r  r1  r×   )rî   rÍ  r£   rO   r¾   rÌ  s   `    @rC   r  Ú _GracefulProcessor._run_strategyr  sÖ   ùé € Ø:<Ð÷	 ð 	 ô ! §¡Ö1‰GˆAØ×(Ñ(¨×+Ñ+Ù#0¤?÷  ˜%Ø•Kð ×,Ñ,¨Q×/Ó/Ø!×(Ñ(¨Ö.ñ 2ñ )œ?÷ 	�%Ø�Kñ  ?ð $(×#3Ñ#3°DÔ#9÷  ð  ˜%Ø•Kò $:ñ	˜?à�‰�‰×*Ò*¨d×.KÑ.KÑKÖ*ùsl   „AC:ÁBÁBÁBÁC:Á/C:ÂCÂCÂCÂC:ÂBÂC:Â/C Â3B6Â4C Â8C:ÃCÃ5C:rƒ   Nr»  rÇ  rƒ   rR   rC   rº   rº   n  s   † án÷LrR   rº   c                  ó"   • \ rS rSrSrSS jrSrg)r¸   i‹  aÜ  `'exhaustive'`: run every tool in parallel, segmented only by `sequential=True` barriers.

Output and function tools launch together, segmented only by `sequential=True` barriers
(which may be output tools via `ToolOutput(sequential=True)`). The first valid output by
emission order becomes the final result; the rest still execute. Function-tool returns
and the message-history parts are assembled in emission order; `FunctionToolResultEvent`s
stream as each task completes.
c           	    ó¶  ^ ^ ^!#   • T R                   b  T R                   R                  OS n0 m!T R                  T R                   Vs/ s H  nT R                  U   PM     snT!S9  S h  v•N nU7v •  M  s  snf  N
 [        / T R                  QT R                  Q5      n0 nT R                   HK  nUc  M  T R                  U   R                  U:X  d  M'  [        T R                  U   ST R                   S9XR'   MM     T R                  R                  5       nUS:H  m US:H  nU Vs/ s H  o"U;  d  M
  UPM     Os  snf nn[        UU U 4S jS9n	0 n
0 n0 n0 n0 nSU U!4S jjn[        5       n[        5       nS	n U	 GHr  nU Vs/ s H5  n[        R                  " U" U5      T R                  U   R                  S
9PM7     Os  snf nn [        [        U5      T R                   R"                  R$                  5        S h  v•N  n['        U[        R(                  5      (       d  U7v •  M0  UR+                  5       u  nn['        U[        5      (       a  UUU'   M_  ['        U[,        R.                  5      (       a  SUU'   UR0                  UU'   M”  ['        U[,        R2                  5      (       a  SUU'   UR0                  UU'   MÉ  Uu  nnUU
U'   U(       a  [4        R6                  " US9UU'   US   n['        U[4        R8                  [4        R:                  -  5      (       d   eT R=                  UT R>                  U   S9(       a  ST l         [4        RB                  " UUS9nU(       a  UUU'   GMu  U7v •  GM}  
 GM  ! [        RD                   aB  n[G        US[I        URJ                  5      S:w  a  URJ                  S   OS 06I S h  v•N    e S nAf[L         a    [G        U6 I S h  v•N    e f = f   T R                   cI  T R                   H9  nURO                  U5      nUc  M  UR                   c  M(  UR                   T l           O   T R                   c™  T R                   H‰  nURO                  U5      nUc  M  URP                  c  M(  T R                   R"                  =RR                  T RT                  -  sl)        T R                   R"                  RW                  5         URP                  e   [Y        U
T R                   RZ                  R\                  5        SnU GHY  nT R>                  U   S:X  a·  URO                  U5      nUc  M-  T R                   S L=(       a-    UR^                  R                  T R                   R                  :H  nU(       a:  T R`                  (       a)  T Rc                  UR^                  5       H  nU7v •  M
     M°  T Re                  UUS9 H  nU7v •  M
     MÎ  X*;   d  MÕ  T Rf                  Ri                  X¢   5        URk                  U5        U(       a  X,;   a  XÂ   7v •  X¢    H;  n['        U[4        Rl                  5      (       d  M$  [4        Rn                  " US97v •  M=     GM\     U H8  nX+;   d  M
  T Rf                  Rq                  X²   5        URk                  U5        M:     U(       d*  [Y        U
T R                   RZ                  R\                  5        U H/  nX*;   d  M
  UU;  d  M  T Rf                  Ri                  X¢   5        M1     U H/  nX+;   d  M
  UU;  d  M  T Rf                  Rq                  X²   5        M1     O ! U(       d*  [Y        U
T R                   RZ                  R\                  5        U H/  nX*;   d  M
  UU;  d  M  T Rf                  Ri                  X¢   5        M1     U H/  nX+;   d  M
  UU;  d  M  T Rf                  Rq                  X²   5        M1     f = fT Rs                  T R                  UUT Rt                  T Rv                  S9  T R                   R"                  =RR                  T RT                  -  sl)        g 7f)NrL  Tr  r}  r|  c                óf   >• T=(       d(    TR                   R                  TR                  U    5      $ rV   )r“   r  r²   )r£   r€  rî   s    €€rC   r�  Ú4_ExhaustiveProcessor._run_strategy.<locals>.<lambda>±  s,   ø€ Ð/@×/wÀD×DUÑDU×DcÑDcÐdh×dsÑdsÐtuÑdvÓDwÐ/wrR   rƒ  c              “  ó¦  >#   • TR                   U    nTR                  U    S:X  a  U TR                  U5      I S h  v•N 4$  U TR                  TR	                  UR
                  U5      TR                  R	                  UR
                  5      S9I S h  v•N 4$  N] N! [        R                  [        R                  4 a  nX4s S nA$ S nAff = f7f)Nrý   ry  )
r²   rÉ   r'  rd  r�   rJ   rÌ   r   rm  rn  )r¡   rO   r$  rî   rB  s      €€rC   Úrun_oneÚ3_ExhaustiveProcessor._run_strategy.<locals>.run_one¼  sÉ   øé € Ø—?‘? 5Ñ)ˆDØ�‰˜uÑ%¨Ó1Ø D×$>Ñ$>¸tÓ$D×DÐDÐDð Ø D§O¡OØ#×'Ñ'¨×(9Ñ(9¸4Ó@Ø%)×%>Ñ%>×%BÑ%BÀ4×CTÑCTÓ%Uð %4ð %÷ ð ð ñ Eñøô ×+Ñ+¬Z×-HÑ-HÐIó  Ø�x•ûð üsR   ƒ8C»B¼CÁAB ÂBÂB ÂCÂB Â$CÃC	ÃCÃCÃ	CÃCFr„  rà   rá   rh  r   rN  r…  rý   r.  r†  r‡  )r¡   rÖ   rˆ  z)tuple[int, _ToolCallPayload[NodeRunEndT]])<r€   rJ   rD  rÏ   r²   r™   rÐ   r{   r“   r‰  r«   rm   r0   rŠ  rH   rD   rŽ   r  r=   r/   rŒ  r    r   rm  r`   rn  rM   rk  rN   rP  rQ  rÉ   rÕ   rl  r�  r   rê   rG  rŽ  r�   r‚   r1  r×   r2  r¥   r¶   r    rO   rÓ   r+  r3  rµ   r�  rn   r›   r�  r5   r‘  rÚ   rÜ   )"rî   Úexternally_won_idr£   r¾   Úexecutable_indicesÚoutput_resultsr’  r“  Útask_indicesr©   Úfunction_partsÚfunction_user_partsÚfunction_eventsÚdeferred_by_indexÚdeferred_meta_by_indexrÕ  Úappended_function_indicesÚappended_user_indicesÚprunedr”  ÚtasksrY   r¡   Úpayloadrp  rb  rq  Úresult_eventr$  r4  r/  rx   r€  rB  s"   `                               @@rC   r  Ú"_ExhaustiveProcessor._run_strategy–  sU  úé € Ø>B×>OÑ>OÑ>[˜D×-Ñ-×:Ò:ÐaeÐð @BˆØ×8Ñ8Ø)-×)>Ò)>Ó?Ò)> AˆT�_‰_˜QÔÑ)>Ñ?ÐQ`ð 9ñ 
÷ 	�%ð �Kùò @ñ	ð 
ô
 $Ð$R d×&9Ñ&9Ð$R¸D×<QÑ<QÐ$RÓSÐð EGˆØ×$Ô$ˆAØ Ó,°·±ÀÑ1C×1PÑ1PÐTeÕ1eÜ$5ØŸ™¨Ñ+¸È4×K\ÑK\ñ%�Ó!ñ %ð × Ñ ×<Ñ<Ó>ˆØ  LÑ0ÐØÐ!:Ñ:ˆÙ#5ÓQÒ#5˜aÀ.Ñ9PŸÒ#5ùÒQˆÐQÜ'ØÕ%wñ
ˆð 9;ˆØCEÐð IKˆØJLÐØCEÐ÷
	 ð 
	 ô  /2«eÐ!Ü*-«%ÐØˆðj	EÜ#�ÙelÓmÒelÐ`aœ×,Ò,©W°Q«Z¸d¿o¹oÈaÑ>P×>ZÑ>ZÔ[ÒelùÒm�Ðmð#Ü&AÄ#ÀeÃ*ÈdÏhÉhÏnÉn×NpÑNpÔ&q÷ 7ð 7˜dÜ)¨$´·±×=Ñ=ð #'�Jà-1¯[©[«]™N˜E 7Ü)¨'Ô3D×EÑEØ8? ¨uÓ 5Ü!+¨G´Z×5LÑ5L×!MÑ!MØ;EÐ 1°%Ñ 8Ø@G×@PÑ@PÐ 6°uÓ =Ü!+¨G´Z×5PÑ5P×!QÑ!QØ;GÐ 1°%Ñ 8Ø@G×@PÑ@PÐ 6°uÓ =à@GÑ = 
Ð,=Ø8B ¨uÑ 5Þ#4ÜAJ×AYÒAYÐbsÑAtÐ$7¸Ñ$>Ø,6°q©M 	Ü'1°)¼Y×=UÑ=UÔXa×XqÑXqÑ=q×'rÑ'rÐ rÐ'rØ#'×#>Ñ#>¸yÈtÏÉÐ_dÑOeÐ#>Ö#fØ@D DÔ$=Ü/8×/PÒ/PÐQZÐduÑ/v Þ#1Ø=I O°EÔ$:à*6Ö$6ó9 'røô: ×-Ñ-ó Ü*¨EÐ_ÄCÈÏÉÃKÐSTÓDT°q·v±v¸a²yÐZ^Ñ_×_Ñ_ØûÜ$ó Ü*¨EÐ2×2Ñ2ØðúñG $ðP × Ñ Ñ(Ø×,Ô,�AØ&×*Ñ*¨1Ó-�AØ“}¨¯©Ó)CØ,-¯N©N˜Ô)Ùñ	 -ð × Ñ Ñ(Ø×,Ô,�AØ&×*Ñ*¨1Ó-�AØ“}¨¯©Ó)@ØŸ™Ÿ™×:Ò:¸d×>[Ñ>[Ñ[Õ:ØŸ™Ÿ™×AÑAÔCØŸk™kÐ)ñ -ô *¨.¸$¿(¹(¿-¹-×:]Ñ:]Ô^ØˆFÜ'�Ø—?‘? 1Ñ%¨Ó1Ø&×*Ñ*¨1Ó-�Aà‘yÙ Ø $× 1Ñ 1¸Ð =× wÀ!Ç&Á&×BUÑBUÐY]×YjÑYj×YwÑYwÑBw�IÞ  T×%I×%Ià%)×%>Ñ%>¸q¿v¹vÖ%F˜EØ"'�Kó &Gð &*×%>Ñ%>¸qÈIÐ%>Ó%V˜EØ"'�Kó &WàÕ(Ø×%Ñ%×,Ñ,¨^Ñ->Ô?Ø-×1Ñ1°!Ô4ö &¨!Ó*>Ø-Ñ0Ó0Ø .Ô 1˜Ü% d¬I×,OÑ,O×PÓPÜ"+×"FÒ"FÈDÑ"QÕQô !2ñ+ (ó0 (�ØÕ+Ø×%Ñ%×,Ñ,Ð-@Ñ-CÔDØ)×-Ñ-¨aÖ0ñ (ö Ü-¨n¸d¿h¹h¿m¹m×>aÑ>aÔbÛ'�ØÕ&¨1Ð4MÕ+MØ×%Ñ%×,Ñ,¨^Ñ->Ö?ñ (ó (�ØÕ+°Ð9NÕ0NØ×%Ñ%×,Ñ,Ð-@Ñ-CÖDò (øö Ü-¨n¸d¿h¹h¿m¹m×>aÑ>aÔbÛ'�ØÕ&¨1Ð4MÕ+MØ×%Ñ%×,Ñ,¨^Ñ->Ö?ñ (ó (�ØÕ+°Ð9NÕ0NØ×%Ñ%×,Ñ,Ð-@Ñ-CÖDò (úð 	×%Ñ%Ø�O‰OØ$5Ø'=Ø×.Ñ.Ø"×4Ñ4ð 	&ñ 	
ð 	�‰�‰×*Ò*¨d×.KÑ.KÑKÖ*ùs-  …AaÁA5ÁaÁ%A<Á)A:Á*A<Á-aÁ:A<Á<6aÂ6aÃAaÄ%	D9Ä2D9Ä8A aÅ9
] Æ<G Æ?] Ç3M<Ç;M8Ç?HÈ M8ÈE5M<Í9] Í<O-Î6OÏO	ÏOÏO-Ï%O(Ï&O-Ï-3] Ð$] Ð3A] Ñ:] Ò	E$] ×1A%] Ù(] Ú2] Ú89aÛ5aÛ=)aÜ*aÜ2"aÝ:_1Þ_1Þ)_1ß_1ß"_1ß1A(a)r€   rÕ   Nr»  rÇ  rƒ   rR   rC   r¸   r¸   ‹  s   † ñ÷lLrR   r¸   )r<   zset[asyncio.Task[TaskResultT]]r=   z list[_messages.AgentStreamEvent]rˆ  zEAsyncIterator[_messages.AgentStreamEvent | asyncio.Task[TaskResultT]])rO   r}   rP   zexceptions.RunCancelledrˆ  r½  )rh   r   rO   r}   ra   z_messages.ToolPartKind | Nonerˆ  zctuple[_messages.ToolReturnPart, str | Sequence[_messages.UserContent] | None, Sequence[str] | None])ro   z Sequence[_messages.ToolCallPart]rˆ  z	list[str]r¾  )rf   zSequence[str]r“   zToolManager[Any]rŒ   z
str | Nonerˆ  rº  )rŸ   zdict[int, _FunctionCallParts]r    zset[str]rˆ  rº  )r§   rÎ   r¨   zCallable[[int], bool]rˆ  zlist[list[int]])r“   rÂ   r²   rÃ   r³   rÄ   r´   rÅ   r€   r   rŽ   rÆ   rµ   rÇ   r¬   z-deque[result.FinalResult[NodeRunEndT]] | Nonerˆ  r¼  )_Ú
__future__r   Ú_annotationsr0   r�   ri  Úabcr   r   Úcollectionsr   r   Úcollections.abcr   r	   r
   r   r   r   Úcopyr   Útypingr   r   r   r   r   Útyping_extensionsr   r   Úpydantic_ai._run_contextr   Úpydantic_ai._utilsr   Úpydantic_ai.tool_managerr   r   Úpydantic_graphr   Úpydantic_graph.basenoder   Ú r   r   r   rM   r    Ú_deferred_capabilitiesr!   r"   r#   rf   r$   r%   r&   r'   r(   Ú_agent_graphr)   r*   r+   r,   rD   r*  rž  r0  r8  r9  r:  r¦  rQ   rk   rr   ry   Ú	dataclassr{   rc   rN   rP  r›   Ú_FunctionCallPartsÚtupler^   ÚUserContentrm  rn  Ú_ToolCallPayloadr–   r¥   r«   r¿   rÁ   r¹   rº   r¸   rƒ   rR   rC   Ú<module>rü     sZ  ðÝ 2ã Û Û ß #ß *ß ]× ]Ý ß =Õ =ç 3å 6Ý /ß CÝ *Ý /ç @Ó @Ý :ß 7ß _Õ _æß=á�Ó€Ù�mÓ$€ð/Ø+ð/à9ð/ð Kô/ðj 4Ð Ød€Ø*hÐ 'ØpÐ ØUÐ ØNÐ Ø(cÐ %ðØ
 ðØ)@ðàôð03aØð3að !ð3að -ð	3að
 iô3aôlð #ñ	0Ø
 ð0à
>ð0ð ð	0ð
 -õ0ð ×Ñô+˜ Ñ,ó +ó ð+ð$ ˜)×2Ñ2°Y×5NÑ5NÑNÐQZ×QtÑQtÑtÑuÐ ð �kÑ"ØÐ  h¨y×/DÑ/DÑ&EÑ EÈÑ LÐLÑMñNà×Ññð ×!Ñ!ñ"ð ð eiñØðØ(8ðØWaðà	õðDØ1ðØJRðà	ôô8ð> JNñC;Ø$ðC;ð -ðC;ð Nð	C;ð
 9ðC;ð 9ðC;ð 
NðC;ð 3ðC;ð GðC;ð /õC;ðL ×ÑôUj˜ ¨Ð!3Ñ4°có Ujó ðUjðp ×ÑôÐ(¨°Ð);Ñ<ó ó ðð6 ×ÑôLÐ+¨E°;Ð,>Ñ?ó Ló ðLð8 ×ÑôvLÐ-¨e°[Ð.@ÑAó vLó ñvLrR   