"j%SSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSK J r J r J r J r JrJrJrJr SSKJrJrJrJr SSKJr SSKJr SSKJr SSKJr SS KJrJrJrJ r J!r!J"r"J#r#J$r$ SS K%J&r& SSK'r'SS K(J)r) SS K*J+r+ SS K,J-r- SSK.J/r/J0r0J1r1 SSK2J3r3 SSK4J5r5 SSK6J7r7 SSK8J9r9J:r:J;r;Jr>J?r?J@rAJBrBJCrDJErEJFrG SSK9JHrHJIrIJJrJJKrKJLrLJMrM SSKNJOrOJPrPJQrQJRrR SSKSJTrT SSKr\GR"S?S@9"SASB55r\GR"S?S@9"SCSD55r\SSSSE.SrSFjj5rSsSGjrStSHjrS5SI.SuSJjjrSvSKjr\1"SL5r\1"SM5r\1"SN5r\1"SO5r\"S5r\GR"SPSQ55r\GR"SRSS9"STSU\\\455r\GR"SVSW55r\GR"SXSY\ \\455rSwSZjrSxS[jrS\rS]\S^'\f\l4rS_\S`'SySajr"SbSc\"5rSzSdjrS{SejrS|SfjrS}Sgjr\GR"ShSi\ \55rSSj.S~SkjjrSSljrSSmjrSSnjrSSojr\GR"SRSS9"SpSq\\55rg)) annotationsN)AsyncGenerator AsyncIterable AsyncIterator AwaitableCallable Collection GeneratorSequence)AbstractAsyncContextManagerAsyncExitStackasynccontextmanagercontextmanager) ContextVar)copy)replace)Path) TYPE_CHECKINGAnyClassVarGenericLiteral NamedTuplecastoverload)uuid4) NoOpTracer)to_snake)GenerateJsonSchema)SelfTypeIsTypeVar)DEFAULT_INSTRUMENTATION_VERSION)load_from_registry)DeferredCapabilityLoader) _agent_graph_display_enqueue _instructions_output_system_prompt_utils concurrency exceptionsmessagesmodelsusage) CallToolsNode EndStrategyModelRequestNodeUserPromptNodebuild_run_contextcapture_run_messages)CancellationToken RunBindingRunCancellationtake_run_binding) registered_loaded_capability_ids)AgentInstructions) OutputToolset)dispatch_event_streamset_current_run_context)validate_from_spec_args)PydanticAIDeprecationWarning)AbstractCapabilityAgentCapability AgentModelCombinedCapabilityModelSelection ModelSelector ToolSearch)wrap_capability_funcs)has_capability_type)PendingMessageDrainCapability)_combine_duplicate_capabilities_declares_default_id_reject_class_crossing_id_repeated_id_messageleaf_capabilities)bind_capabilities_tier)EventTHooksOnEventHookFunc)Instrumentation)InstrumentationSettingsInstrumentedModel)AbstractNativeTool)ToolSearchTool) OutputDataT OutputSpecStructuredDict)AgentRunAgentRunResult) ModelSettingsmerge_model_settings) TemplateStr)ParallelExecutionMode ToolManager) AgentDepsTAgentNativeToolArgsValidatorFuncDeferredToolResultsDocstringFormatGenerateToolJsonSchemaNativeToolFunc RunContextSystemPromptFuncToolToolDefinition ToolDeniedToolFuncContextToolFuncEither ToolFuncPlain ToolParamsToolPrepareFuncToolsPrepareFunc)AbstractToolset AgentToolset)DynamicToolset ToolsetFunc)collect_toolset_instructions)parse_discovered_toolsAGENT_TOOLSET_ID)CombinedToolset)FunctionToolset)PreparedToolset) AbstractAgent AgentMetadataAgentModelSettings AgentRealtime AgentRetriesAgentRunEventsEventStreamHandlerEventStreamProcessorRunOutputDataT_RealtimeSessionLifecycle_RealtimeSessionResolution) AgentSpecget_capability_registry) WrapperAgent) Starlette)GraphGraphRunContextresult)AudioRetentionKnownRealtimeModelName RealtimeEvent RealtimeModelRealtimeModelSettingsRealtimeProviderSessionRealtimeSession) ModelsParam)rAgentrrrr_rr`rlr3r4rrrXr5rdr6rr8rCrwrqrT)frozenc.\rSrSr%SrS\S'S\S'Srg)_ResolvedAgentRetriesz-Fully resolved retry budgets used internally.inttoolsoutputN__name__ __module__ __qualname____firstlineno____doc____annotations____static_attributes__rW/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/agent/__init__.pyrrs7 J Krrc \rSrSr%S\S'Srg) _RunLifecycleboolshort_circuitedrN)rrrrrrrrrrrsrr) extract_error result_readyrestore_context_onc  ^^^^^^^^^^^^# [R"5m[R"5mSmSmS UUUUUUUUUU4 Sjjn[T5Vs0sHoRcMURU_M n nTR=n cU TlO!U R 5 U R U 5 TRT5 [R"5m[R"TRTUS95n [R"TR55n [R"X1[RS9IShvN [R"U 5IShvN /mT=(d SH.nTR%USUSR#US545 M0 S U4SjjnUbUR'U5 SUUUU4S jjnU R)5=(a TR+5(+nU(aU"U R-55IShvN [/US 97v U(dTR#5 Tc(Tb T"5(aU"U IShvN 5IShvN OMTbU"U IShvN 5IShvN O0U R)5(dU R;5 U IShvN Tb)TR=TTS 9IShvN nU"U5IShvN TbTeUcU"5 ggs snfGNGN![ a7n U mTR#5 [R"X5IShvN eSn A ff=fGN/![ a4n TbT"U 5OU m[1T[2[445(aeSn A GNXSn A ff=fGN0GN'GNGN![ a6n[1U[R65(d UTLaUTlSnAGNSnAff=fGN%![R6[ 4a GN@f=f!U(dTR#5 Tc*Tb T"5(aU"U IShvN 5IShvN fTbhU"U IShvN 5IShvN f![ a?n[1U[R65(dUTLa UTlSnAfSnAfSnAfSnAff=fU R)5(d=U R;5 U IShvN f![R6[ 4a ff=fff=fGN4GN'![ a nUmSnAGN7SnAff=f!UcU"5 ff=f7f)uDispatch run hooks around a caller-owned run body. `restore_context_on` hands ownership of the propagated-ContextVar restore to the caller's exit stack: registered before the caller pushes later entries (like its toolset), so restore happens in LIFO order after those exit — resources entered inside the propagated context (e.g. the run span set by `Instrumentation.wrap_run`) also *exit* inside it. Without it, this context manager restores on its own exit. Nc > # [T 5 T RT 5IShvN [R"5nSSS5 WVs/sHnUT;d TUXLdMXU4PM snmTR 5 TR 5IShvN Tb TbT"T5eTeT b7T "5(d+[ R[["5IShvN T"5$N!,(df  N=fs snfNmN%7fN) rA before_run contextvars copy_contextsetwaitasyncioFuturer`r) current_ctxvar _run_done _run_error _run_ready _wrap_context build_resultr outer_contextrrun_capabilityrun_ctxs r_do_run%_run_lifecycle_hooks.._do_runs $W - ++G4 4 4%224K.# "-'=+=[EU+U $Sc" #" nn  !/>THupURU5 M gr)reset)rtokencontext_tokenss r_restore_context_vars3_run_lifecycle_hooks.._restore_context_vars5s(JC IIe )rc># TRTUS9IShvN n[R"5 T"U5IShvN SmgN,N 7f)Nr) after_runr-raise_if_cancelling)rrfinalizerrs r_finalize_result._run_lifecycle_hooks.._finalize_result<sJ%///GG ""$v H sAA$AAAA)r)errorreturnAgentRunResult[Any])rNonerrrr)rEventrRid_run_capabilities_by_idclearupdate_prepare_run_contextrr create_taskwrap_runrFIRST_COMPLETEDr-cancel_and_drain BaseExceptionrappendcallbackdoneis_setrr isinstance GeneratorExitKeyboardInterruptCancelledError __context__cancel on_run_error)rrrrrrrr capabilityrun_capabilities_by_idexisting _wrap_task _ready_waiterexccv_pairrrrwrap_excr on_error_excrrrrrrs`````` @@@@@@r_run_lifecycle_hooksrs<J I'+J>BM85Fn4U4UjYfYf! z!4U 333<*@'./''0,,.M$$^%<%>'!*+EFG'%##$9:  !oo'C 0A0A0C,COz0023335$# @ @# %<+?<>>*+;<<<+ >.Z/?@@@$**%%'(((  ! /-::7*:UU'v...  !  "  % ! # &i$ ] 5    %%m@@@  V 4  / *(G4J4JKKPX`jPj5=J2>)#22MB/# %<+?<>>*+;+;<<<+ >.Z/?/?@@@(> *(G4J4JKKPX`jPj5=J22QkK >$**%%'(((#22MB +'#:V/! *)  *  % ! # &sBA UL/LB(U)'LL LU.L /B6U%M&U, M80T2(N) T24N5T2>N$N N$N!N$&T2=O*O'O*T2 TTT# T2.T/ T29U L U M+M MM  MU N!)N P NP T2T2N$!N$$ O$.+OT2O$$T2'O**PT2PT2 1T<P? = T Q  TQ/Q  Q/(Q+)Q/.T/ R89+R3$T3R88(T!S-&S)'S-,T-T T T  TT2TT2 T/"T*$T2*T//T22 T??Uc6[U[R5$)zONarrow a value to a concrete model without losing its client type to `Unknown`.)rr1Model)values r _is_modelrs eV\\ **rcz[U[[R45(a[R"5$S$)a=The source to attribute one of the agent's configured instructions to. Only the literal instructions the agent was built with are addressed by the agent's own key: an instruction function becomes addressable when `@agent.instructions(name=...)` names it, so a bare callable speaks for nobody and stays unidentified. N)rstr _messagesInstructionPartAgentInstructionSource) instructions r_agent_instruction_sourcers02rTS_PreparedDepsT_PreparedOutputTcj\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S\S 'S\S'S\S'Srg) _ResolvedSpeciz>Result of resolving an AgentSpec for use at run/override time.zCombinedCapability[Any] | Nonerz)list[_instructions.AgentInstruction[Any]] instructions str | NonemodelModelSettings | Nonemodel_settingsdict[str, Any] | Nonemetadataname int | Noneoutput_retries tool_retriesrNrrrrrrs5H..;; ((## rrF)initcn\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S'S\S'SrS\S'\R"SS9r S\S'\R"SS9r S\S'\R"SS9r S\S'\R"SS9r S\S'\R"SS9r S\S'\R"SS9rS\S '\R"SS9rS!\S"'\R"SS9rS#\S$'\R"SS9rS%\S&'\R"SS9rS'\S('\R"SS9rS)\S*'\R"SS9rS+\S,'\R"SS9rS+\S-'\R"SS9rS.\S/'\R"SS9rS0\S1'\R"SS9rS2\S3'\R"SS9rS4\S5'\R"SS9rS+\S6'\R"SS9rS7\S8'\R:SS9j5r\S\ S:S;\!S:S:S:S:S:S;S:SSjjj5r"\S\ S:S;\!S:S:S:S:S:S;S:SSR~\>R~\>R~\>R~\>R~\>R~\>R~\>R~\>R~\>R~S:Sg. SShjj5r@\SSij5rA\SSjj5rA\SSkj5rA\SSlj5rA\S:Sm.SSnjj5rASS:Sm.SSojjjrAS:S:S:S:S:S:Sp.SSqjjrB\SSrj5rC\SSsj5rC\SStj5rC\SSuj5rC\SSv.SSwjj5rCSSSv.SSxjjjrC\SSyj5rD\SSzj5rD\SS{j5rD\SS|j5rDSS}jrD\SS~j5rE\S:S.SSjj5rESS:S.SSjjjrE\SSj5rF\S:S:S:S:S:SS\GS:SSS:S:SS:S.SSjj5rFSS:S:S:S:S:SS\GS:SSS:S:SS:S.SSjjjrF\SSj5rH\S:S:S:S:S:SS\GS:SSS:S:SS:S.SSjj5rHSS:S:S:S:S:SS\GS:SSS:S:SS:S.SSjjjrH\SSj5rI\SKS:S.SSjj5rISSKS:S.SSjjjrISSjrJSSjrKSSjrLSSSjjrMSSSjjrNSSjrOSSjrPS:S.SSjjrQS:S.SSjjrR\'SSj5rSSSSjjrTSSjrUSSjrVSSjrWSSSjjrX\>R~S:S:S:S:4GSSjjrY\)SSj5rZ\)GSSj5r[\)GSSj5r\SSS.GSSjjjr]\GSSj5r^\GSSj5r^GSSjr^\7S:S:S:S:S:S:S:S:S:S:S:SS. GSSjj5r_\7S:S:S:S:S:S:S:S:S:S:S:SSSSS:S.GSSjj5r`GSSjraGS SjrbSGS SjjrcS:S:S:S:S:S:S.GS SjjrdSreg:( riaGClass for defining "agents" - a way to have a specific type of "conversation" with an LLM. Agents are generic in the dependency type they take [`AgentDepsT`][pydantic_ai.tools.AgentDepsT] and the output type they return, [`OutputDataT`][pydantic_ai.output.OutputDataT]. By default, if neither generic parameter is customised, agents have type `Agent[object, str]`. Minimal usage example: ```python from pydantic_ai import Agent agent = Agent('openai:gpt-5.2') result = agent.run_sync('What is the capital of France?') print(result.output) #> The capital of France is Paris. ``` 1models.Model | models.KnownModelName | str | None_modelr_name$TemplateStr[AgentDepsT] | str | None _descriptionr4 end_strategy%AgentModelSettings[AgentDepsT] | Noner"OutputSpec[OutputDataT] _output_type%InstrumentationSettings | bool | None _instrumentFz(ClassVar[InstrumentationSettings | bool]_instrument_defaultrepr AgentMetadata[AgentDepsT] | None _metadatatype[AgentDepsT] _deps_type!_output.OutputSchema[OutputDataT]_output_schemaz6list[_output.OutputValidator[AgentDepsT, OutputDataT]]_output_validators2list[_instructions.SourcedInstruction[AgentDepsT]]r*tuple[str, ...]_system_promptsz3list[_system_prompt.SystemPromptRunner[AgentDepsT]]_system_prompt_functionsz8dict[str, _system_prompt.SystemPromptRunner[AgentDepsT]] _system_prompt_dynamic_functionszFunctionToolset[AgentDepsT]_function_toolsetz OutputToolset[AgentDepsT] | None_output_toolset!list[AbstractToolset[AgentDepsT]]_user_toolsetsr_max_output_retries_max_tool_retries float | None _tool_timeout-Any | Callable[[RunContext[AgentDepsT]], Any]_validation_context%EventStreamHandler[AgentDepsT] | None_event_stream_handler._concurrency.AbstractConcurrencyLimiter | None_concurrency_limiter_entered_countAsyncExitStack | None _exit_stackc,[R"5$r)anyioLockselfs r _enter_lockAgent._enter_locks zz|rNrgraceful) output_typer system_prompt deps_typer% descriptionr"rvalidation_contextrtoolsetsdefer_model_checkr0r$ tool_timeoutmax_concurrency capabilitiescgrrrZr r^rr_r`r%rar"rrbrrcrdr0r$rerfrgs r__init__Agent.__init__,rcgrrris rrjrk2rlrc  X`lXplXl[U5n[ U5 [ 5Ul[U5Ul[URR5 [URU/5n[U[5(dS5eUUl[UR/5 XlXlX lSUlXlXPl[(R*[,R/U5Ul/Ul[4R6"U5Vs/sH#n[4R8"U[;U55PM% snUl[U[<5(aU4O [?U5Ul /Ul!0Ul"[GU 5n[IU5nURJUl&URNUl(UUl)URRb3URRS::a#[TRV"SURR35eXl,UR0RZUl.UR\(a2UR\R^cURPUR\l/[aU SURRUR0S9Ul1[eU =(d /5nUVs/sH+n[U[f5(aM[h[j"US9PM- snUl6[oURl5Ul8UVs/sHn[U[f5(dMUPM snUl9SUl:[vRx"U5Ul=[}SSS9Ul?[}S SS9Ul@[}S SS9UlA[}S SS9UlB[}S SS9UlC[}S SS9UlD[}SSS9UlE[}SSS9UlF[}SSS9UlG[}SSS9UlH[}SSS9UlI[}SSS9UlJSUlKSUlL[5UlN0UlO/UlP/UlQ/UlRSUlS[URUSS9UlURR5nUbU/UlP[URUSS9UlUb=U (d6URR(d"U5Ul/nURRUR5 [U5 [UR/5 URR5UlQ[eURR55UlR[URSS9 URR5UlS[UR5 gs snfs snfs snf)aCreate an agent. Args: model: The default model to use for this agent, if not provided, you must provide the model when calling it. We allow `str` here since the actual list of allowed models changes frequently. output_type: The type of the output data, used to validate the data returned by the model, defaults to `str`. instructions: Instructions to use for this agent, you can also register instructions via a function with [`instructions`][pydantic_ai.agent.Agent.instructions] or pass additional, temporary, instructions when executing a run. system_prompt: Static system prompts to use for this agent, you can also register system prompts via a function with [`system_prompt`][pydantic_ai.agent.Agent.system_prompt]. deps_type: The type used for dependency injection, this parameter exists solely to allow you to fully parameterize the agent, and therefore get the best out of static type checking. If you're not using deps, but want type checking to pass, you can set `deps=None` to satisfy Pyright or add a type hint `: Agent[object, ]`. name: The name of the agent, used for logging. If `None`, we try to infer the agent name from the call frame when the agent is first run. description: A human-readable description of the agent, attached to the agent run span as `gen_ai.agent.description` when instrumentation is enabled. model_settings: Optional model request settings to use for this agent's runs, by default. Can be a static `ModelSettings` dict or a callable that takes a [`RunContext`][pydantic_ai.tools.RunContext] and returns `ModelSettings`. Callables are called before each model request, allowing dynamic per-step settings. retries: Per-category retry budgets for tools and output validation. Pass an `int` to set the same budget for both, or an [`AgentRetries`][pydantic_ai.AgentRetries] dict to set them individually (e.g. `retries={'tools': 3, 'output': 1}`). Defaults to 1 for both. On the text path, `output` is a global budget shared across all output-validation retries in a run; on the tool path it is the default per-tool `max_retries` for each output tool, overridable via [`ToolOutput(max_retries=...)`][pydantic_ai.output.ToolOutput.max_retries]. Both budgets can be overridden per run via `agent.run(retries=...)` (and friends), passing an `AgentRetries` dict (e.g. `retries={'tools': 3}`) for per-category control. For model request retries, see the [transport retries](../retries.md#transport-retries) documentation. validation_context: Pydantic [validation context](https://docs.pydantic.dev/latest/concepts/validators/#validation-context) used to validate tool arguments and outputs. tools: Tools to register with the agent, you can also register tools via the decorators [`@agent.tool`][pydantic_ai.agent.Agent.tool] and [`@agent.tool_plain`][pydantic_ai.agent.Agent.tool_plain]. toolsets: Toolsets to register with the agent, including MCP servers and functions which take a run context and return a toolset. See [`ToolsetFunc`][pydantic_ai.toolsets.ToolsetFunc] for more information. defer_model_check: by default, if you provide a [named][pydantic_ai.models.KnownModelName] model, it's evaluated to create a [`Model`][pydantic_ai.models.Model] instance immediately, which checks for the necessary environment variables. Set this to `True` to defer the evaluation until the first run. Useful if you want to [override the model][pydantic_ai.agent.Agent.override] for testing. end_strategy: Strategy for handling tool calls that are requested alongside a final result. See [`EndStrategy`][pydantic_ai.agent.EndStrategy] for more information. metadata: Optional metadata to store with each run. Provide a dictionary of primitives, or a callable returning one computed from the [`RunContext`][pydantic_ai.tools.RunContext] on each run. Metadata is resolved when a run starts and recomputed after a successful run finishes so it can reflect the final state. Resolved metadata can be read after the run completes via [`AgentRun.metadata`][pydantic_ai.agent.AgentRun], [`AgentRunResult.metadata`][pydantic_ai.agent.AgentRunResult], and [`StreamedRunResult.metadata`][pydantic_ai.result.StreamedRunResult], and is attached to the agent run span when instrumentation is enabled. tool_timeout: Default timeout in seconds for tool execution. If a tool takes longer than this, the tool is considered to have failed and a retry prompt is returned to the model (counting towards the retry limit). Individual tools can override this with their own timeout. Defaults to None (no timeout). max_concurrency: Optional limit on concurrent agent runs. Can be an integer for simple limiting, a [`ConcurrencyLimit`][pydantic_ai.ConcurrencyLimit] for advanced configuration with backpressure, a [`ConcurrencyLimiter`][pydantic_ai.ConcurrencyLimiter] for sharing limits across multiple agents, or None (default) for no limiting. When the limit is reached, additional calls to `run()` or `iter()` will wait until a slot becomes available. capabilities: Optional list of [capabilities](https://pydantic.dev/docs/ai/capabilities/overview/) to configure the agent with, including functions which take a run context and return a capability. See [`CapabilityFunc`][pydantic_ai.capabilities.CapabilityFunc] for more information. Custom capabilities can be created by subclassing [`AbstractCapability`][pydantic_ai.capabilities.AbstractCapability]. z1combining the agent capabilities kept a containerNrztool_timeout must be > 0, got  max_retriestimeout output_schema) toolset_func_override_namer_override_deps_override_model_override_toolsets_override_tools_override_native_tools_override_instructions_override_metadata_override_model_settings_override_output_retries_override_tool_retries_override_root_capabilityF) innermostTagent capabilitiessource)ar-r/r0rK_inject_auto_capabilitiesrU _event_hooksrG_root_capability_validate_capability_idsrgrNr _validate_instruction_source_idsr,r"r3r5r:r<r+ OutputSchemar\buildr>r?r*normalize_instructionssourced_instructionrr tuplerBrCrDrrrrJrrIrLr/ UserErrorrNtoolsetrFrp_AgentFunctionToolsetrElistrxrzrf_dynamic_toolsetslen"_constructor_dynamic_toolset_countrHrP _concurrencynormalize_to_limiterrRrrtrurvrwrxryrzr{r|r}r~rrSrUr_entered_model_ids_entered_models_by_selection _cap_toolsets_cap_instructions_cap_native_tools_cap_model_settingsrS get_toolsethas_resolve_model_idr1 infer_modelapplyr_collect_instructionsget_native_tools_validate_native_tool_idsget_model_settingsrrc)rZr r^rr_r`r%rar"rrbrrcrdr0r$rerfrgcombinedr retry_overridesresolved_retriesagent_toolsetsr cap_toolsetstatic_capabilitiess rrjrkJsWt '(,\: !,/05w 2< @ !6!6!C!CD343H3H<.Y($677l9ll7 (($*?*?)@A ,'!#%22;?EEkR"$ -CCLQ Q   - -k;TU`;a bQ  4>mS3Q3Q /W\]jWk(*%02-:7C3OD!1!7!7#3#:#: )    )d.@.@A.E&&)GHZHZG['\] ]#5 #22::   D$8$8$D$D$L/3/G/GD , "7 &&-- " hn"-*" )g7 =N: &G <)"  36d6L6L2M/6Dmn7 SZ\kHlwnm&*"$0$E$Eo$V!>HIYcg>hEOP`jnEofp tg eo $e  ($ 7 is $di # / > #Yc $Y dn &d %IS &I %GQQiswFx#dn 'e & ,/EQS)>@UWDFJN !7t7L7Ld^c d++779  ""-D  6t7L7Ld^b c  %6t?T?T?i?i ,,U3DKEG ##$7$>$>? !45($*?*?)@A"&!6!6!L!L!N!%d&;&;&L&L&N!O!$"8"8AUV#'#8#8#K#K#M   &u H" ns&*V8.V= V=W#W)custom_capability_typesr r^rr_r%rar"rrbrrcrdr0r$rerfrgcgrr)clsspecrr r^rr_r%rar"rrbrrcrdr0r$rerfrgs r from_specAgent.from_specQs0!rcgrr)rrr`rr r^rr_r%rar"rrbrrcrdr0r$rerfrgs rrrks2rr`rr r^rr_r%rar"rrbrrcrdr0r$rerfrgc P[X5unnU[LaUnO)URb[UR5nO[n[R "UR 5nUR[R "U55 [[UUU55nU(aURU5 U=(d URn[S0SU_SU_SU=(d S_SU_SU_SU=(d UR_SU =(d UR_S [UR(a[!["UR5OSU 5_S [%U U5_S U _S U _S U_SU_SUbUO UR&_SUbUO UR(_SUbUO UR*_SU_SU_6nU$)aConstruct an Agent from a spec dict or `AgentSpec`. This allows defining agents declaratively in YAML/JSON/dict form. Keyword arguments supplement the spec: scalar spec fields (like `name`, `retries`) are used as defaults that explicit arguments override, while `capabilities` from both sources are merged. Args: spec: The agent specification, either a dict or an `AgentSpec` instance. deps_type: The type of the dependencies for the agent. When provided, template strings in capabilities (e.g. `"Hello {{name}}"`) are compiled and validated against this type. custom_capability_types: Additional capability classes to make available beyond the built-in defaults. model: Override the model from the spec. output_type: The type of the output data, defaults to `str`. instructions: Instructions for the agent. system_prompt: Static system prompts. name: The agent name, overrides spec `name` if provided. description: The agent description, overrides spec `description` if provided. model_settings: Model request settings. retries: Retry budgets for tools and output validation. Pass an `int` to set the same budget for both, or an [`AgentRetries`][pydantic_ai.AgentRetries] dict to set them individually. Overrides spec `retries` if provided. validation_context: Pydantic validation context for tool arguments and outputs. tools: Tools to register with the agent. toolsets: Toolsets to register with the agent. defer_model_check: Defer model evaluation until first run. end_strategy: Strategy for tool calls alongside a final result, overrides spec `end_strategy` if provided. metadata: Metadata to store with each run, overrides spec `metadata` if provided. tool_timeout: Default timeout for tool execution, overrides spec `tool_timeout` if provided. max_concurrency: Limit on concurrent agent runs. capabilities: Additional capabilities merged with those from the spec. Returns: A new Agent instance. Nr r^rr_r`r%rar"rrbrrcrdr0r$rerfrgr)_validate_specr rrr^r*rrextendr_capabilities_from_specr rr%rarbr"rra_merge_retries_with_specr0r$re)rrr`rr r^rr_r%rar"rrbrrcrdr0r$rerfrgvalidated_spectemplate_contexteffective_output_typemerged_instructionsall_capabilitieseffective_modelagents rrrs~,:$+J(( c !$/ !  ) ) 5$2>3O3O$P !$' !,BB>C^C^_""=#G#G #UV7; #N4KM] ^8    # #L 17>#7#7 ! - -4 (    ,,,  $A~'A'A 0FTFcFc]N$A$ABim -WnE  2   0! "*6)A~GbGb# $"*!5X>;R;R% &*6)A~GbGb' (,) **+ . r)fmtrr r^rr_r%rar"rrbrrcrdr0r$rerfrgcgrr)rpathrrr r^rr_r%rar"rrbrrcrdr0r$rerfrgs r from_fileAgent.from_files2!rcgrr)rrrr`rr r^rr_r%rar"rrbrrcrdr0r$rerfrgs rrrs4r)rr`rr r^rr_r%rar"rrbrrcrdr0r$rerfrgcr[R"XS9nURUUUUUUUU U U U U UUUUUUUUS9nU$)a`Construct an Agent from a YAML or JSON spec file. This is a convenience method equivalent to `Agent.from_spec(AgentSpec.from_file(path), ...)`. The file format is inferred from the extension (`.yaml`/`.yml` or `.json`) unless overridden with the `fmt` argument. All other arguments are forwarded to [`from_spec`][pydantic_ai.agent.Agent.from_spec]. )rr)rrr)rrrr`rr r^rr_r%rar"rrbrrcrdr0r$rerfrgrrs rrr+skH""41 $;#%'#)1/%%+%) , rTcU[lg)ziSet the instrumentation options for all agents that don't explicitly add an `Instrumentation` capability.N)rr6) instruments rinstrument_allAgent.instrument_allhs %/!rcUR$)z/Instrumentation settings applied to this agent.r5rYs rrAgent.instrumentmsrcXlgrrrZrs rrrrs rcUR$)z,The default model configured for this agent.r,rYs rr  Agent.modelvs{{rcXlg)zSet the default model configured for this agent. We allow `str` here since the actual list of allowed models changes frequently. Nrrs rr r{s  rctURR5nU(a UR$UR$)zThe name of the agent, used for logging. If `None`, we try to infer the agent name from the call frame when the agent is first run. )rtrrr-)rZname_s rr% Agent.names- ##'')#u{{33rcXlg)z,Set the name of the agent, used for logging.N)r-rs rr%rs  rcHURcg[UR5$)zA human-readable description of the agent. If the description is a TemplateStr, returns the raw template source. The rendered description is available at runtime via OTel span attributes. N)r/r rYs rraAgent.descriptions$    $4$$%%rcXlg)z!Set the description of the agent.N)r/rs rrars "rcURcg[UR[5(aURRU5$UR$)zLReturn the agent description, rendering any TemplateStr with the given deps.N)r/rrcrender)rZdepss rrender_descriptionAgent.render_descriptionsG    $ d'' 5 5$$++D1 1   rcUR$)z+The type of dependencies used by the agent.)r<rYs rr`Agent.deps_typesrcUR$)zjThe type of data output by agent runs, used to validate the data returned by the model, defaults to `str`.)r3rYs rr^Agent.output_types   rcUR$)zcOptional handler for events from the model's streaming response and the agent's execution of tools.)rPrYs revent_stream_handlerAgent.event_stream_handlers)))rcUR$)aThe Pydantic validation context used to validate tool arguments and outputs. Set this when validators need values from [`ValidationInfo.context`][pydantic.ValidationInfo.context]. A callable can build the context from the current [`RunContext`][pydantic_ai.tools.RunContext]. rNrYs rrbAgent.validation_contexts'''rcUR$rrrYs r_get_validation_contextAgent._get_validation_contexts'''rc [U5RSUR<SUR<SUR<SUR <SUR <S3 $)Nz(model=z, name=z, end_strategy=z, model_settings=z, output_type=))typerr r%r0r"r^rYs r__repr__Agent.__repr__st*%%&gdjj^7499-_c_p_p^stEFJFYFYE\\jkok{k{j~~@ @r)r^message_historydeferred_tool_resultsconversation_idrun_idr rrr" usage_limitscancellation_tokenr2r$r infer_namercrgrcgrrrZ user_promptr^rrrrr rrr"rrr2r$rrrcrgrs riter Agent.iters .JMr)rrrrr rrr"rrr2r$rrrcrgrcgrrrs rrrs .MPrch# U(a1URc$UR[R"55 UR UUUUUUUUU U U U U UUUUUS9IShvN nUR 5IShvN nU7v SSS5IShvN gN3NN !,IShvN (df  g=f7f)aA contextmanager which can be used to iterate over the agent graph's nodes as they are executed. This method builds an internal agent graph (using system prompts, tools and output schemas) and then returns an `AgentRun` object. The `AgentRun` can be used to async-iterate over the nodes of the graph as they are executed. This is the API to use if you want to consume the outputs coming from each LLM model response, or the stream of events coming from the execution of tools. The `AgentRun` also provides methods to access the full message history, new messages, and usage statistics, and the final result of the run once it has completed. For more details, see the documentation of `AgentRun`. Example: ```python from pydantic_ai import Agent agent = Agent('openai:gpt-5.2') async def main(): nodes = [] async with agent.iter('What is the capital of France?') as agent_run: async for node in agent_run: nodes.append(node) print(nodes) ''' [ UserPromptNode( user_prompt='What is the capital of France?', instructions_functions=[], system_prompts=(), system_prompt_functions=[], system_prompt_dynamic_functions={}, ), ModelRequestNode( request=ModelRequest( parts=[ UserPromptPart( content='What is the capital of France?', timestamp=datetime.datetime(...), ) ], timestamp=datetime.datetime(...), run_id='...', conversation_id='...', ) ), CallToolsNode( model_response=ModelResponse( parts=[TextPart(content='The capital of France is Paris.')], usage=RequestUsage( cost=Decimal('0.000196'), input_tokens=56, output_tokens=7 ), model_name='gpt-5.2', timestamp=datetime.datetime(...), run_id='...', conversation_id='...', ) ), End(data=FinalResult(output='The capital of France is Paris.')), ] ''' print(agent_run.result.output) #> The capital of France is Paris. ``` Args: user_prompt: User input to start/continue the conversation. output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no output validators since output validators would expect an argument that matches the agent's output type. message_history: History of the conversation so far. deferred_tool_results: Optional results for deferred tool calls in the message history. conversation_id: ID of the conversation this run belongs to. Pass `'new'` to start a fresh conversation, ignoring any `conversation_id` already on `message_history`. If omitted, falls back to the most recent `conversation_id` on `message_history` or a freshly generated UUID7. run_id: Optional ID for this agent run. Unlike `conversation_id`, never inherited from `message_history`. Passing an empty string, or a value that already appears on `message_history`, raises `UserError` because both break `new_messages()`; use `conversation_id` to correlate across turns or deferred-tool resume. If omitted, a fresh UUID7 is generated. model: Optional model to use for this run, required if `model` was not set when creating the agent. instructions: Optional additional instructions to use for this run. deps: Optional dependencies to use for this run. model_settings: Optional settings to use for this model's request, or a callable that receives [`RunContext`][pydantic_ai.tools.RunContext] and returns settings. Callables are called before each model request, allowing dynamic per-step settings. usage_limits: Optional limits on model request count or token usage. cancellation_token: Token used to cancel this run from another task or thread. Single-use: mint a fresh token per run, as a reused (already-cancelled) token prevents the run from starting. usage: Optional usage to start with, useful for resuming a conversation or agents used in tools. metadata: Optional metadata to attach to this run. Accepts a dictionary or a callable taking [`RunContext`][pydantic_ai.tools.RunContext]; merged with the agent's configured metadata. retries: Override the agent-level retry budgets for this run. Pass an `int` to override both the tool-retry and output budgets, or an [`AgentRetries`][pydantic_ai.AgentRetries] dict to override just one (e.g. `retries={'tools': 3}`). See [`Agent.__init__`][pydantic_ai.agent.Agent.__init__] for semantics of the two enforcement paths. infer_name: Whether to try to infer the agent name from the call frame if it's not set. toolsets: Optional additional toolsets for this run. capabilities: Optional additional [capabilities](https://pydantic.dev/docs/ai/capabilities/overview/) for this run, merged with the agent's configured capabilities. spec: Optional agent spec to apply for this run. At run time, spec values are additive. Returns: The result of the run. Nr^rrrrr rrr"rrr2r$rrcrgr)r% _infer_nameinspect currentframe _prepare_runopen)rZrr^rrrrr rrr"rrr2r$rrrcrgrprepared agent_runs rrrsr $))+   W113 4** #+"7+%)%1%%+  (==??iO#??) (#???sZAB2BB27B8B2;B B2 B B2B2B2B/B!  B/+B2rc^^O^P^Q^R^S^T^U^V^W^X^Y^Z# [5nUb URO [5n[U5nTR 5unnTR U5nUR S5nUR S5nUGb-UcURb URnUcURb URnUcURb URnUR(a;URnUb*[R"U5nURU5 UnOUnURb)U b[U 5(d[!URU 5n UR"bJUb;[U5(aUR"mPUmOSLUOUP4SjjnUnO0UR"EUEnO UR"nTR$R 5nUb UR&nTR)U5nTR+U 5n U =(d [,R."5n /n Ub(UR0bU R3UR05 U R55 TR7U 5n U/U Qn![9U!5S:a [;U!5mROU!SmR0mWUSL=(d TR<R 5SLn"U"(aSOTRR?5n#TRAU#U5 TRCU5n$Sn%Sn&Sn'U$(aFTREU5n([GU([H5(aU(OSn%U%n&TRKU(TRU TWS9IShvN n'U#bI[LRN"TU U'SU(a [QU5O/U S9n)TRSU#TRU)TWS9IShvN un*n%OU'bU'n*O[TRV"S 5eATRYU5n+U=(d TRZmUTR\n,UbUO TR^n-TR`n.U+TRb:wdU,(aOU+Rdn.U.(a;U.TR`LaUb [gU.5n.U.RhbUbU-U.l4U,U.l5OU.bUb[gU.5n.U-U.l4[lRn"TRpTRrTU5n/[lRt"U(a [QU5O/U SS[lRv"Xc5[lRx"XS5S 9n0TRzR 5n1U1b U1R&O TRmQU1cU OSmYU*R|n2[TQ5(d [!U2TQ5n2[TY5(d [!U2TY5n2U2(aGU2R S 5n3U3S :Xd[GU3[P5(aRV"S U3<S35eU =(d [,R~"5n [GU*[5(aU*Rn4U*Rn*OTR5n4U4bU4Rn5[U4S9n6O [5n5Sn60n70n8[["SM0SU _ST_SU7_SU8_SU*_SU%_SU _SU _SU_SU0R_SU5_SU4SL=(a U4R_SU4(a U4RO[_SS_SU0R_SU0R_S U0R_S!U_6n9TRU9U5U0lU0R"U9lTRU9UU U6S"US#9IShvN n:U:RmXU:Rn;U:RnU:RmV[9TV5[9U!5- mT[UTUV4S$j[U!555n?SNUQUSUY4S%jjn@TRU.UU>TXU-S&9nAUARU95IShvN nA[["UATXUS'9nBTRUUU;_S?WD_S@WE_SAU7_SBU8_SCU=_SDWB_SEWK_SU5_SFWC_SGU4_SHU_6nM[lR["UUS/TRTRTRSI9nN[[[4"U/U0UMUNTRp=(d SUU U*WIWLTXWAU TR[R"TRUSJ9SK9$GNGNcGNGN GN7f)RNrrc.>0T=(d 0ET"U5E$rr)ctx_orig_metadata _spec_metas r _merged_meta(Agent._prepare_run.._merged_metas#Pz'7R#PN3# UHupTTU-ULv M g7frr).0indexlayermodel_layer_startresolved_layerss r %Agent._prepare_run..s'% TkLEO-5 6% ?Tksc>URn[UTTT4[U[R5(aUR S9$SS9$)Nbase)r _layer_model_settingsrr1rr) run_context step_modelagent_model_settingscap_model_settingsrun_model_settingss rr.Agent._prepare_run..get_model_settingssV %**J(%'9;MN,6z6<<,P,PZ(( W[ r)output_toolsetadditional_toolsets cap_toolsetsrmax_output_retriesroot_capabilitydefault_max_retriesadditional_instructionscap_instructionsc`># [R"TU5IShvN =(d S$N 7fr)r*resolve_sourced_instructions)r3sourced_instructionss rget_instructions,Agent._prepare_run..get_instructionss)'CCDXZeffnjn nfs .,.Fz[A capability removed the bootstrap model in `for_run()` but the agent has no default model.cD># TRUTUTS9IShvN $N7f)Nr)_evaluate_model_contribution)selector selection_ctxresolved_models_by_selectionrrZs revaluate_model_selector3Agent._prepare_run..evaluate_model_selector.s6::)! < ; s   c \>[R"TRUTU[T5S9 g)N)r%r r^rrg)r(display_agent_bannerr%_registered_capability_count)r rbootstrap_capability output_type_rZs rdisplay_banner*Agent._prepare_run..display_banner8s,  ) )YY(9:NO  r user_depsnew_message_indexresumed_requestresumed_request_indexmodel_idmodel_selectormodel_selected_for_steprM enter_modelrr<r0rroutput_validatorsrbr>rgloaded_capability_idsdiscovered_tool_namesdurable_operationsr native_tools tool_managerrTrFinstrumentation_settings cancellation)rrrinstructions_functionssystem_promptssystem_prompt_functionssystem_prompt_dynamic_functions)r$)graphstate graph_depsuser_prompt_node agent_namebindingrr capability_owns_current_modelmodel_resourcesrrrconcurrency_limiterresolve_metadata)r RunContext[AgentDepsT]rdict[str, Any]r)r3rtrr!)r3rtrz&list[_messages.InstructionPart] | None)rJzModelSelector[AgentDepsT]rK(models.ModelSelectionContext[AgentDepsT]rtuple[models.Model, str | None])r r rrrr)sr<rer;r_base_run_capability _resolve_specrr r'r(rr*rrr"callablerbr$r}r_resolve_tool_retries _get_deps_usageRunUsagerrrK_bind_run_capabilitiesrrGrv get_model_check_dynamic_model_resume _has_model_pick_raw_modelrr _resolve_model_selectionr1ModelSelectionContextrrIr/r_prepare_output_schemar^r?rIrFr>rrrpr^r'build_agent_graphr%r<GraphAgentStateresolve_run_idresolve_conversation_idr|r UsageLimitsrYrdwrapped!_resolve_instrumentation_settingsrInstrumentationCaprrmrfrinclude_contentversionr#rrr _get_metadata_resolve_run_capabilitiesrrgrbrcr,all enumerate _get_toolsetfor_runre_get_instructionsr=keysrr}r_RunModelResourcesrGraphAgentDepsr\r]r0rNr6rBrCrD_PreparedAgentRunrrR functoolspartial_resolve_and_store_metadata)[rZrr^rrrrr rrr"rrr2r$rrcrgrrorerr"r&resolvedeffective_output_retrieseffective_tool_retriesextrarr override_output_retrieseffective_tool_retries_resolvedr# model_layersmodel_is_explicitmodel_contributionhas_default_modelrZdefault_model_id default_model raw_modelrK model_usedrrr^$effective_output_toolset_max_retriesr9rjrkmodel_settings_overridebaseline_settingsrrdrr$rar initial_ctx resolved_capscapabilities_dictrBcap_native_toolsr;model_layers_unchangedrrrcrFr_r`run_model_contributionr[r\rprMrTrqrlrmr r r5rRr6r+rSr,rLrr7rEs[` @@@@@@@@@@@@rrAgent._prepare_runs 2#$ 07/Bw++HY ;7C-1,E,E,G))%%d+#2#6#6x#@ !0!4!4W!=  }!; '/H4K4K4W+3+B+B(%-(2G2G2S)1)>)>&$$ --+,CCLQHOOE*#+L#(L&&2!).1I1I%9(:Q:QSa%bN  ,'))%-%6%6 )1QQ$0#Dh&7&7#D8#D'00H #'"?"?"C"C"E " .'>'D'D $*.*D*DE[*\'~~d#** DF  H$7$7$C  % %h&9&9 :!!"7 "EF!889KL>M=cPb=c | q #5l#C #/? LN$ "-W1E1E1I1I1KSW1W%6T$>yDH' "&"?"?/ < #@#M  )"88#2Ao.r M*.)J)J"/! < *K*$ J  &&J&&'mn n 33K@ "6d&6&6 !33)A(L $RVRjRj --- D// /3D*22N"T%9%99>V>b%).%9N!--59Q9]1UN.3D0  ',D,P".1N)MN &..tyy$//<X,,5DD1" !..vG(@@b  #'"?"?"C"C"E-D-P # ) )VZViVi 0G/N^TX 3=2E2E,-- 45FH\ ] *++ 45FHZ [  +// >Kj(J{D,I,I **#K?3VW$;v'9'9';  j"3 4 4GQGjGj $#++J'+'M'M'O $ # /-44F=OYq=r \F"&  TVLN !,   !3 %;       &  **  #;$"F"sKcKsKs (%=$D$D0 ! "#33# $<<% &"11' (') <++KB$~~ #<< +1 3#'- =  '55)66(55(55*99$-- (7703|3DD!$% T]^jTk% "   ##) (%)C $   44":. ^Ih $55$0- 6   o/ o 3 o -_>O>T>T>V WS  L[ 6 G`cdg`h`j):@X@X@Z (()?Q "&./A&B&B9UgKhKh"nr ,:+Ea4 #,>d,J ) , - -i@V6W6W4N&* #,0 ) # /#<<&) < = J 2<&>?! @&A! F(66zB#"7#%//$($A$A,0,Q,Q !S1!-yy+G1*G+)% $ 9 9&..t/O/OZbc  C $r `5\s_L?lk6Alk9Nl5k<6B?l5k?6D+l!l"Gl9l<l?llc URR5nUbURURU5$URURU5nURX!5nU(a U(a0UEUE$U=(d U$r)r{r_resolve_metadata_configrr:)rZr additional_metadatametadata_override base_metadata run_metadatas rrAgent._get_metadatas !33779  (001B1H1H#N N55dnncJ 445HN \4m4|4 4,},rcFUcg[U5(a U"U5nU$UnU$r)rz)rZconfigr r$s rrAgent._resolve_metadata_configs0 >"*6"2"26#;9?rc^[U5nURX25nXARlU$r)r7rrkr$)rZ graph_run_ctxr$r3resolved_metadatas rr!Agent._resolve_and_store_metadatas1 ( 6  ..{E'8$  rc Ucg[XR5up4[[X2U55nU(a [ U5OSn[ U5n[ HYn[U5RUn URUU R:wdM:[R"SU<S3[SS9 M[ [UUR(a [ R""UR5O/UR$UR&(a[)[*UR&5OSUR,UR.UR1S5UR1S5S9$) zkValidate and instantiate capabilities from a spec, returning contributions. Returns None if spec is None. NzAgentSpec field z: is not supported at run/override time and will be ignored) stacklevelrr)rrr r"r$r%r'r()rr<rrrG_retry_overrides_from_spec_UNSUPPORTED_SPEC_FIELDSr model_fields__dict__rwarningswarn UserWarningrrr*rr r"rrar$r%r) rZrrrrrgrr field_name field_infos rryAgent._resolve_specs+ <+9$+P(3N]mno 7C%l34^D3Jn-:::FJ&&z2j6H6HH &zn4no 3**'==n>Y>YZ &&,, ~/L/LM#,,$$*..x8(,,W5  r) r%rr rcrrbrr$r"rrc #l# [R"U 5(aL[U 5n U RS[R5n U RS[R5nO [Rn [RnUR U 5nUbRUR bE[UR R5n[U5 [U5RU5nOSnUGbp[R"U5(dURb URn[R"U5(dURb URn[R"U5(dUR(a URn[R"U 5(dURb URn [R"U5(dUR b UR n[R"U 5(dUR"b UR"n [R"U5(dUR$b UR$n[R"U5(a0UR&R)[R*"U55nOSn[R"U5(a0UR,R)[R*"U55nOSn[R"U5(aU=(d UR/5n[1U[25(aUR4(aUO[6R8"U5nUR:R)[R*"U55nOSn[R"U5(a0UR<R)[R*"U55nOSn[R"U5(a0UR>R)[R*"U55nOSn[R"U5(a0UR@R)[R*"U55nOSn[R"U5(aF[BRD"U5nURFR)[R*"U55nOSn"U5(a0URHR)[R*"U55nOSn[R"U 5(a0URJR)[R*"U 55nOSn[R"U 5(a0URLR)[R*"U 55nOSn[R"U5(a0URNR)[R*"U55nOSnUb0URPR)[R*"U55n OSn Sv UbUR&RSU5 UbUR,RSU5 UbUR:RSU5 UbUR<RSU5 UbUR>RSU5 UbUR@RSU5 UbURFRSU5 UbURHRSU5 UbURJRSU5 UbURLRSU5 UbURNRSU5 U bURPRSU 5 gg!UbUR&RSU5 UbUR,RSU5 UbUR:RSU5 UbUR<RSU5 UbUR>RSU5 UbUR@RSU5 UbURFRSU5 UbURHRSU5 UbURJRSU5 UbURLRSU5 UbURNRSU5 U bURPRSU 5 ff=f7f)aContext manager to temporarily override agent configuration. This is particularly useful when testing. You can find an example of this [here](../testing.md#overriding-model-via-pytest-fixtures). Args: name: The name to use instead of the name passed to the agent constructor and agent run. deps: The dependencies to use instead of the dependencies passed to the agent run. model: The model to use instead of the model passed to the agent run. toolsets: The toolsets to use instead of the toolsets passed to the agent constructor and agent run. tools: The tools to use instead of the tools registered with the agent. native_tools: The native tools to use instead of the agent's configured native tools. instructions: The instructions to use instead of the instructions registered with the agent. Note: this also replaces capability-contributed instructions (e.g. from [`get_instructions`][pydantic_ai.capabilities.AbstractCapability.get_instructions]). metadata: The metadata to use instead of the metadata passed to the agent constructor. When set, any per-run `metadata` argument is ignored. model_settings: The model settings to use instead of the model settings passed to the agent constructor. When set, any per-run `model_settings` argument is ignored. retries: The retry budgets to use instead of the agent-level configuration. Pass an `int` to override both the tool-retry and output budgets, or an [`AgentRetries`][pydantic_ai.AgentRetries] dict to override just one (e.g. `retries={'tools': 3}`). When set, any per-run `retries` argument is ignored. spec: Optional agent spec providing defaults for override. Explicit params take precedence over spec values. When the spec includes `capabilities`, they replace (not merge with) the agent's existing capabilities. To add capabilities without replacing, pass `spec` to `run()` or `iter()` instead. rrN)*r-rrrUNSETryrrrgrrG for_agentr%r rr"r$r'r(rtrSomeru_effective_root_capabilityrr rr1rrvrwrxryr*rrzr{r|r}r~rr)!rZr%rr rcrrbrr$r"rrrroverride_tool_retriesr override_capsoverride_capability name_token deps_tokenmodel_capabilityoverride_model model_tokentoolsets_token tools_tokennative_tools_tokennormalized_instructionsinstructions_tokenmetadata_tokenmodel_settings_tokenoutput_retries_tokentool_retries_token cap_tokens! roverrideAgent.overridesb == ! !>wGO&5&9&9(FLL&Q #$3$7$7$N !&,ll #$*LL !%%d+  H$7$7$C !4!4!A!ABM %m 4I[\iIjItItJ #'   ==&&8==+D}}==''HNN,F ==..83H3H'44 ==00X5L5L5X!)!8!8==**x/@/@/L#,,==!899h>U>U>a*2*A*A'==!677H str: return 'foobar' @agent.instructions async def async_instructions(ctx: RunContext[str]) -> str: return f'{ctx.deps} is the best' ``` Args: func: The instructions function to register. name: An optional name for the instruction part this function produces, keyed as `'agent:'` on [`InstructionPart.id`][pydantic_ai.messages.InstructionPart.id] so an application can address this part specifically, where the bare `'agent'` key addresses the agent's literal instructions. See [instruction parts](../agent.md#instruction-parts). Nrc h>TRR[R"UTTSS95 U$)NT)r%rdynamic)r*rSourcedInstruction)func_instruction_idr%rZs r decorator%Agent.instructions..decorators5    % %00Tn^bc LrrSystemPromptFunc[AgentDepsT]rr)r*validate_instruction_namer  InstructionIdr )rZrr%rrs` ` @rrrsoN    3 3D 9VZVfI # #I$D$D$FT Rlp  /  )  !Ly=io=r)rr rrr2r"c # URU5nU=(d [R"5n[U=(d /5nUR 5nUR U5n U (a'UR URU5XS9IShvN OSn Uc~URR5ccUR5n U b4[R"UUU SUUS9n URXU S9IShvN upO#U bU n O[R"S5eU ceU n [ [""UUU UUUUSS9n[$R&"UR(UR*U5IShvN $NNxN7f)zResolve the agent's configured system prompts into `SystemPromptPart`s. See [`AbstractAgent.system_prompt_parts`][pydantic_ai.agent.AbstractAgent.system_prompt_parts]. )rrNrr)rr zD`model` must either be set on the agent or supplied by a capability.)rrr r2rr0r"r)r|r}r~rrrrrrvrrr1rrIr/rrmrfr,resolve_system_promptsrBrC)rZrr rrr2r"r0rrr contributionrKselected_model_r3s rsystem_prompt_partsAgent.system_prompt_partss~~d#**-2.446  OOE2!//0D0DU0KXb/n n n  =T11557?%//1L' & < <'% ! +/*K*K ]+L+%!*!. **+qrr , ,,*N , )  $::  $"?"?   G o%( s8BE1E+A#E14E-5A1E1&E/'E1-E1/E1cgrrrs rr_Agent.system_prompt rrcgrrrs rr_r  rrcgrrrs rr_r  s\_rcgrrrs rr_r " srurrcgrr)rZrs rr_r % rrc^^UcSUU4SjjnU$T(aS5eTRR[R["UTS95 U$)a Decorator to register a system prompt function. Optionally takes [`RunContext`][pydantic_ai.tools.RunContext] as its only argument. Can decorate a sync or async functions. The decorator can be used either bare (`agent.system_prompt`) or as a function call (`agent.system_prompt(...)`), see the examples below. Overloads for every possible signature of `system_prompt` are included so the decorator doesn't obscure the type of the function, see `tests/typed_agent.py` for tests. Args: func: The function to decorate dynamic: If True, the system prompt will be reevaluated even when `messages_history` is provided, see [`SystemPromptPart.dynamic_ref`][pydantic_ai.messages.SystemPromptPart.dynamic_ref] Example: ```python from pydantic_ai import Agent, RunContext agent = Agent('test', deps_type=str) @agent.system_prompt def simple_system_prompt() -> str: return 'foobar' @agent.system_prompt(dynamic=True) async def async_system_prompt(ctx: RunContext[str]) -> str: return f'{ctx.deps} is the best' ``` c>[R["UTS9nTRR U5 T(aUTR UR 'U$)Nr)r,SystemPromptRunnerrfrCrrDr)rrunnerrrZs rr&Agent.system_prompt..decoratorR sO(:::FuV]^--44V<PVD99%:L:LM rz"dynamic can't be True in this caserr)rCrr,rrf)rZrrrs` ` rr_r * siL < 3 -    D D D;  ) ) 0 01R1RS]1^_cmt1u vKrcgrrrs routput_validatorAgent.output_validatora HKrcgrrrs rrrf s SVrcgrrrs rrrk 03rcgrrrs rrrp s;>rc~URR[R[[ 4"U55 U$)aDecorator to register an output validator function. Optionally takes [`RunContext`][pydantic_ai.tools.RunContext] as its first argument. Can decorate a sync or async functions. Overloads for every possible signature of `output_validator` are included so the decorator doesn't obscure the type of the function, see `tests/typed_agent.py` for tests. Example: ```python from pydantic_ai import Agent, ModelRetry, RunContext agent = Agent('test', deps_type=str) @agent.output_validator def output_validator_simple(data: str) -> str: if 'wrong' in data: raise ModelRetry('wrong response') return data @agent.output_validator async def output_validator_deps(ctx: RunContext[str], data: str) -> str: if ctx.deps in data: raise ModelRetry('wrong response') return data result = agent.run_sync('foobar', deps='spam') print(result.output) #> success (no tool calls) ``` )r?rr+OutputValidatorrfrrs rrru s3D &&w'>'>z3'OPT'UV rcgrrrs ron_eventAgent.on_event s7:r)rqcgrr)rZrq event_typess rr#r$ rrcURRnUcUR"USU06$UR"U/UQ7SU06$)u Decorator to register a listener for events on this agent's run event stream. Every event on the stream can be listened for: the framework's own model and tool events, the application's [`CustomEvent`][pydantic_ai.messages.CustomEvent]s, and the [`CapabilityEvent`][pydantic_ai.messages.CapabilityEvent]s published by the agent's capabilities. Naming event classes narrows the `event` argument to their union and lets dispatch skip the agent's listeners for anything else; a bare `@agent.on_event` sees every [`AgentStreamEvent`][pydantic_ai.messages.AgentStreamEvent]. This is the application-level counterpart to [`@on_event`][pydantic_ai.capabilities.on_event] on a capability, and it dispatches at the same point. These listeners join after the agent's own capabilities, so they see the events those emitted, and they survive an overridden root capability. Capability ordering still applies: one asking for `position='innermost'` keeps that position and its listeners run after these. Dispatch happens *upstream* of [`wrap_run_event_stream()`][pydantic_ai.capabilities.AbstractCapability.wrap_run_event_stream], so a listener sees each event as it was emitted, not as it is finally delivered. A capability that rewrites, replaces or drops events in its stream wrapper does so after every listener has already run, which means a listener can see an event that no stream consumer ever receives. To act on the delivered stream instead, wrap it yourself with `wrap_run_event_stream` on a [`Hooks`][pydantic_ai.capabilities.Hooks] capability, or consume [`run_stream_events()`][pydantic_ai.agent.AbstractAgent.run_stream_events]. Being application code, a listener may emit a `CustomEvent` of its own. That is how a capability's internal event reaches a frontend: capability events are deliberately not forwarded by the [AG-UI](../ui/ag-ui.md) and [Vercel AI](../ui/vercel-ai.md) adapters, so you republish the part of one that is public. For hook families other than events, pass a [`Hooks`][pydantic_ai.capabilities.Hooks] capability to `capabilities=`, where its position among the other capabilities — which decides where it sits in each wrap chain — is yours to choose. Example: ```python from dataclasses import dataclass from pydantic_ai import Agent, CapabilityEvent, CustomEvent, RunContext agent = Agent('test') @dataclass(kw_only=True) class IndexRebuiltEvent(CapabilityEvent, namespace='indexer'): documents: int @dataclass(kw_only=True) class SearchReadyEvent(CustomEvent): documents: int @agent.on_event(IndexRebuiltEvent) async def republish(ctx: RunContext[None], event: IndexRebuiltEvent) -> None: await ctx.emit(SearchReadyEvent(documents=event.documents)) ``` rq)ronevent)rZfunc_or_event_typerqr& registrars rr#r$ sJF**--  %??KAA A1QKQQQrcgrrrs rtool Agent.tool rrauto)r%rarprepareargs_validatordocstring_formatrequire_parameter_descriptionsschema_generatorstrict sequentialrequires_approvalr$rq defer_loadinginclude_return_schemacgrrrZr%rarr0r1r2r3r4r5r6r7r$rqr8r9s rr-r. s (hkrcr^^^^^^^^^ ^ ^ ^ ^ ^^^SUUUUUU UUUU UU UU U U4SjjnUcU$U"U5$)aDecorator to register a tool function which takes [`RunContext`][pydantic_ai.tools.RunContext] as its first argument. Can decorate a sync or async functions. The docstring is inspected to extract both the tool description and description of each parameter, [learn more](../tools.md#function-tools-and-schema). We can't add overloads for every possible signature of tool, since the return type is a recursive union so the signature of functions decorated with `@agent.tool` is obscured. Example: ```python from pydantic_ai import Agent, RunContext agent = Agent('test', deps_type=int) @agent.tool def foobar(ctx: RunContext[int], x: int) -> int: return ctx.deps + x @agent.tool(retries=2) async def spam(ctx: RunContext[str], y: float) -> float: return ctx.deps + y result = agent.run_sync('foobar', deps=1) print(result.output) #> {"foobar":1,"spam":1.0} ``` Args: func: The tool function to register. name: The name of the tool, defaults to the function name. description: The description of the tool, defaults to the function docstring. retries: The number of retries to allow for this tool, defaults to the agent's default retries, which defaults to 1. prepare: custom method to prepare the tool definition for each step, return `None` to omit this tool from a given step. This is useful if you want to customise a tool at call time, or omit it completely from a step. See [`ToolPrepareFunc`][pydantic_ai.tools.ToolPrepareFunc]. args_validator: custom method to validate tool arguments after schema validation has passed, before execution. The validator receives the already-validated and type-converted parameters, with `RunContext` as the first argument. Raise [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] to ask the model to correct the arguments and try again, or [`ToolFailed`][pydantic_ai.exceptions.ToolFailed] to report a terminal failure the model should adapt to instead of retrying. Return `None` on success. See [`ArgsValidatorFunc`][pydantic_ai.tools.ArgsValidatorFunc]. docstring_format: The format of the docstring, see [`DocstringFormat`][pydantic_ai.tools.DocstringFormat]. Defaults to `'auto'`, such that the format is inferred from the structure of the docstring. require_parameter_descriptions: If True, raise an error if a parameter description is missing. Defaults to False. schema_generator: The JSON schema generator class to use for this tool. Defaults to `GenerateToolJsonSchema`. strict: Whether to enforce (vendor-specific) strict schema adherence for tool calls (supported by OpenAI, Anthropic, Google, and Bedrock). See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info. sequential: Whether this tool acts as a barrier that runs alone, not overlapping with other tool calls. See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info. Defaults to False. requires_approval: Whether this tool requires human-in-the-loop approval. Defaults to False. See the [tools documentation](../deferred-tools.md#human-in-the-loop-tool-approval) for more info. metadata: Optional metadata for the tool. This is not sent to the model but can be used for filtering and tool behavior customization. timeout: Timeout in seconds for tool execution. If the tool takes longer, a retry prompt is returned to the model. Overrides the agent-level `tool_timeout` if set. Defaults to None (no timeout). defer_loading: Whether to hide this tool until it's revealed by tool search, `load_capability`, or another tool's `ToolReturn.tools`. Defaults to False. See [Tool Search](../tools-advanced.md#tool-search) for more info. include_return_schema: Whether to include the return schema in the tool definition sent to the model. If `None`, defaults to `False` unless the [`IncludeToolReturnSchemas`][pydantic_ai.capabilities.IncludeToolReturnSchemas] capability is used. cZ>T RRUSTTT TTTT T TTT TTTTS9 U$)NT takes_ctxr%rarr0r1r2r3r4r5r6r7r$rqr8r9rE add_functionrr1r8rar2r9r$r%r0r3r7rr4rZr6r5rqs rtool_decorator"Agent.tool..tool_decorator[ sX  " " / /'-!1/M!1%"3!+&;# 0 &Lr)r'ToolFuncContext[AgentDepsT, ToolParams]rrErrZrr%rarr0r1r2r3r4r5r6r7r$rqr8r9rCs` ``````````````` rr-r. s:l :  4   2"&~G>$3GGrcgrrrs r tool_plainAgent.tool_plainv rrcgrrr;s rrHrIy s (LOrcj^^^^^^^^^ ^ ^ ^ ^ ^^^SUUUUUU UUUU UU UU U U4SjjnUcU$U"U5$)uDecorator to register a tool function which DOES NOT take `RunContext` as an argument. Can decorate a sync or async functions. The docstring is inspected to extract both the tool description and description of each parameter, [learn more](../tools.md#function-tools-and-schema). We can't add overloads for every possible signature of tool, since the return type is a recursive union so the signature of functions decorated with `@agent.tool` is obscured. Example: ```python from pydantic_ai import Agent, RunContext agent = Agent('test') @agent.tool def foobar(ctx: RunContext[int]) -> int: return 123 @agent.tool(retries=2) async def spam(ctx: RunContext[str]) -> float: return 3.14 result = agent.run_sync('foobar', deps=1) print(result.output) #> {"foobar":123,"spam":3.14} ``` Args: func: The tool function to register. name: The name of the tool, defaults to the function name. description: The description of the tool, defaults to the function docstring. retries: The number of retries to allow for this tool, defaults to the agent's default retries, which defaults to 1. prepare: custom method to prepare the tool definition for each step, return `None` to omit this tool from a given step. This is useful if you want to customise a tool at call time, or omit it completely from a step. See [`ToolPrepareFunc`][pydantic_ai.tools.ToolPrepareFunc]. args_validator: custom method to validate tool arguments after schema validation has passed, before execution. The validator receives the already-validated and type-converted parameters, with [`RunContext`][pydantic_ai.tools.RunContext] as the first argument — even though the tool function itself does not take `RunContext` when using `tool_plain`. Raise [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] to ask the model to correct the arguments and try again, or [`ToolFailed`][pydantic_ai.exceptions.ToolFailed] to report a terminal failure the model should adapt to instead of retrying. Return `None` on success. See [`ArgsValidatorFunc`][pydantic_ai.tools.ArgsValidatorFunc]. docstring_format: The format of the docstring, see [`DocstringFormat`][pydantic_ai.tools.DocstringFormat]. Defaults to `'auto'`, such that the format is inferred from the structure of the docstring. require_parameter_descriptions: If True, raise an error if a parameter description is missing. Defaults to False. schema_generator: The JSON schema generator class to use for this tool. Defaults to `GenerateToolJsonSchema`. strict: Whether to enforce (vendor-specific) strict schema adherence for tool calls (supported by OpenAI, Anthropic, Google, and Bedrock). See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info. sequential: Whether this tool acts as a barrier that runs alone, not overlapping with other tool calls. See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info. Defaults to False. requires_approval: Whether this tool requires human-in-the-loop approval. Defaults to False. See the [tools documentation](../deferred-tools.md#human-in-the-loop-tool-approval) for more info. metadata: Optional metadata for the tool. This is not sent to the model but can be used for filtering and tool behavior customization. timeout: Timeout in seconds for tool execution. If the tool takes longer, a retry prompt is returned to the model. Overrides the agent-level `tool_timeout` if set. Defaults to None (no timeout). defer_loading: Whether to hide this tool until it's revealed by tool search, `load_capability`, or another tool's `ToolReturn.tools`. Defaults to False. See [Tool Search](../tools-advanced.md#tool-search) for more info. include_return_schema: Whether to include the return schema in the tool definition sent to the model. If `None`, defaults to `False` unless the [`IncludeToolReturnSchemas`][pydantic_ai.capabilities.IncludeToolReturnSchemas] capability is used. cZ>T RRUSTTT TTTT T TTT TTTTS9 U$)NFr>r@rBs rrC(Agent.tool_plain..tool_decorator sV  " " / /'-!1/M!1%"3!+&;# 0 &Lr)rToolFuncPlain[ToolParams]rrNrrFs` ``````````````` rrHrI s*n   ."&~G>$3GGrcgrrrs rr Agent.toolset sTWr per_run_steprcgrr)rZrRrs rrrP s HKrc6^^^SUUU4SjjnUcU$U"U5$)aDecorator to register a toolset function which takes [`RunContext`][pydantic_ai.tools.RunContext] as its only argument. Can decorate a sync or async functions. The decorator can be used bare (`agent.toolset`). Example: ```python from pydantic_ai import AbstractToolset, Agent, FunctionToolset, RunContext agent = Agent('test', deps_type=str) @agent.toolset async def simple_toolset(ctx: RunContext[str]) -> AbstractToolset[str]: return FunctionToolset() ``` Args: func: The toolset function to register. per_run_step: Whether to re-evaluate the toolset for each run step. Defaults to True. id: An optional unique ID for the dynamic toolset. Under durable execution, construct a [`DynamicToolset`][pydantic_ai.toolsets.DynamicToolset] with this ID and pass it to `Agent(toolsets=[...])` instead; decorator registrations cannot be used inside a workflow or flow because they happen after durable units are created. cP>TRR[UTTS95 U$)NrQ)rrrz)rrrRrZs rtoolset_decorator(Agent.toolset..toolset_decorator- s&  " " ) ).\^`*a bLr)rToolsetFunc[AgentDepsT]rrXr)rZrrRrrVs` `` rrrP s&D  %)L M6G6MMrczUSL=(d1 URR5SL=(d URSL$)zWhether a run given `model` would have one to use, counting an `override(model=...)`. What `_pick_raw_model` answers for, asked ahead of it by callers that would rather not have it raise. A capability can still contribute a model when this is False. N)rvrr )rZr s rrAgent._has_model3 s7 D dD$8$8$<$<$>d$Jddjj`dNddrcURR5=n(a UR$UbU$URb UR$[R "S5e)Nr)rvrrr r/r)rZr  some_models rrAgent._pick_raw_model; s[--113 3: 3## #  L :: !:: ""#ijjrclURR5nUb UR$UR$)zKReturn the override capability when present, otherwise the configured root.)rrrr)rZrs rr Agent._effective_root_capabilityF s011557!)!5x~~P4;P;PPrc URU5n/URQU=(d /QnUVs/sHn[U[5(dMUPM nn[ [U[ R 5(a UROU[U5[U5:Xa[SU55OS[UR55[U[5=(d UR5SLS9$s snf)aDescribe the session `_cli` is about to open, before any run has resolved anything. Resolved the way a run resolves it rather than read off the agent as configured: an `override()` in force, or instrumentation switched on globally by `Agent.instrument_all()`, would otherwise have the banner describe a different session than the one about to start. Args: model: Model the session was asked to use, if not the agent's own. toolsets: Toolsets the session will pass to each run, which aren't on the agent. c3L# UHn[UR5v M g7fr)rr)r(rs rr-0Agent._startup_banner_details..e sB Wc'--(( "$N)r rrg instrumented)rrcrr_StartupBannerDetailsr1rrZrsumrQrrYr)rZr rc chat_modelsession_toolsetsr countables r_startup_banner_detailsAgent._startup_banner_detailsK s))%0 >T]]>hn">-=e,< 7Tc@dW,< e$)3J )M)M*%%S]GJ)nX[\lXmFm#B BBsw5d6U6U6WX:'89qT=c=c=emq=q  fs C3 C3cvURR5nUb UR$UbU$UR$)zNResolve the effective tool-retry default: override > run/spec > agent default.)r~rrrJ)rZrrs rr{Agent._resolve_tool_retriesl s<..224  >> !!-wI43I3IIrcURR5nUR5nURR(a[ X R/5nX!SL4$)ukThe base capability layer for a run, plus whether it came from `override(root_capability=...)`. `iter` and `realtime_session` both resolve the base layer through this so the override is honored identically — KEEP the two call sites in sync (a realtime session that ignored the override would silently drop a `with agent.override(root_capability=...):` block). N)rrrr has_on_eventrG)rZ override_capr1s rrxAgent._base_run_capabilitys sX5599; ..0    ) ) &t->->&?@D---rcNUVs/sHo"RU5PM sn$s snf)uBind per-run capabilities to this agent via `for_agent` before capability resolution. `_resolve_run_capabilities` only ever calls `for_run`, so binding the per-run layer via `for_agent` is the caller's responsibility. `iter` and `realtime_session` both MUST call this — skipping it uses a capability that overrides `for_agent` (e.g. the durability capabilities) unbound, a silent divergence. KEEP the two call sites in sync. )r)rZr#rs rrAgent._bind_run_capabilities s(>PP=Oz$$T*=OPPPs")rc|# [U[5(dU$[U5U4nUbURU5=nbU$URRU5=n(a UbXtU'U$[ R "XS9nURXS9IShvN n U bU O[ R"U5nUbXdU'U$N(7f)z@Resolve a concrete model selection through the capability chain.N)rr)rZ) rr rrrr1ModelResolutionContextresolve_model_idr) rZ selectionrrr cache_keyresolved_model entered_modelresolution_ctxrs rrAgent._resolve_model_selection s)S))  ^Y/  &o>Q>QR[>\,\N+i! ! ==AA)L L= L*-: * 66TM#44^4XX%-%9v?Q?QR[?\  &)7I & YsBB<B:)B<c.# [U5(a[U5(dU"U5OUn[R"U5(a UIShvN nUR XRUR US9IShvN nU[ U[5(aU4$S4$NCN"7f)zGEvaluate a static or dynamic model contribution and resolve its result.Nr)rzrr isawaitablerrrr )rZrrr rrwr s rrI"Agent._evaluate_model_contribution s*2,)?)? R^H_H_L%eq   y ) )'I33 388_4  :i#=#=iGG4GG ( s$A B B"B0B1!BBc[U5(af[U5(dUU(aM[US[R5(a*USR S:Xa[ R"S5eggggg)zRReject cross-run continuation when a selector cannot reconstruct the pinned model. suspendedzCannot resume a suspended response with a dynamic capability model: the model that created the provider-side job cannot be reconstructed unambiguously. Pass that model explicitly to `run(model=...)` when resuming.N)rzrrr  ModelResponserkr/r)rrs rr!Agent._check_dynamic_model_resume s{ \ " "l++?2. 0G0GHH#))[8&&K 9I , #rcPUR5nUcURR5b9URU5n[ U5(aU$[ R "U5$UR5n[U5(a&[ U5(d[R"S5eUbUOURS5n[U[5(a'UR(a[R"S5e[ U5(aU$[ R "U5$)zOResolve a configured or static capability model where run deps are unavailable.Nz~The capability model is dynamic and can only be selected during a run with run dependencies. Pass a concrete model explicitly.zmThe configured model ID is resolved by a capability using run dependencies. Pass a concrete model explicitly.)rrvrrrr1rrrzr/rrr r)rZr rrwrs r_get_model_outside_runAgent._get_model_outside_run s446   4 4 8 8 : F,,U3I )) 4 49 W&:L:LY:W W!++- L ! !)L*A*A&&4 %1$&(NJNrc`URR5=n(a UR$U$)zGet deps for a run. If we've overridden deps via `_override_deps`, use that, otherwise use the deps passed to the call. We could do runtime type checking of deps against `self._deps_type`, but that's a slippery slope. )rurr)rZr some_depss rr|Agent._get_deps s-++//1 19 1?? "Krc Z^# U/UQnUb'[U[5(dURSU5 [R"U4SjU56IShvN nU[ U5[ U5- Sn UR TU V V s/sHn [U 5HoPM M sn n 5 US[ U5[ U5- U 4V s/sH?n U (dM [[ U 5S:a[[U 55OU SU /5PMA n n [ U 5S:a:[[ U 5S:a [U 5OU SU V s/sHo/PM sn 5OU Sn[U/5 [U5nU(a[[SUR555(a6[U/[5(d [U[5/5n[U5nUTlXLdU(aUnOSnUbRUR#5n[UR%55nUR'5nUR)5nUbU/O/nOSnUR*nUR,nSn[U SR%55n[/UU(aSOSS9 [ U 5S:a[U SR%55O/n[/US S9 UR0R35=n(a$[/UR4S S9 /UR4QUQn[7UUUUUUUS 9$GNs sn n fs sn fs sn f7f) uPResolve the per-run capability layers and extract their contributions. Shared by [`iter`][pydantic_ai.agent.AbstractAgent.iter] / [`run`][pydantic_ai.agent.AbstractAgent.run] and [`realtime_session`][pydantic_ai.agent.Agent.realtime_session] so both wire capabilities up identically: the outermost `Instrumentation` injection, per-layer `for_run` resolution (never composing first — see below), optional deferred-loader injection, and the native-tool / instruction / model-settings / toolset contributions with `override(native_tools=...)` folded in. Each caller keeps its own surrounding logic (instrumentation *settings* resolution, model-settings layering, output toolset, the graph vs. the connection) and cross-references this method so the two stay in sync. `ctx` must already carry `metadata` (and, when instrumented, `tracer` / `trace_include_content`), since capability `for_run` hooks observe it. `base_is_override` is whether `base_capability` came from `override(root_capability=...)` (only the graph run supports that today), used solely for the native-tool validation error's `source`. Nrc3D># UHoRT5v M g7fr)r)r(capr s rr-2Agent._resolve_run_capabilities.. s/WJS C0@0@Js rc3<# UHoRSLv M g7f)TN)r8)r(rs rr-rI sYCXZ((D0CXszoverride spec capabilitiesrrzrun capabilitieszoverride native_tools)rrgrrbr"rcr,)rLrinsertr-gatherr_validate_runtime_capabilitiesrRrNrGrr_build_run_capabilitiesanyvaluesr%rgrrrrrrrryrr_ResolvedRunCapabilities)rZr r"r#r$r%r& run_layersr,resolved_extrasrrr*combined_layersrrg source_caprrbr"rrcbase_native_toolsextra_native_toolssome_native_toolss ` rrAgent._resolve_run_capabilities sQ4=L;aN`;a   *3FzSe3f3f   a!4 5!' /WJ/W XX*#o*>EWAX*X*Z[66 %4 `_EGXY^G_ZG_Z_ ` **ZC,@3GYCZ,Z[]lm m v +sSXz\]~,>tE{,Kchijcknsmt um  ?#a' ,7:?7Ka7O"?3UdefUg&56oUo6  !#  ).)9:/~>  " YBL (  04D@NJJ  !%;;=L ; ; =>L'::. s'$'d "55k4HH'ds$&) rzrrr*rrrrr)rZrArBoverride_instructionsr rs rrAgent._get_instructions s!% ; ; ? ? A $9#>#>#>K11+?XYd?ef#> 1T//0L   4D4P 0VZVlVl m&2##$'4'K'KLc'd$ s*B=c^ ^ ^ [URUS95nU(a!URR5c/UQUQn[ U5nUb5Um SU 4Sjjn[ Xx5nUR U5=(d Un[R"U5(aUO URnUb<Ub-Um UbUO URm SU U 4Sjjn [ X5n[ X/5nU$)aGet the complete toolset. Args: output_toolset: The output toolset to use instead of the one built at agent construction time. additional_toolsets: Additional toolsets to add, unless toolsets have been overridden. cap_toolsets: Per-run capability toolsets to use instead of the init-time capability toolsets. run_capability: The per-run capability instance, used to apply wrapper toolsets. max_output_retries: The effective output retry budget for this run (run kwarg / spec / agent default). Used as `ctx.max_retries` for the `prepare_output_tools` capability hook so it sees the same budget the run will actually enforce. Falls back to the agent-level default. )r;cB># TRX5IShvN $N7fr) prepare_tools)r  tool_defsfn_caps r_dispatch_prepare_tools3Agent._get_toolset.._dispatch_prepare_tools s$11#AAAAs cV># [UTS9nTRX!5IShvN $N7f)N)rp)rprepare_output_tools)r r output_ctxeffective_max_output_retries output_caps r_dispatch_prepare_output_tools:Agent._get_toolset.._dispatch_prepare_output_tools s,"):V!WJ!+!@!@!WWWWs )'))r rtrlist[ToolDefinition]rr) r_build_toolset_listrwrrrget_wrapper_toolsetr-rrFrI) rZr9r:r;rr<rcrrrrrrs @@@rrAgent._get_toolset s(&00l0KL 4#:#:#>#>#@#H88$78H/>x/H  % $F B+ B8L B% B &gGG%88ALWG+1==+H+HdNbNb  %), *<*H&dNfNf-X/XAgent.root_capability s$$$rc"UR5$)zAll toolsets registered on the agent, including a function toolset holding tools that were registered on the agent directly. Output tools are not included. rrYs rrcAgent.toolsets s ''))rc URSS9$)zThe toolsets this agent was built with, ignoring anything added afterwards. Read by `pydantic_ai.durable_exec` through `construction_toolsets`, which is where the reason it exists is written down. Tignore_overridesrrYs r_construction_toolsetsAgent._construction_toolsets s'''>>rrc/nU(dLURR5=n(a+[URSURUR S9nO UR nURU5 U(d>URR5=n(aURUR5 U$URUR5 U(aURSURO URnURU5 UbUO URHEn[U[5(aURU5 M+UR[!U55 MG U$)aEBuild the list of toolsets, optionally with per-run capability toolsets. With `ignore_overrides`, active `override(tools=...)`/`override(toolsets=...)` values and dynamic toolsets added with `@agent.toolset` after construction are skipped, so the result is what the agent was built with. See `Agent._construction_toolsets`. Nro)rxrrrrLr>rErrwrrHrrrrrxrz) rZr;rrc some_toolsfunction_toolsetsome_user_toolsetsdynamic_toolsetscap_tss rrAgent._build_toolset_list s?7943G3G3K3K3M%MZ%M 5   **"11    $55 ()4;R;R;V;V;X%X%7%X OO.44 5  OOD// 0$&&'P)P)PQ++  OO, -*6*B,HZHZZfo66OOF+OON6$:; [rcgrrrZr^s rrAgent._prepare_output_schema2 s^arcgrrrs rrr5 rrcUbHUR(a[R"S5e[RR U5nU$UR nU$)NzJCannot set a custom run `output_type` when the agent has output validators)r?r/rr+rrr>)rZr^schemas rrr: sR  "&& **+wxx))// . s%lOkmd=&9&9OkzRealtime sessions cannot reveal tools mid-session, so deferred capabilities that contribute tools or native tools are not supported; remove `defer_loading=True` from: .)rr2rrr$)r9r:r;rc^>Tb TRceTRRT5$r)session_build_run_result)lifecycle_state result_statesr_build_session_result>Agent._resolve_realtime_session.._build_session_results1".?3J3J3V VV"**<<\J Jrc># TceTb'TR(a[R"S5eTRcUTlgUTRlg7fNz6pydantic-ai: re-asserting a requested run cancellation)cancel_requestedrrr short_result_result)rrers r_finalize_session_resultAAgent._resolve_realtime_session.._finalize_session_resultsT". ..'L,I,I,,-eff&&./5,28''/sAAch># TbTceSUUUUU4SjjnS7v TR 5 g![RanU"S5UeSnAf[Ra6nU"S5nTR 5(aX!eUR U5 eSnAff=f!TR 5 f=f7f)Nc >TceTRn[R"UUbUR5O T=(d S[ T=(d S5TR TR TTS9$)Nr)r0rWr2r$rr)rr/ RunCancelled all_messagesrr2r$)messagerrrrr3rs r_run_cancelledXAgent._resolve_realtime_session.._translate_cancellation.._run_cancelled%so&222)11!..7>7JW113P_Pece&)/*?R&@%++(11!$3r,The agent run was cancelled by a nested run.The agent run was cancelled.rr rzexceptions.RunCancelled)r/rrrresolve _attach_torelease_issued) rr cancelledrerrrr3rs r_translate_cancellation@Agent._resolve_realtime_session.._translate_cancellation!s+0K KK   .++-** ^%%STZ]])) *+IJ ''))#,$$S)  ++-s=B20B2B A  B$1BBBB//B2F)rr) r r3rcmodel_request_parametersr"rrequest_messages model_profilerdrr lifecyclerr=r@)partsr)function_toolsrbsupports_tool_return_schema)rsupported_native_toolsc38# UHn[U5v M g7frr7)r(r%s rr-rs+WCV4DJJCVrzyRealtime sessions cannot reveal tools mid-session, so tools with `defer_loading=True` are not supported; remove it from: )rc8>TRT[TU5S9$)N)stream)wrap_run_event_streamr@)rrr3s r1Agent._resolve_realtime_session..s#>#G#G#,A+v,V$H$r) r r3rcrr"rrrrdrrwrap_event_streamrrrrzAsyncGenerator[None])frealtimerrrr|r'rrr{r;rmrfr}r~rrbuild_validation_contextrNrbrrKrrrrRrrrrrrrrr$rxrrrgitemsr8rrjoinr/rr>rr2rrr"rbrZrr~r[optionalrprofilerrcrrrr r enter_async_contextbindrfinishrrrrerr1ModelRequestParameters for_run_steprrrr*rDrr|rr r sorted ModelRequestprepare_return_schemasrresolve_request_tools frozensetrr% dataclassesrdeclared_function_toolshas_wrap_run_event_streamror)>rZr rr"rrcrgr2rr$rrrrrrmax_tool_retriesr#rdr$instrumentation_layersr*leafexplicit_instrumentationsexplicit_instrumentation session_instrumentation_settingsr"r&rrrundeliverable_capability_ids formatted_idseffective_model_settingsrb native_toolresolved_nativerrrrryielded session_stackrrcrrEinstruction_partsresolved_instructionsrrr-deferred_tool_namesformatted_namesr resolutionrerrrr3s> ``` @@@@@r_resolve_realtime_sessionAgent._resolve_realtime_sessionD s4 C%//(/E~~d#'>>P_`,,V_E557,9(t  , ,%&//2C *6)AvGYGYhlGm+/>T/*2(# ,*6)N)NtOgOgit)u &"889N|9\]#'#I#I#K E]Ei (@ Aos $#'"A"A"C!YFX!Y0% /)%0$ 23 0 / "% E^#+>+@((//?&> "24 (55Kk+=>>"-k":&&77,;&;O"*- {N;; @T@T@T##K06 ## (&//) $    44:G35D K K 9 9  . .  .>!##}*#///-9 )#778O8QRRR!!#&&|':':;"/"C"C(&#%:!9 # ,,'8"'(3)4_5F)G5;5R5R5T+C)--/*75U,;#)&5,0 #'W$##X 33G< < S>[W[\  (.'D'D()( $(.'D'D(,9,=,=>[]b,c( $(.'C'C(-*;*;5OS_SU_S&TR&_S'TR _S(TR@_6nUUl!UTR0l"UIShvN U7v SnSSS5IShvN SSS5IShvN SSS5IShvN U(agWRceW"UR57v gGNT!Snf=fGNGNNy!Snf=fNj!,IShvN (df  N=fNv!,IShvN (df  N=fN!,IShvN (df  N=f7f)*aDWorker behind [`AgentRealtime.session`][pydantic_ai.agent.AgentRealtime.session]. Opens the realtime session and drives the agent's tools. Users go through [`agent.realtime(model).session()`][pydantic_ai.agent.AbstractAgent.realtime]; see [`realtime`][pydantic_ai.agent.AbstractAgent.realtime] for the parameter reference. r&)r)RealtimeCodecEventRealtimeConnection RealtimeInputNr.zA WebRTC sideband session can't retain audio: the browser exchanges audio with the provider directly, so no audio bytes reach this connection. Leave `audio_retention` at 'transcript_only' (transcripts still build the conversation history).FTrc >"SST5nT"U"5TRTRTRRTTTRTR TRR S9 nXlSUlU$)Nc(\rSrSrSSjrSSjrSrg)YAgent._open_realtime_session.._closed_session.._SkippedRealtimeConnectioni1c6# [R"S5e7fNz._closed_session.._SkippedRealtimeConnection.send2s(22Zsc.[R"S5er=r>rYs r __aiter__cAgent._open_realtime_session.._closed_session.._SkippedRealtimeConnection.__aiter__7s(22ZrrN)r?r8rr)rz!AsyncIterator[RealtimeCodecEvent])rrrrr@rCrrrr_SkippedRealtimeConnectionr;1s  rrE)r rcr2rrrrr$T) r rcr3r2rrr$r_closed)rrErr7rrrrs r_closed_session5Agent._open_realtime_session.._closed_session-sy 1C *.0"..!)!6!6"..44!-$3$,$<$<#??%11:: #)"&rsupports_session_seedingzThe zJ realtime model does not support seeding a session with `message_history`.output_modalityaudiotextsupports_text_outputz realtime model does not support `output_modality='text'`; it only generates audio. Read the spoken answer from the transcript on the `SpeechPart` instead.)r0r"rr rc owns_mediainstrumentationrnrr2rr0r1r2r3rrrrr$agent_descriptionrr"r)rrrr)#rrrealtime.codecr6r7r8r/rr,rrrrrr  model_namer"connectrrconnect_webrtcrcrdr%r3r2rrrr$rrrrrealtime_session)rZr rr"rrcrgr2rr$rrrr0r1r2r3r4r6r8rNr%rrGrJconnection_manager connectionrr7rrs ` ` @@@r_open_realtime_sessionAgent._open_realtime_sessionsl8 /ZZ&- o1BB&&X  11 )%%%++2   **I( ((  <'' --999 #))*@*@AA"Gu   xx'='='A'AB\^c'd'd **8>>4478)) (66<"AABSU\]O&(1G1G1K1KLbdh1i1i **8>>4478,,$+ &&%66#+#:#:-5-N-N' ^^22$%66#+#:#:-5-N-N 3 *)Z) ".. "*!6!6  *  %-$E$E  $yy3G #..44 ". %4 %4 +@ '8  %4! "%-$<$<# $$??% &"*!6!6' (&11::) .$<<H//0D0D0I0IJ!1 4%45 :.6-N-N; <$,#:#:= >'/&@&@? B%, !8?$$5"7'% "& #7I*)w  J   %%111i4455] r#Gs v*H##' #777I*)))w    s(AP! N4!P!$>P#N78P; P!N>P! EPOPD,O+ O O+OOO O+"O #O+' P2O)3P7 P!P2P!7N;;P>P!PO+O O O+O& O O& "O+)P+P 1O42 P >PP!P P  PP!cd# URIShvN URS:XGa[5IShvN nUR5nUR U5IShvN UR 5nUR 5nURR5nUb URnO5[U5(a[U5(dSnOUbUnO URnUb[U[5(aUR(d[U5(aUO[ R""U5nUR U5IShvN UR$R'[)U55 [U[5(aXpR*[)U5U4'UR-5UlSSS5IShvN U=RS- slSSS5IShvN U$GNGNGNNN6!,IShvN (df  NK=fN-!,IShvN (df  U$=f7f)aEnter the agent context. This will start all [`MCPToolset`s][pydantic_ai.mcp.MCPToolset] registered as `toolsets` so they are ready to be used, and enter the model so the provider's HTTP client will be closed cleanly on exit. This is a no-op if the agent has already been entered. Nrr)r[rSr rr rrrvrrrzrr rr rr1rraddrrpop_allrU)rZ exit_stackrrcapability_modelrstatic_selectionr s r __aenter__Agent.__aenter__s###""a')++z"//1G$88AAA!%!@!@!BJ'1';';'=$%)%9%9%=%=%?N%1+9+?+?(!"233IFV]>]1::J0K0K,QWQcQcdtQu)<%&6<^_'1'9'9';D$7,+8   1 $ =$#> ?$+A(D-,+++$##> sH0G,H0 HG/H%G9 G2!C(G9 G5 A+G95 HG7H H0%H&H0/H2G95G97H9H ?H H HH0H-H  H-(H0c6# URIShvN U=RS-slURS:XakURb^URR5IShvN SUlURR 5 UR R 5 SSS5IShvN gNNR!SUlURR 5 UR R 5 f=fNI!,IShvN (df  g=f7f)Nrr)r[rSrUacloserrr)rZargss r __aexit__Agent.__aexit__s###   1 $ ""a'D,<,<,H>**11333'+D$++11355;;=$##4'+D$++11355;;=$###snDB9D3C? B=(B;)B=-;C?( D3C=4D;B===C::C?=D?DD  DDc^^U(a[R"U5OUR5mSSK J m SUU4SjjnUR5RU5 g![RaunUR 5nUcF[ UR55(dUR(a[R"S5Ue[R"S5UeSnAff=f)zSet the sampling model on all [`MCPToolset`s][pydantic_ai.mcp.MCPToolset] registered with the agent. If no sampling model is provided, the agent's model will be used. Nz{The capability model requires run dependencies and cannot be used for MCP sampling setup. Pass a concrete model explicitly.z9No sampling model provided and no model set on the agent.r&) MCPToolsetcL>[UT5(aURT5 ggr)rset_sampling_model)rrhsampling_models r_set_sampling_model9Agent.set_mcp_sampling_model.._set_sampling_models#':..**>:/r)rAbstractToolset[AgentDepsT]rr) r1rrr/rrrzrrmcprhrr)rZr errlrhrks @@rset_mcp_sampling_modelAgent.set_mcp_sampling_models k:?V//6TE`E`EbN % ; ; !!"56## k88:J}(:+?+?+A"B"BjFeFe **8&&'bcij j ks-A C)4A0C$$C)r1rr"r html_source allowed_hostsc &SSKJn U"UUUUUUUS9$)a Create a Starlette app that serves a web chat UI for this agent. This method returns a pre-configured Starlette application that provides a web-based chat interface for interacting with the agent. By default, the UI is fetched from a CDN and cached on first use. The returned Starlette application can be mounted into a FastAPI app or run directly with any ASGI server (uvicorn, hypercorn, etc.). Note that the `deps` and `model_settings` will be the same for each request. To provide different `deps` for each request use the lower-level adapters directly. The agent's configured native tools (registered via `capabilities=[NativeTool(...)]` or higher-level capabilities like `WebSearch()`) are automatically exposed as options in the UI. Args: models: Additional models to make available in the UI. Can be: - A sequence of model names/instances (e.g., `['openai:gpt-5', 'anthropic:claude-sonnet-4-6']`) - A dict mapping display labels to model names/instances (e.g., `{'GPT 5': 'openai:gpt-5', 'Claude': 'anthropic:claude-sonnet-4-6'}`) The agent's model is always included. Native tool support is automatically determined from each model's profile. deps: Optional dependencies to use for all requests. model_settings: Optional settings to use for all model requests. instructions: Optional extra instructions to pass to each agent run. html_source: Path or URL for the chat UI HTML. Can be: - None (default): Fetches from CDN and caches locally - A Path instance: Reads from the local file - A URL string (http:// or https://): Fetches from the URL - A file path string: Reads from the local file allowed_hosts: Additional hostnames to answer to, e.g. `['ui.example.com']` or `['*.example.com']` (subdomains only, so list the apex separately if you serve it). IP addresses and `localhost` are always allowed; any other `Host` header is refused with a `421`, so that a website cannot reach the UI on your machine by pointing a hostname it controls at you (DNS rebinding). Pass `['*']` to answer to any host, only if something in front of the app already authenticates requests. Returns: A configured Starlette application ready to be served (e.g., with uvicorn) Example: ```python from pydantic_ai import Agent from pydantic_ai.capabilities import NativeTool from pydantic_ai.native_tools import WebSearchTool agent = Agent('openai:gpt-5', capabilities=[NativeTool(WebSearchTool())]) # Simple usage - uses agent's model and native tools app = agent.to_web() # Or provide additional models for UI selection app = agent.to_web(models=['openai:gpt-5', 'anthropic:claude-sonnet-4-6']) # Then run with: uvicorn app:app --reload ``` r&)create_web_apprs)ui._webrw)rZr1rr"rrtrurws rto_web Agent.to_webs*H - )%#'  r)0rrrrrRrr<r/rrSrrrrPrUrEr*r5rIrJr:r,r-r>rFr3r?rurzr{rvr|rtryr}rr~rxrwrrDrCrBrLrHrNr0r")rz anyio.Lockr)&r r+r^r2rAgentInstructions[AgentDepsT]r_str | Sequence[str]r`r;r%rrar.r"r1rint | AgentRetries | NonerbrMrAbstractAsyncContextManager[AgentRun[AgentDepsT, OutputDataT]])(rrr^OutputSpec[RunOutputDataT]rrrrrrrrr r+rr{rrfr"r1rrrrr2rr$r9rr}rrrcrrgrrrrzAAbstractAsyncContextManager[AgentRun[AgentDepsT, RunOutputDataT]])(rrr^OutputSpec[Any] | Nonerrrrrrrrr r+rr{rrfr"r1rrrrr2rr$r9rr}rrrcrrgrrrrz)AsyncGenerator[AgentRun[AgentDepsT, Any]])&rrr^rrrrrrrrrr r+rr{rrfr"r1rrrrr2rr$r9rr}rcrrgrrrrz"_PreparedAgentRun[AgentDepsT, Any])r rtrr9rr#)rr9r rtrr#)rz[GraphRunContext[_agent_graph.GraphAgentState, _agent_graph.GraphAgentDeps[AgentDepsT, Any]]r$r9rr#)r)rrrrrz_ResolvedSpec | None)r%zstr | _utils.UnsetrzAgentDepsT | _utils.Unsetr z9models.Model | models.KnownModelName | str | _utils.Unsetrcz4Sequence[AbstractToolset[AgentDepsT]] | _utils.UnsetrzKSequence[Tool[AgentDepsT] | ToolFuncEither[AgentDepsT, ...]] | _utils.Unsetrbz4Sequence[AgentNativeTool[AgentDepsT]] | _utils.Unsetrz,AgentInstructions[AgentDepsT] | _utils.Unsetr$z(AgentMetadata[AgentDepsT] | _utils.Unsetr"z-AgentModelSettings[AgentDepsT] | _utils.Unsetrz!int | AgentRetries | _utils.UnsetrrrzGenerator[None])r.Callable[[RunContext[AgentDepsT]], str | None]rr)r9Callable[[RunContext[AgentDepsT]], Awaitable[str | None]]rr)rCallable[[], str | None]rr)r#Callable[[], Awaitable[str | None]]rr)r%rrFCallable[[SystemPromptFunc[AgentDepsT]], SystemPromptFunc[AgentDepsT]])r#SystemPromptFunc[AgentDepsT] | Noner%rreCallable[[SystemPromptFunc[AgentDepsT]], SystemPromptFunc[AgentDepsT]] | SystemPromptFunc[AgentDepsT])rrfr r+rrrrr2rr"r!rz list[_messages.SystemPromptPart])rrrr)rrrrrr)rr?r*rBrCrDrErFrHrIrJrLrNrPrRrSrUrcached_propertyr[rr objectrj classmethodrrr staticmethodrpropertyrsetterr r%rarr`r^rrbrrrrrrrrryrr-rrrr r_rr#r-rkrHrrrrrjr{rxrrrIrrrr|rrrr>rcrrrr,rXr`rerqryrrrrrrs!& >= 66 :9*)66EJAI2=2C2C2OI/O#.#4#4%#@J @8C8I8Iu8UN5UQ\QbQbhmQnNnHSHYHY_dHeMEe'2'8'8e'DO_DT_TeTekpTqQqalarar b$&^6A5F5FE5R2R8C8I8Iu8UO5U8C8I8Iu8UN5U*00e<<(..E:s:"-"3"3"?M<?ITIZIZ`eIfFfCNCTCTZ_C`@`KVK\K\bgKhHh%++7NC7)4):):)FK&FDH036:-/&,<@@D-1LPNP>B"'$.59%)<@EI)@-  4  + $:>+JL<  "!"3#$#%&:'(C)* +.DH036:-/&,<@@D-1LPNP>B"'$.59%)<@EI)@-  4  + $:>+JL<  "!"3#$#%&:'(C)* +2DHE'036:-/&,<@@D-1LPNP>B"'$.59%)<@EI)E'@E'- E' 4 E' + E'$E'E':E'>E'+E'JE'LE'<E' E' "!E'"3#E'$#%E'&:'E'(C)E'* +E'N LNCG'*/3-/59/3-1"&@B7;"'+/.2%)<@>B+!(!"I ! A ! % !-!+!!3!-!+! !>!5!  !!")#!$,%!&#'!(:)!*<+!, -!!0 LNCG'*/3-/59/3-1"&@B7;"'+/.2%)<@>B-(  "I  A %-+3-+ > 5!" #$)%&,'(#)*:+,<-. /2 $DzKMCG'*/3-/59/3-1"&@B7;"'+/.2%)<@>B-k(k k "I k A k%k-k+kk3k-k+k k>k 5!k" #k$)%k&,'k(#)k*:+k,<-k. /kkZ /3KMCG'*/3-/59/3-1"&@B7;"'+/.2%)<@>B-!!, ! "I ! A !%!-!+!!3!-!+! !>! 5!!" #!$)%!&,'!(#)!*:+!,<-!. /!!2 /3KMCG'*/3-/59/3-1"&@B7;"'+/.2%)<@>B/,    "I A%-+3-+  >!"5#$ %&)'(,)*#+,:-.B/::, :  : "I :A:%:-:+::3:-:+: : >!:"5#:$ %:&)':(,):*#+:,:-:.M0M5M&M 3!M"+#M$%M&?'M(C)M*0+M, H-MM0EIP DH<@&*!CG6:@D267;(,59-1AEEI26+PAP0 P A P : P$PPAP4PP>P0P5P&P 3!P"+#P$%P&?'P(C)P*0+P, K-PP0EIP/3CG<@&*!CG6:@D267;(,59-1AEEI26+PAP, P A P : P$PPAP4PP>P0P5P&P 3!P"+#P$%P&?'P(C)P*0+P, 3-PPhEIw /3CG<@&*!CG6:@D267;(,59-1AEEI26)w Aw , w A w : w $w w Aw 4w w >w 0w 5w &w 3!w "+#w $?%w &C'w (0)w * ,+w xAE- #->-  - 0$  !r!3!  !LN+ /+ "I+   + Z$*<<*0,,KQ<  5>15>  5> o 5>t CGCG?C(,/39 9 A 9 A 9 = 9 &9 -9  *9 v=B= 7==HMH BHH__ uu $)U!U OUU 595  515  5 o 5nKPK EKKV[V PVV383 -33>C> 8>>#H# =#J:?: 4::BFK(K3?K EKK aeFR!% FR]FR#FR FR FRPtt  "&"6:KO,2/45K" "'*. $#-1%k k  k  k4kIk*k)-k3kkk k(k !k"#k$ +%k& f'kk.@DoH  "&"6:KO,2/45K" "'*. $#-1'oH<oH  oH  oHoH4oHIoH*oH)-oH3oHoHoH oH (!oH"#oH$%oH& +'oH( )oHb^^  "&"6:KO,2/45K" "'*. $#-1%O O  O  O4OIO*O)-O3OOO O(O !O"#O$ +%O& J'OO.26nH  "&"6:KO,2/45K" "'*. $#-1'nH.nH  nH  nHnH4nHInH*nH)-nH3nHnHnH nH (!nH"#nH$%nH& +'nH( )nH`WW " K K  K F KK04&N " &N,&N  &N  &N &NPe kF k 3 kQBF @ ?    BJ." Q"F Q - Q$GK !3    D  >GK H,H3 H 6 H D H )H"3@ $T(O M #M 8 M A M 7 M !%M M  .M bBFVZ"!>"T" < "LMSLLLPBF@D)- DIDJD@ D > D ' D %DL%%**??CG-"' -?- - + -^aa 353 -33  7;DHAEEI(,2659&*!CG#i ;i  i 5 i B i ?i Ci &i 0i 3i $i i Ai i @!i i V   7;DHAEEI(,2659&*!CG*; %%&(+;?'x6;x6 x6 5 x6 B x6?x6Cx6&x60x63x6$x6x6Ax6(x6 !x6" ##x6$&%x6&9'x6( ))x6x6t'R >76#/3#')-.2N N  N - N ! N 'N ,N  N N rrcf\rSrSr%SrS\S'\R"SSSS9rS\S 'S S jr SS jr S r g)riHzAEnter every model selected by a run on its shared resource stack.zset[int]entered_model_idsNF)rr)r8rT_stackc.URbeXlgrr)rZstacks r bind_stack_RunModelResources.bind_stackOs{{""" rc# [U5nX R;agURceURRU5IShvN URR U5 gN 7fr)rrrr r[)rZrmodel_identitys rr]_RunModelResources.enter_modelSs_N+ 33 3 {{&&&kk--n=== "">2 >sA A. A, !A.r)rr rr)rrrr) rrrrrrrrrrr]rrrrrrHs0K$/$5$5dUZ$[F ![3rrc\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S '\S$S!j5rS"rg#)%ri\zGThe fully assembled inputs and resources for one graph-based agent run.zGraph[_agent_graph.GraphAgentState, _agent_graph.GraphAgentDeps[_PreparedDepsT, _PreparedOutputT], _agent_graph.UserPromptNode[_PreparedDepsT, _PreparedOutputT], _result.FinalResult[_PreparedOutputT]]rjz_agent_graph.GraphAgentStaterkz=_agent_graph.GraphAgentDeps[_PreparedDepsT, _PreparedOutputT]rlz=_agent_graph.UserPromptNode[_PreparedDepsT, _PreparedOutputT]rmr rnzRunBinding | Nonerorrrr rrprrqz"AbstractCapability[_PreparedDepsT]rzAbstractToolset[_PreparedDepsT]rz_usage.UsageLimitsrrQrrzCallable[[GraphRunContext[_agent_graph.GraphAgentState, _agent_graph.GraphAgentDeps[_PreparedDepsT, _PreparedOutputT]]], dict[str, Any] | None]rsc ^^ ^ ^ # TRm TRm T Rn[U[R 5(de[ S U U 4Sjj5n[5IShvN nURU"55IShvN T RR5 URT RR5 URUR5 TRb%T RRTR5 TR R#U5 UR[$R&"TR(STR*355IShvN TR,(a-TR R/TR05IShvN URTR2R5TR6T T SSS95IShvN n[9U5m TR:bT TR:lTR?T R@5 [BRD"T R@5nS U U U4SjjnS U 4SjjnS U 4Sjjn[GTRHUUUUU 4SjUS 9IShvN URTRJ5IShvN T 7v T RLbTR?T R@5 SSS5IShvN SSS5IShvN gGNGNGNGNbGN'NNd!T RLbTR?T R@5 ff=fNV!,IShvN (df  Nk=fNb!,IShvN (df  g=f7f)Nc># SUU4SjjnS7v TRR5 g![RanU"S5UeSnAf[RaGnTRR 5nU(a U"S5UeU"S5R U5 eSnAff=f!TRR5 f=f7f)Nc4>[R"UTT5$r)r'run_cancelled_snapshot)rrlrks rrO_PreparedAgentRun.open.._translate_cancellation.._run_cancelleds#::7E:VVrrrz@The agent run was cancelled by an external asyncio cancellation.r)r/rrrrerrr)rr first_partyrlrks rr7_PreparedAgentRun.open.._translate_cancellations W W 96''6685** ^%%STZ]])) (55==? ()GHcQ abmmnqr  ''668s> C /C B* A  B*#AB%%B**B--C  C zagent:F)inputsrkrspanrc># TRRUR5 TRR(a[ R "S5eUTlg7fr)r check_costr2rerrr_result_override)rrrlrZs rr0_PreparedAgentRun.open.._finalize_resultsI!!,,V\\:**;;!001ijj-3 *sAA"c.>TR=(d U$r) _node_error)rrs r_extract_error._PreparedAgentRun.open.._extract_errors!,,55rc*>TRnUceU$rr)rrs r _build_result-_PreparedAgentRun.open.._build_results"))))) rc >TRSL$rr)rsrr(_PreparedAgentRun.open..sY%5%5T%Ar)rrrrrrr)rrrrr)'rlrkrrr)PendingMessageQueuerr r rerrrcloser attach_tokenrqrrget_concurrency_contextrrrnrpr]r rjrrmr_rorrsr r'r7rrrr) rZpending_message_queuerr graph_runrrrrrrlrks ` @@@rr_PreparedAgentRun.openxs__   % 6 6/1M1MNNNN  9  9D"##u++,C,EF F F  # # ( ( * NN:2299 : NN066 7&&2''44T5L5LM  + +E 2++44T5M5MQWX\XgXgWhOij  11**66tzzBBB#77 00#$  I!+I||'*3 &  ! !)-- 0#44Y]]CG 4 4 6   ,##*),A#(  // ====#O ''3--imm<#  {$## F  CL >!''3--imm<4!    {$###sA&N,L -N0M, L C+M,6L7=M,4L5=M,2L3B#M,LM,M9L:M?L (M, M,7M8M,< NM*NM,M,M,M,M,M +M  MM,M' M M' #M,*N,N2M5 3 N?NrN)rz:AsyncGenerator[AgentRun[_PreparedDepsT, _PreparedOutputT]]) rrrrrrrrrrrrrr\s~Q  ('MMSSO 00 #''''66 ,,$$GG w=w=rrc`[U5nUR[U55 U(dgU$)zuMerge an explicit `retries=` value with the retry fields on an `AgentSpec`. Explicit kwarg keys win over spec keys. N)rrr)explicitrmergeds rrrs+( -F MM28<=  MrcPSUR;a[UR5$0$)z.s mOlt:d$ABBBOlrc)rfrR)rs rrQrQs mO`akOlm mmrcD\rSrSr%SrS\S'S\S'S\S'S \S 'S rg ) rei zNWhat a chat session can say about itself before any run has resolved anything.r r r&rrrgrrdrNrrrrrere sX J brrecn[H+n[X5(aMURU"55 M- g)zEnsure all auto-injected infrastructure capabilities are present. Each capability's own `CapabilityOrdering` (e.g. `position='outermost'`) determines its final placement, so insertion order here doesn't matter. N)rrLr)rgcap_types rrr*s) 2"<::    +2rc>0nUGH nURSLa#URc[R"S5eURcME[R "URSS9 UR UR5nUbc[URU[U515 [[U55(d)[R"[UR55eURUR[U55 GM [U5$)aIValidate capability `id`s and return the set of explicit ones. Rejects deferred capabilities that lack an explicit `id`, and ids shared by capabilities that have not said how they compose. Capabilities whose class declares a default `id` (what `_declares_default_id` reads off the class body -- `Thinking` declares one and overrides nothing) are allowed to repeat: their duplication is resolved over the whole composed tree at run setup by `_combine_duplicate_capabilities`, the only place `combine` is called. Rejecting the rest here means the common mistake still surfaces in `Agent(...)` rather than on the first run. Shared by construction-time validation over the statically-provided capabilities and run-time assembly, which also covers capabilities supplied per-run or returned by `for_run` and so can't be checked at construction. TzjDeferred capabilities must use stable explicit `id` values. Pass `id=...` when using `defer_loading=True`.z Capability id)kind) r8rr/rr*validate_instruction_id_segmentrrPrrOrQ setdefaultr)rgownersrowners rrr5s8:F    $&&A  66> 55cff?S 366"   %cffud3i.@ A'S 22 **+?+GHH#&&$s),#$ v;rcR0nUHn[U[5(a UROU4nUHrnURcMUR URU5=oTLdM4[ [ U55(aMO[R"SUR<S35e M g)aReject two instruction sources that would contribute parts under one `capability:` key. `_validate_capability_ids` walks the flattened capabilities, but a `CombinedCapability` subclass that overrides `get_instructions` contributes as a source in its own right and is deliberately retained rather than splatted, so it never appears in that list. Its `id` therefore went unchecked, and a sibling could share it -- leaving an application unable to tell whose text `capability:` addresses, which is the one thing the key exists to make unambiguous. Runs at construction, after `for_agent`, and again on the tree a run actually resolves to. The last of those is not redundant: a capability passed to `run()` joins the retained container the same way a registered sibling does, and `for_run` may hand back a capability carrying a different `id` than the one construction saw. Sources whose class declares a default `id` are exempt at construction for the same reason they are in `_validate_capability_ids`: the run resolves them to one source before any instructions are collected, so the `capability:` key is unambiguous by the time it is used. The run-setup call sees the already-combined tree, where a surviving duplicate is a genuine conflict. NzCapability id zk is used by multiple capabilities that contribute instructions. Capability ids must be unique within a run.) rrG_instruction_sourcesrrrOrr/r)rg sources_by_idrsourcesrrs rrrZs&9;M" *&899  + +  Fyy )44VYYGGV_sV ``!**$X[[O4PP  #rc0nUHin[U[5(dMURURU5nXCLdM<XC:wdMC[R "SUR<SUS35e g)aReject native tools that share a `unique_id` but carry conflicting definitions. Native tools are keyed by `unique_id` when request parameters are deduplicated (see `Model.prepare_request`). That dedup is intentionally last-wins *across* layers, so a run-level native tool can override an agent-level default with the same id. *Within* a single layer, though, two different tools sharing an id are ambiguous: the silent last-wins would bind a stable id (e.g. an `MCPServerTool` id) to an unexpected definition such as a different server URL or authorization token. Fail fast here instead. Identical duplicates are allowed and collapsed later. `NativeToolFunc` callables are skipped: they have no stable `unique_id` to key on. zNative tool id z$ maps to conflicting definitions in z;. Native tool ids must be unique within a capability layer.N)rrZr unique_idr/r)rbrseenr-rs rrrsx+-D$ 233 ??4>>48  H$4&&!$..!33WX^W_`LL  rc`\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S'S\S'Srg)riaThe per-run capability state shared by `run`/`iter` and `realtime_session`. Produced by [`Agent._resolve_run_capabilities`][]: the resolved capability tree plus the contributions extracted from it (instructions, native tools, model settings, toolsets), so both a graph run and a realtime session wire capabilities up identically. See the cross-references on the two call sites for the surrounding logic each keeps to itself. rr)dict[str, AbstractCapability[AgentDepsT]]rgrrz!list[AgentNativeTool[AgentDepsT]]rbr1r"z%list[AgentToolset[AgentDepsT]] | Nonercrr,rNrrrrrrs932;;KK33993399_rrr0c~UnX0lUH.n[U5(aU"U5OUn[X55nX0lM0 U$)u'Merge model-settings layers left-to-right, stamping `run_context.model_settings` before each. Each layer is a static `ModelSettings`, a callable resolved against the run context, or `None`. Stamping the merged-so-far onto `run_context.model_settings` before a callable layer runs lets it observe the previous layers — the agent -> capability -> run order both `iter` (per model-request step) and `realtime_session` (once, at connect) rely on. `base` is the model's own settings for a graph run; a realtime model has none, so it defaults to `None`. )r"rzrb)r3layersr1rr*rs rr2r2sDF!')1%5%e%f7%+" Mrc/nURUR5 [U5n0nUH:nURnUc$[ [ U5UR 5U-S9nXCU'M< U$)N)taken)rrrr_synthetic_capability_idrr)rrg explicit_idsby_idrrs rrrsp9;L\(() ,L9L79E  4T#YejjlUaFabM"m  Lrc|[UR5nSUS[5RSSS3nX1;aU$M')aA key for a capability the user never named, shaped so nobody mistakes it for a name. Every capability in a run needs a key, including the ones with no `id`, or `ctx.capabilities` could not list them. Nothing carries such a key out of the run: the paths that persist one -- the load records progressive disclosure reads back out of message history -- all require `defer_loading=True`, which in turn requires an explicit `id`. So this is a run-local handle, and the only thing wrong with the `thinking` / `thinking_2` it used to be was that it looked exactly like an `id` somebody chose. It looked stable, too, and wasn't: the ordinal counted from attachment order, so listing two anonymous capabilities of one class the other way round swapped which of them owned `thinking_2`. Nothing depended on that, because nothing may -- but a reader who copied the key out of `ctx.capabilities` had no way to tell. Angle brackets say "the framework named this", the way `''` and `''` already do for toolsets. The class name keeps the registry and a traceback readable. The random suffix is the part that matters: it differs every run, so relying on it fails immediately and visibly rather than the next time someone reorders a list. <:N>)rrrhex)rr base_id candidates rr r sG(s||$G y%'++bq/!2!4  !  rcSU[S5LaUOS0n[U[5(a[R"XS9nOUnUR US'X24$)zValidate a spec dict/object and build the template context. Shared by `Agent.from_spec()` and `Agent._resolve_spec()`. Returns: A tuple of (validated_spec, template_context). r`N)contextr)rrdictrmodel_validater)rr`rrs rrrs\ )4:"=Y4($"11$Q&4&@&@]#  ++rc |^SSKJn [U5nSU4SjjnURXES9nURR U5n/nUR H!n [UU SSUS9n URU 5 M# UURRU5 $!URRU5 f=f) zInstantiate capabilities from an AgentSpec using the capability registry. Shared by `Agent.from_spec()` and `Agent._resolve_spec()`. rrcF>[XUT5upUR"U0UD6$r)rBr)cap_clsrdkwargsrs r_instantiate_cap1_capabilities_from_spec.._instantiate_caps, /wfFVW   $1&11r)registry instantiaterr)labelcustom_types_paramr )rtype[AbstractCapability[Any]]rdztuple[Any, ...]rrurAbstractCapability[Any]) pydantic_ai.agentrrCapabilitySpecContextcapability_spec_contextrrgr$rr) rrr _agent_specrrr rrgcap_specrs ` rrr s6&'>?H2.222 ! 2  + +X + \C  / / 3 3C 8E 968 ))H+"#<, J    +*++11%8 ++11%8s 4BB;c^\rSrSr%S\S'/4SSSS.S U4Sjjjjr\S Sj5r\S Sj5rS r U=r $) ri3rrrNrprqrc.>XPl[TU] XX4S9 g)Nr+)rrsuperrj)rZrrprqrrr __class__s rrj_AgentFunctionToolset.__init__7s+ Prc[$rr~rYs rr_AgentFunctionToolset.idCsrcg)Nz the agentrrYs rr!_AgentFunctionToolset.labelGsr)rr) rr~rpr&rqrKrrrrrr) rrrrrrjrrr!r __classcell__)r.s@rrr3s,,OQ Q#' $ QK Q Q  Q  Q1 Q Q  rr)rr$rzRunContext[Any]rz!Callable[[], AgentRunResult[Any]]rz0Callable[[AgentRunResult[Any]], Awaitable[None]]rz/Callable[[BaseException], BaseException] | NonerzCallable[[], bool] | NonerrTrzAsyncGenerator[_RunLifecycle])rrrzTypeIs[models.Model[Any]])r z#_instructions.AgentInstruction[Any]rz"_messages.InstructionSource | None)rrrrrr)rr}rr)rr}rrrzAgentRetries | None)rrrr)rr$rr)rglist[AbstractCapability[Any]]rr)rg!Sequence[AbstractCapability[Any]]rzset[str])rgr6rr)rbzSequence[AgentNativeTool[Any]]rr rr)r3rtrz/Sequence[AgentModelSettings[AgentDepsT] | None]r1r!rr!)rrrr)rr#r zCollection[str]rr )rrr`rrz tuple[AgentSpec, dict[str, Any]])rrrrrrurr5) __future__r _annotationsrrrrrrcollections.abcrrrrrr r r contextlibr r rrrrrpathlibrtypingrrrrrrrruuidrrWopentelemetry.tracerpydantic.alias_generatorsrpydantic.json_schemartyping_extensionsr r!r"pydantic_ai._instrumentationr#pydantic_ai._specr$4pydantic_ai.capabilities._deferred_capability_loaderr%r'r(r)r*r+r,r-r.rr/r0r r1r2r}r3r4r5r6r7r8_cancelr9r:r;r<_deferred_capabilitiesr=r>r? _run_contextr@rA _templaterB _warningsrCrgrDrErFrGrHrIrJ ToolSearchCapcapabilities._dynamicrKcapabilities._orderingrLcapabilities._pending_messagesrMcapabilities.abstractrNrOrPrQrRcapabilities.combinedrScapabilities.hooksrTrUrVcapabilities.instrumentationrWrmodels.instrumentedrXrYrbrZnative_tools._tool_searchr[rr\r]r^runr_r`rrarbtemplatercrcrdrerrfrgrhrirjrkrlrmrnrorprqrrrsrtrurvrwrcrxrytoolsets._dynamicrzr{ toolsets._instruction_collectionr|toolsets._tool_searchr}toolsets.abstractrtoolsets.combinedrtoolsets.functionrtoolsets.preparedrabstractrrrrrrrrrrrrrrwrapperrstarlette.applicationsrpydantic_graphrrrrrrrrrrrrrxr__all__ dataclassrrrrrrrrrrrrNoneTyperrrrrrrrrrQrerrrrrr2rr rrrrrrrest2    #]]] *.333H0Y    WVE-#I/4:8J;??PL-6<<*:"=(5L:0///    5!05$& 6 d#$ d#$FJ.204r$+r$ r$4 r$ ? r$ C r$,r$.r$#r$r$j+ uGHm  CL CL)*-. :     E"G: M*k1 2G: #G: Tt 333& S=0@ @AS=S=l '    h -/D!LHJnJ,"J#L2 _wz2__2"& ' ;    .(6, $,,&,,%9 %9D%9%%9# %9P E"OJ7#r