"j0%SSKJr SSKrSSKJrJrJr SSKJr SSK J r SSK J r J r Jr SSKJrJrJrJr SSKJr S S KJrJr S S KJr S S KJrJrJrJ r S S K!J"r"J#r# S SK$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r. S SKJ/r/J0r0J1r1 S SK2J3r3J4r4J5r5J6r6J7r7 S SK8J9r9J:r: S SK;Jr> \Sr?\ "SSS9r@S\AS'\\3\4/\S4rB\\C/\S4rD\ "SS\\"55rE"SS\'5rF"SS\G5rHS#S jrI\ "S!S"\\"55rJg)$) annotationsN) AwaitableCallable Generator)contextmanager) ContextVar) dataclassfieldreplace) TYPE_CHECKINGAnyGenericLiteral)ValidationError)_usage_attributionmessages)filter_deferred_results) OutputSchema OutputToolsetrun_output_process_hooksrun_output_validate_hooks) AgentDepsT RunContext) ApprovalRequired CallDeferred ModelRetrySkipToolExecutionSkipToolValidation ToolFailedToolFailedErrorToolRetryErrorUnexpectedModelBehavior UserError)RetryPromptPart ToolCallPart ToolReturn)DeferredToolRequestsDeferredToolResults ToolApprovedToolDefinition ToolDenied)AbstractToolset ToolsetTool)RunUsage)AbstractCapability)parallel sequentialparallel_ordered_eventsparallel_execution_moder1)defaultz!ContextVar[ParallelExecutionMode] _parallel_execution_mode_ctx_varcx\rSrSr%SrS\S'S\S'S\S'S \S 'S rS \S 'S rS\S'S rS\S'Sr g )ValidatedToolCall8a0Result of validating a tool call's arguments (may represent success or failure). This separates validation from execution, allowing callers to: 1. Know if validation passed before executing 2. Emit accurate `args_valid` status in events 3. Handle validation failures differently from execution failures r&callToolsetTool[AgentDepsT] | NonetoolRunContext[AgentDepsT]ctxbool args_validNdict[str, Any] | Nonevalidated_argsz'ToolRetryError | ToolFailedError | Nonevalidation_errorz&CallDeferred | ApprovalRequired | Nonedeferral) __name__ __module__ __qualname____firstlineno____doc____annotations__rBrCrD__static_attributes__rEU/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/tool_manager.pyr8r88s` & ((> -I,0N)0AE=DM7;H4;rMr8c0^\rSrSrSrSU4SjjrSrU=r$)_ToolUnavailablebuA `ModelRetry` refusing a call because the tool is not available yet. A distinct type only so `_make_validation_failure` can recognise it. It reaches the model as an ordinary retry prompt, exactly like the `ModelRetry` it replaced. Carries the tool it refused: the refusal is raised while resolving, before the caller has bound the resolved tool, and the budget this failure is charged against is the tool's own `max_retries` — not the manager's default, which is all an unresolved name could offer. c0>[TU]U5 X lgN)super__init__r<)selfmessager< __class__s rNrU_ToolUnavailable.__init__ms ! rM)r<)rWstrr<zToolsetTool[Any]rFrGrHrIrJrUrL __classcell__rXs@rNrPrPbsrMrPc0^\rSrSrSrSU4SjjrSrU=r$)_ValidationDeferralraInternal signal that validation requested approval for or deferred the tool call. Raised for a deferral from the tool's `args_validator` or from a validation hook that already has validated arguments. Carries those arguments alongside the user's deferral so `validate_tool_call` can report the call as valid and re-raise the deferral at the execution boundary. Never escapes `ToolManager`. c:>XlX l[TU] 5 grS)rDrBrTrU)rVrDrBrXs rNrU_ValidationDeferral.__init__{s , rM)rDrB)rDCallDeferred | ApprovalRequiredrBdict[str, Any]r[r]s@rNr_r_rsrMr_cL[SUS[U5RS35$)uoBuild the error for a tool validation hook that deferred before the arguments were validated. A tool call may only be deferred once its arguments are known to be valid — whoever resolves the deferral is shown those arguments. Hooks that run before validation (or after it failed) have none, so they get this error instead; the message names the positions that do. `z ` raised `z`, but a tool call can only be deferred once its arguments have been validated. Raise it from `after_tool_validate`, from the tool's `args_validator`, or from `before_tool_execute` instead.)r$typerF) hook_nameerrors rN_validate_hook_deferral_errorrjs3  I;je!5!5 67) ) rMc\rSrSr%SrS\S'SrS\S'SrS\S 'SrS \S '\ "\ \ S 9r S \S'\ "\ \ S 9r S \S'\ "\ \ S 9rS \S'SrS\S'SrS\S'\\S;SSj5rS?SjrS@SjrSASjrSBSjr\SCSj5r\SDSj5rSSS .SES!jjrSS".SFS#jjrSGS$jr S%S&.SHS'jjr!SIS(jr"SJS)jr#SKS*jr$SLS+jr%SSS%S,.SMS-jjr&S%S&.SNS.jjr'SS%S/.SOS0jjr(S%S&.SPS1jjr)SS%S/.SQS2jjr*S%S&.SHS3jjr+S%S&.SHS4jjr,SSS%SSS5.SRS6jjr-SSS7jr.S%SS8.STS9jjr/S:r0g)U ToolManagerzManages tools for an agent run step. It caches the agent run's toolset's tool definitions and handles calling tools and retries.zAbstractToolset[AgentDepsT]toolsetNz%AbstractCapability[AgentDepsT] | Noneroot_capabilityzRunContext[AgentDepsT] | Noner>z)dict[str, ToolsetTool[AgentDepsT]] | Nonetools)default_factoryzset[str] failed_toolssucceeded_toolsavailability_refusedrintdefault_max_retrieszfrozenset[str] | Noneresolved_capability_idsc## [RU5nSv [RU5 g![RU5 f=f7f)aSet the parallel execution mode during the context. Args: mode: The execution mode for tool calls: - 'parallel': Run tool calls in parallel, yielding events as they complete (default). - 'sequential': Run tool calls one at a time in order. - 'parallel_ordered_events': Run tool calls in parallel, but events are emitted in order, after all calls complete. N)r6setreset)clsmodetokens rNr4#ToolManager.parallel_execution_modes<144T: :  , 2 25 9 , 2 25 9sA 3A A  A c # [UR5nSnURbURURR:Xa1X R:XaU$Sn[ XRR S9nOURR R5VVs0sHupEX@R;dMXE_M nnnURURVs0sH,nXpRR RUS5S-_M. sn5 [ XS9nU(a URO"URRU5IShvN nURUURUUR!U5IShvN UR"UR$UU(a URO[&[("5U(a URO[&[("5S9 n XlU $s snnfs snfNNz7f)aUBuild a new tool manager for the next run step, carrying over the retries from the current run step. Re-resolves within a step as well, when capability availability moved since the cached tools were resolved (see `resolved_capability_ids`), so a capability that became active mid-step still gets its `prepare_tools` say over its own tools. FNT)retriesrr) rnror>rprvrtrwrrrs) frozenset_dispatch_active_capability_idsr>run_steprwr ritemsrsupdaterrgetrn for_run_steprXro get_toolsrvrtryrZ tool_manager) rVr>rw same_step tool_namecountrfailed_tool_namernnew_tms rNrToolManager.for_run_steps#,C,O,O"P 88 ||txx000*.J.JJK ! c88+;+;<-1HH,<,<,B,B,D,D(  (<(<<%I$,D 150A0A0A,)((*:*:*>*>?OQR*SVW*WW0A c3 #,$,,t||7P7PQT7U1U 00))#.. $ 8 8!%!:!:$;/8**SXZ4=D003s8:   " I 2V /sDB!H#G1<G1H3G7AHG<0HG>A9H>HcURc [S5eURR5Vs/sHoRPM sn$s snf)z8The tool definitions for the tools in this tool manager.4ToolManager has not been prepared for a run step yet)rp ValueErrorvaluestool_def)rVr<s rN tool_defsToolManager.tool_defs sC :: ST T*.***;*;*=>*=$ *=>>>sA c*[R5$)aGet the run-scoped parallel execution mode set via [`parallel_execution_mode`][pydantic_ai.tool_manager.ToolManager.parallel_execution_mode]. Per-tool `sequential=True` barriers are applied separately during execution and don't affect this run-scoped mode: a single barrier tool no longer forces the whole batch serial (the v1 behavior). Use `parallel_execution_mode('sequential')` to opt the entire run into serial execution. )r6r)rVs rNget_parallel_execution_mode'ToolManager.get_parallel_execution_modes03355rMcfURUR5nUSL=(a UR$)zWhether a tool call must run as a barrier (`sequential=True`), executing alone. Tools emitted before a barrier complete first; the barrier runs by itself; tools emitted after it start only once it finishes. Other tools parallelize around it. N) get_tool_defrr2)rVr:rs rN is_sequentialToolManager.is_sequentials. $$T^^4t#;(;(;;rMcURc [S5eURRU5nUb UR$S$)zPGet the tool definition for a given tool name, or `None` if the tool is unknown.Nr)rprrr)rVnamer<s rNrToolManager.get_tool_def$s> :: ST Tzz~~d# $ 0t}}:d:rMcURceURRRUS5U:a[SU<SUS35Ueg)zGRaise UnexpectedModelBehavior if the tool has exceeded its max retries.NrTool z exceeded max retries count of z. Consider raising the retry limit, or see the docs on tool retries: https://pydantic.dev/docs/ai/tools-toolsets/tools-advanced/#tool-retries)r>rrr#)rVr max_retriesris rN_check_max_retriesToolManager._check_max_retries+sexx### 88    a (K 7)x>{mLCC  8rMcV[R"X URS9n[U5$)zSConvert a ValidationError or ModelRetry to a ToolRetryError with a RetryPromptPart.)r tool_call_id)r% from_errorrr"rr:rims rN_wrap_error_as_retry ToolManager._wrap_error_as_retry6s'  & &u4K\K\ ]a  rMcn[R"UURURSS9n[ U5$)zGConvert a ToolFailed to a ToolFailedError with a failed ToolReturnPart.failed)rcontentroutcome) _messagesToolReturnPartrWrr!rs rN_wrap_error_as_failed!ToolManager._wrap_error_as_failed<s7  $ $MM**   q!!rMF)approvedmetadatac URce[URUURURURRR URS5UR UUUS9 $)z,Build the execution context for a tool call.r)rrrretryrtool_call_approvedtool_call_metadatapartial_output)r>r rrrrr)rVr:r< allow_partialrrs rN_build_tool_contextToolManager._build_tool_contextGsmxx### HH nn**((""&&t~~q9((''(  rM) args_overridec# UbUO URnU(aSOSnURn[U[5(a$UR U=(d SXsR S9n O#UR U=(d 0XsR S9n URb;UR"U40U D6n [R"U 5(a U IShvN U $U $N![[4an [X5U eSn A ff=f7f)a^Validate tool arguments using Pydantic schema and custom args_validator_func. Returns: The validated arguments as a dictionary. Raises: ValidationError: If argument validation fails. ModelRetry: If argument validation fails with a retry request. _ValidationDeferral: If the custom validator requested approval or deferred the call. Nztrailing-stringsoffz{})rcontext) argsargs_validator isinstancerZ validate_jsonvalidation_contextvalidate_pythonargs_validator_funcinspect isawaitablerrr_) rVr:r<r>rrraw_argspyd_allow_partial validator args_dictresultes rN_validate_tool_argsToolManager._validate_tool_argsbs&%2$==4992?.U'' h $ $!// D0AKaKa0I"11B.?I_I_2I  # # / ?11#CC&&v.. LLy! "23 ?*!7Q>  ?s<BC73CC C C7CC4# C//C44C7c ^^^^^^ # TRnSm S UUUU UU4SjjnUbTRRS:waTRnTRb TRO0nUR TTXxS9IShvN nSn URTTXxUS9IShvN n URTTX{S9IShvN n U b[U RU 5U eU $U"TRb TRO05IShvN n U $N![ [ 4an [SU 5U eSn A ff=fN![an U n U Rn Sn A NSn A f[ [ 4a(n T c [SU 5U e[U T 5n T n Sn A NSn A f[[4aLn URTTXxU S9IShvN n Sn A GN![ [ 4an [S U 5U eSn A ff=fSn A ff=fGN+![ [ 4an [X5U eSn A ff=fGN 7f) z:Run validation with before/wrap/after tool_validate hooks.NcN># TRTTTTUS9IShvN nUmU$N7f)N)rr)r)r validatedrr:r>handler_validated_argsrVr<s rN do_validate4ToolManager._run_validate_hooks..do_validates<#66tT3Vcsw6xxI&/ "  ys %# %outputr:rrbefore_tool_validater:rrhandlerwrap_tool_validater:rrrion_tool_validate_error)rstr | dict[str, Any]returnrd)rorkindrrrrrjrr_rBrrrafter_tool_validaterD)rVr:r<r>rcaprrrrrDrB hook_deferralrs````` @rN_run_validate_hooksToolManager._run_validate_hookssN""8<   ?t}}11X=}}H;?)):OTYYUWH V!$!9!9#DS[!9!kk 48H t'*'='=dXk(>(": D'*'>'>sX`'>'v!v #*(*;*;^LRZZ$$/DIIDH D*D(D* G"4G5G"9AH :H;H DD% D  D%%H (D** G4EH GE=8H =GF2&F)'F2,H 2G GGGGH G""H2 G>>HH Twrap_validation_errorsc H^^^^# TRceTRceTRnTRnTRnSUUUU4SjjnUbTRR R S:waoTRR nURXeUTRS9IShvN n URXeXUS9IShvN n UR%XeXU S9IShvN n U $U"TR5IShvN n U $NUN=![[[[[4a e[[4a e[ a$n UR#XeXU S9IShvN n Sn A NSn A ff=fN![&[4ann T(deUR(n TR+U TRR,U 5 TR.R1U 5 TR3XU 5U eSn A f[a*n T(deTR5UR(X[5U eSn A ff=fGN 7f) z8Run execution with before/wrap/after tool_execute hooks.NcV># [TUS9nTRUTTS9IShvN $N7f)N)rBusager)r _raw_execute)rmodified_validatedrVrrrs rN do_execute2ToolManager._run_execute_hooks..do_executes=!(4!H **"%H^+ s )')rrrr)r:rrr)rrdrr )r<rBror:r>rrbefore_tool_executewrap_tool_executerrrr"r!r r Exceptionon_tool_execute_errorafter_tool_executerrrrrraddrr) rVrrrrr:r>rrr tool_resultrrs ```` rN_run_execute_hooksToolManager._run_execute_hookss~~)))''333""~~mm   ?y~~66;;xG ~~..H! Q 44Sh]f]u]u4vv y(+(=(=j)>)#K%($:$:X%;% (!+9+C+C DDKGw#*<9I>[jk"J/ y(+(A(A#[cvw(A(x"x"xKy$Z0 F.~~''inn.H.H!L!!%%d+//A>AE Q-00IqP Q EsB H"E,0D1E,6D D D E,#E*$E,(H"?HH"E,D 9E'E"EE"E,"E''E,,H# UH5upTRRUR5(dM1Uv M7 g7frS)r>is_tool_availabler).0ntrVs rN ,ToolManager._resolve_tool..+s/j-?TQ488C]C]^_^h^hCiqq-?s 0A AzAvailable tools: z, c3(# UHo<v M g7frSrE)rrs rNrr-s3PieHisz:No tools are available yet: search for the tools you need.zNo tools available.zUnknown tool name: z. ) rpr>rrrsortedrjoinr_unavailable_reasonrrP)rVr:rr< availablemsg unavailables` rN _resolve_toolToolManager._resolve_tool s :: !1ST T~~zz~~d# <jTZZ-=-=-?jjI)$))3Pi3P*P)QRR+24("SEBC C33DMMB BK O";5 5zrMcURceURRU5(agUR=nb.X RR;aSUR<SU<S3$SUR<S3$)u#Why this tool cannot be called yet, or `None` when it is available. A deferred tool is callable only once the model has been shown it. The message says *not available yet* rather than "unknown tool" so the model searches or loads again instead of concluding the tool does not exist — and the resulting search/load exchange restores the history that justifies the call, which is what keeps a compacted history coherent. Both requirements apply to a capability-owned tool: an active capability is what makes its tools *eligible* to be shown, not proof that any of them were. An always-on capability can own search-gated tools, and loading a deferred one reveals its tools through the same availability delta everything else uses — so discovery stays the single answer to "has the model seen this?". Nrz0 is not available yet: it belongs to capability zo. Call `load_capability` for it first, then call the tool again once you've read the capability's instructions.z[ is not available yet: search for it first, then call it again once you've seen its schema.)r>r capability_idactive_capability_idsr)rVrrs rNrToolManager._unavailable_reason7sxx### 88 % %h / /&33 3M @ !?!? ? ((X #$BB  HMM$%+ + rMc [UUUSUSS9$)zRBuild a successful `ValidatedToolCall`. Counterpart to `_make_validation_failure`.TNr:r<r>r@rBrC)r8)rVr:r<r>rBs rN_make_validation_success$ToolManager._make_validation_successXs#!)!   rMc Ub URO URn[U[5(a+[UR[ 5(a UROUn[U[ 5(a+XR;aURRU5 O-URXU5 URRU5 [U[5(aUOURXU5n[UUUSSUS9$)aHandle validation failure: check retries, mark failed, wrap error. Only called when wrapping is requested (`wrap_validation_errors=True`); when False (streaming, or sandboxed callers that want raw errors), the caller lets the exception propagate without going through this helper. NFr) rrvrr" __cause__rrPrtrrrrrr8) rVrr:r<r>rircauserCs rN_make_validation_failure$ToolManager._make_validation_failureis+/*:d&&@X@X )%@@ZPUP_P_ajEkEkEOOqv  e- . .4?X?X3X  % % ) )$ /  # #Du =    ! !$ '$.un$E$E54KdKdeiqvKw -   rMrrrc "# URceURnSnURU5upvURXSX#S9nURXUSS9IShvN nUR XXX5$N![ a+n UceUR XXYR 5sSn A $Sn A f[a=n Uce[UR XXYR 5U RS9sSn A $Sn A f[[4aPn U(de[U [5(a U RnURUR XXY5sSn A $Sn A f["a:n U(de[%UUUSSUR'UR X5S9sSn A $Sn A ff=f7f)uValidate tool arguments without executing the tool. This method validates arguments BEFORE the tool is executed, allowing the caller to: 1. Emit `FunctionToolCallEvent` / `OutputToolCallEvent` with accurate `args_valid` status 2. Handle validation failures differently from execution failures 3. Decide whether to execute or defer based on validation result A tool call can be deferred during validation by raising [`ApprovalRequired`][pydantic_ai.exceptions.ApprovalRequired] or [`CallDeferred`][pydantic_ai.exceptions.CallDeferred] — but only once its arguments are known to be valid, which the caller is shown. That means the tool's `args_validator`, `after_tool_validate`, or `wrap_tool_validate` after its handler has returned; the same exception raised before validation has run raises a `UserError` naming the alternatives. A permitted deferral is control flow rather than a validation failure: the returned `ValidatedToolCall` has `args_valid=True` and carries the exception on [`deferral`][pydantic_ai.tool_manager.ValidatedToolCall.deferral], which `execute_tool_call` raises in place of running the tool, so callers handle deferrals in one place. Args: call: The tool call part to validate. approved: Whether the tool call has been approved. metadata: Additional metadata from DeferredToolResults.metadata. wrap_validation_errors: If True (default), wrap `ValidationError` / `ModelRetry` as `ToolRetryError` on the returned `ValidatedToolCall.validation_error`, count the call against the retry budget, and add it to `failed_tools`. `ToolFailed` is wrapped as `ToolFailedError` without consuming the retry budget. If False, propagate the raw exception and leave retry-budget state untouched — useful for nested callers (e.g. sandboxed tool dispatch) where validation failures shouldn't consume the agent's retry budget and the raw exception is what the caller wants to surface. Returns: ValidatedToolCall with validation results, ready for execution via execute_tool_call(). NF)rrrr)rDr)r>r rrrrrBr_r rDrrrrPr<rrr r8r) rVr:rrrr>r<_namerBrs rNvalidate_tool_callToolManager.validate_tool_callsVxx###hh/3$ ,,T2KE**4UU]*qC#'#;#;D[`#;#aaN00SQ Qb! T# ##00SBRBRS S" r# ## 488SJZJZgfpfpq q, U)!-..vv00ST T )$ #!%!;!;DNND!T   sF8A2A0A2/F0A22 F < B"F F" F /2C'!F "F'F :AE?F F F /FF FF  Fc# URc [S5eURXRRUS9IShvN $N7f)aExecute a validated tool call via capability hooks. The Instrumentation capability (if present) creates trace spans via its wrap_tool_execute hook. Args: validated: The validation result from validate_tool_call(). wrap_validation_errors: If True (default), `ModelRetry` raised by the tool body or by execute-stage capability hooks (`before_tool_execute`, `after_tool_execute`, `wrap_tool_execute`) is wrapped as `ToolRetryError` after counting against the retry budget. If False, the raw `ModelRetry` / `ValidationError` propagates and retry-budget state is left untouched. Returns: The tool result if validation passed and execution succeeded. Raises: ToolRetryError: If validation failed with a retry prompt or the tool raised `ModelRetry`. Only when `wrap_validation_errors=True`. ToolFailedError: If validation failed with `ToolFailed`, or the tool raised `ToolFailed`. Only when `wrap_validation_errors=True`. ModelRetry / ValidationError / ToolFailed: When `wrap_validation_errors=False`. CallDeferred / ApprovalRequired: If the tool's `args_validator` deferred the call (see [`ValidatedToolCall.deferral`][pydantic_ai.tool_manager.ValidatedToolCall.deferral]) or the tool function raised one of these itself. The tool is not executed in the former case. RuntimeError: If trying to execute an external tool. Nrr)r>r_execute_tool_call_implr)rVrrs rNexecute_tool_callToolManager.execute_tool_callsNF 88 ST T11 XX^^DZ2    sAA AA )rrc ^^^# URceURU5upV[UR[5(d'S[ UR5R 35eURXTS9mURnURUmTRUSXRS9nS UUU4Sjjn URn U cS5eURb URO0n [U TUU U TUS9IShvN n TR=n bX0nOU nURXTU5$N,![ ["[$4a&nU(deUR'XQUTU5sSnA$SnAff=f7f) aValidate output tool args through output validate hooks (skipping tool hooks). Output tools use output hooks for validation instead of tool hooks. The Pydantic schema validation is used as the inner handler wrapped by output validate hooks. `schema` is the run's output schema; it's forwarded to [`OutputContext`][pydantic_ai.output.OutputContext] so hooks can see the full shape of what the schema accepts. Raises: UnexpectedModelBehavior: If max retries exceeded. NzExpected output tool, got rr<r| tool_callrc6># TRUTTS9upU$7f)N) run_contextr) hook_validate)rsemantic_staterr> processors rNr:ToolManager.validate_output_tool_call..do_validate6s&(66t\i6j HOsz2validate_output_tool_call requires root_capability)r)output_contextrrrr)rrrr )r>r rrnrrgrFr processorsget_output_contextrrorrhook_unwrap_keyrr"rrr)rVr:schemarrrr<rnr/rrrsemantic_valuekrBrr>r-s ` @@rNvalidate_output_tool_call%ToolManager.validate_output_tool_calls(xx###''- $,, 66r:TUYZ^ZfZfUgUpUpTq8rr6&&t&O,,&&t, "55f6UYdqdq5r  ""T TT K:>)):OTYYUWH#<-'+'=$N ...;9:8K!/00S.Q Q)*< K)00T3J J KsHCE/-D1D/+D1.E//D11E,E'!E,"E/'E,,E/c V^^^^# TR(deTRceURceTRRnTRR m[ T[5(deTRnTRUmTRUSTRURS9nTR=nb1[ TR[5(deTRUnO TRnTRce[TRURR TRS9mSUUUU4Sjjn UR"n U cS5e[%U TRUUU US9IShvN n U(aUR2R1U5 U $N(![&ajn [ U R([*5(a U R(OU n UR-XERU 5 UR.R1U5 eSn A ff=f7f) aaExecute output tool through output process hooks (skipping tool hooks). Output validators run inside process hooks (inside wrap_output_process), ensuring the complete output pipeline is wrapped. Validators see the global output retry context (from self.ctx), not the per-tool context, matching the text output path. `schema` is the run's output schema; it's forwarded to [`OutputContext`][pydantic_ai.output.OutputContext] so hooks can see the full shape of what the schema accepts. Raises: ToolRetryError: If execution or output validation fails. UnexpectedModelBehavior: If max retries exceeded. Nr<r&)rrc># TRUSTRSS9IShvN nTRHnUR UT5IShvN nM U$N3![a ef=fN7f)NF)r)r) hook_executer>routput_validatorsvalidate)rrrr-rnr validator_ctxs rN do_process8ToolManager.execute_output_tool_call..do_processs (55DimmTY 6 %66 (11&-HH7M    Is7A+AAA$A+ A) A+A A&&A+z1execute_output_tool_call requires root_capability)r)r/rr>r)rr rr )r@r<r>r:rrnrrr0r1rr2rBdictrr rrorr"rrrrrrrs)rVrr3rrr<r/r5r4r>rrrrr-rnr=s ` @@@rNexecute_output_tool_call$ToolManager.execute_output_tool_callYs*####~~)))xx###~~''..(('=1111~~&&t, "55 9>>DMM6 ** *A 7i66== =="+":":1"=N&55N""... TXX^^QXQdQde   *""S SS 3%MM-%%'= F "  $ $T * # #-akk9#E#EAKK1E  # #D*:*:E B    ! !$ '   s=E%H),F2F0F2 $H)0F22 H&> " " ' ': 5@A A # $ 7 7?U!8!K "  $ $Y^^%=%= >! #  / / 6((K #sBBD!C()C&*C(.8D!&C(( D2"DD!DD!c# URceURceURRnURR UURUR UR5IShvN n[R "U5 U$N![a*nU(deURXARU5UeSnAf[aknU(deURXARRU5 URRU5 URXARU5UeSnAff=f7f)z7Execute a validated tool call without hooks or tracing.N)r<rBr:rrn call_toolr>r rrrrrrrrrrI)rVrrrrrrs rNrToolManager._raw_executes~~)))''333~~'' L $ 6 6((  !K" ++E2'  M),,T>>1E1 L L)  # #D..*D*Da H    ! !$ '++D..!D! K  LsG5E?B7B8B<EB D= %C D=A&D88D==E)rrron_inline_deferred on_validatecf# URUUUUS9IShvN nUbU"UR5IShvN U(dvUR(aeURcXUR=nbIUR R (a.UR RS:Xa [5e[5eURXtS9IShvN $N![a UbU"S5IShvN ef=fNN+![[4a%n URUU UUS9IShvN sSn A $Sn A ff=f7f)u Handle a tool call by validating the arguments, calling the tool, and handling retries. This is a convenience method that combines validate_tool_call() and execute_tool_call(). If the tool or its `args_validator` raises [`ApprovalRequired`][pydantic_ai.exceptions.ApprovalRequired] or [`CallDeferred`][pydantic_ai.exceptions.CallDeferred], the capability handler (if any) is invoked to resolve it inline; otherwise the exception propagates. Args: call: The tool call part to handle. approved: Whether the tool call has been approved. metadata: Additional metadata from DeferredToolResults.metadata. wrap_validation_errors: If True (default), validation failures surface as `ToolRetryError` (after counting against the retry budget) or `ToolFailedError` (without consuming the retry budget). If False, the raw `ValidationError` / `ModelRetry` / `ToolFailed` propagates and retry-budget state is left untouched — useful for nested callers (e.g. sandboxed tool dispatch) where the call shouldn't consume the agent's retry budget and the raw exception is what the caller wants to surface. on_inline_deferred: Internal callback invoked when a capability resolves a deferred call inline. on_validate: Internal callback invoked with the argument-validation outcome before execution. Returns: The tool's return value on success — possibly a [`ToolReturn`][pydantic_ai.messages.ToolReturn] wrapper if the tool or handler supplied one. A [`ToolDenied`][pydantic_ai.tools.ToolDenied] instance if a [`HandleDeferredToolCalls`][pydantic_ai.capabilities.HandleDeferredToolCalls] handler denied the call. **Callers must `isinstance`-check the result** before treating it as a successful tool return — `ToolDenied` is *not* a valid tool result and the message string alone is indistinguishable from a real return value. Surfacing the denial (e.g. recording `ToolReturnPart(outcome='denied')` in message history, or raising inside a sandbox) is the caller's responsibility. Raises: ToolRetryError: The handler requested a retry, or the (re-)executed tool raised `ModelRetry`. Only when `wrap_validation_errors=True`. ValidationError / ModelRetry: When `wrap_validation_errors=False` and the arguments fail validation or a hook raises `ModelRetry`. CallDeferred / ApprovalRequired: No handler resolved the call, or the approved tool re-raised a deferral. rNFrGrrrN) r BaseExceptionr@rDr<rdeferrrrr#_resolve_single_deferred) rVr:rrrrNrOr deferred_toolexcs rN handle_callToolManager.handle_call5sCl "55!!'= 6I  "i223 3 3 ((&&.&/nn4]A!**00 )6(>(>(C(Cz(QlniWgWii// /ii iM  &!%(((    40j./ 66'=#5 7  sD1CCCD1C5D1BC9 C7 C9D1CC2*C-+C22D17C99D. D)D!D)#D.$D1)D..D1c# URb URcgURRURUS9IShvN nUb [X5$S$N7f)aInvoke the capability handler to resolve deferred tool calls. Args: requests: The deferred tool requests to resolve. Returns: `DeferredToolResults` with results for some or all calls, or `None` if no handler is available or the handler declined to handle the requests. N)requests)ror>handle_deferred_tool_callsr)rVrZresultss rNresolve_deferred_tool_calls'ToolManager.resolve_deferred_tool_callss_    '488+;,,GG[cGdd=D=P&x9ZVZZesAAAArQc# [[U[5(aU/O/[U[5(aU/O/UR(aUR UR0O0S9nUR U5IShvN nUcUeUR5RUR 5nUcUeUbU"XV5IShvN [U[5(aU$[U[5(a%U(dUeURURX5e[U[5(axUnURb[XRS9nURRUR 5n UR!USU US9IShvN n UR#XS9IShvN $[U[$5(a=['[(R*"UR,URUR S95e[U[(R*5(a-URUl UR Ul['U5eUR.UR $GNGNNN7f)uResolve a single deferred tool call inline using the capability handler. Dispatches the handler's result for `call` on the same set of [`DeferredToolResult`][pydantic_ai.tools.DeferredToolResult] variants as the batch path in `_agent_graph._call_tool`, but returns a raw tool-like value (what the tool "would have returned") rather than a message-history part. NOTE: keep the dispatch branches here in sync with [`_call_tool`][pydantic_ai._agent_graph._call_tool] — both paths must accept the full [`DeferredToolResult`][pydantic_ai.tools.DeferredToolResult] surface. `wrap_validation_errors` is forwarded to the post-approval re-validation and re-execution so callers passing `False` (e.g. sandboxed dispatch) keep the same raw-error contract through deferred-tool resolution. Handler-constructed retry signals (`ModelRetry` / `RetryPromptPart` returned by the handler) still surface as `ToolRetryError` regardless — those are handler outputs, not exceptions raised by validation or the tool body. Returns: For approved calls, the raw tool return (possibly a `ToolReturn` wrapper). For external-call results, the value the handler supplied verbatim (plain value or `ToolReturn`). For denied calls, the [`ToolDenied`][pydantic_ai.tools.ToolDenied] instance from the handler — callers must `isinstance`-check before treating the return value as a successful tool result. Raises: ToolRetryError: Handler requested a retry via `ModelRetry` or `RetryPromptPart`, or the approved tool re-raised `ModelRetry` (only when `wrap_validation_errors=True`). ToolFailedError: Handler reported a failure via `ToolFailed`, or the approved tool raised `ToolFailed` (only when `wrap_validation_errors=True`). ValidationError / ModelRetry / ToolFailed: When `wrap_validation_errors=False` and the approved tool's re-validation fails or its body raises `ModelRetry` or `ToolFailed`. CallDeferred / ApprovalRequired: Handler couldn't resolve the call, or the approved tool re-raised a deferral. ) approvalscallsrN)rTrr)rrr)r(rrrrrr]to_tool_call_resultsrr,r rrr* override_argsr rr#rr"rr%rWra) rVr:rVrrNrZdeferred_resultstool_call_result validate_call call_metadatars rNrT$ToolManager._resolve_single_deferreds4Z( *30@ A Atfr&sL994&r:=,,d''6B  "&!A!A(!KK  #I,@@BFFtGXGXY  #I  )$X@ @ @ & 3 3$ # & 3 3)&&,,T^^TT T & 5 5 M--9 '3Q3Q R ,5599$:K:KLM"55&'= 6I // /ii i & 3 3 )),44"nn!%!2!2  & (A(A B B)-  &,0,=,=  ) !12 2 %%d&7&788cL A  jsKA9I%;Ir=rzToolManager[AgentDepsT])rzlist[ToolDefinition])rri)r:r&rr?)rrZrzToolDefinition | None)rrZrrurirrNone)rrZr:r&rizValidationError | ModelRetryrr")rrZr:r&rir rr!) r:r&r<ToolsetTool[AgentDepsT]rr?rr?rr rr=) r:r&r<rkr>r=rr?rzstr | dict[str, Any] | Nonerrd) r:r&r<rkr>r=rr?rrd)rValidatedToolCall[AgentDepsT]rr/rr?rr )r:r&rz#tuple[str, ToolsetTool[AgentDepsT]])rr+rz str | None) r:r&r<r;r>r=rBrArrl) rrZr:r&r<r;r>r=riz-ToolRetryError | ValidationError | ModelRetryrrl) r:r&rr?rr rr?rrl)rrlrr?rr ) r:r&r3OutputSchema[Any]rr?rr?rrl)rrlr3rmrr?rr ) r:r&r3rmrr?rr?rr )r:r&rr?rr rr?rN"InlineDeferredResultHandler | NonerOzToolValidationHandler | Noner"ToolDenied | ToolReturn[Any] | Any)rZr(rzDeferredToolResults | None) r:r&rVrcrr?rNrnrro)1rFrGrHrIrJrKror>rpr ryrZrrrsrtrvrw classmethodrr4rpropertyrrrrr staticmethodrrrrrrr rrrrr#r6rArDr"rrWr]rTrLrErMrNrlrlsK ((@=AO:A2)-C &-87;E 4;"3s8rs1"::%"1177$7. 1   @?ff;9 STjGQzG "C'(<>Q'RT]^bTc'cdX $4!89O & +& &R z  )   @9'*%@9 @9rM