"j%SSKJr SSKJr SSKJr SSKJrJrJ r J r J r SSK J r Jr SSKJr SSKJrJrJrJrJrJr SSKJr SS KJr SS KJr SS KJrJ r J!r!J"r"J#r# SS K$J%r% SS K&J'r'J(r( SSK)J*r*J+r+J,r,J-r- SSK.J/r/J0r0J1r1J2r2J3r3J4r4J5r5 SSK6J7r7J8r8 SSK9J:r: SSK;Jr> SSK?J@r@JArA SSKBJCrC SSKDJErEJFrFJGrGJHrHJIrI SSKJJKrK SSKLJMrM SSKNJOrO SSKPJQrQ SrRS\SS'SrTS\SS 'S!rUS\SS"'S#rVS\SS$'S%rWS\SS&'S'rXS\SS('S)rYS\SS*'S+rZS\SS,'\[\\\[\4-r]S\SS-'\\\[\4r^S\SS.'\ \]/\\^4r_S\SS/'\ \^/\\4r`S\SS0'\[\\\[\4-raS\SS1'\ \a/\\4rbS\SS2'\ \/\\4rcS\SS3'\S4rdS5reS\SS6'\[\4\/-rf\"S7S855rg\"S9S:9"S;S<\\\/55rhSHS=jriSIS>jrj\"S?S@9"SASB\\/55rkSJSCjrlSKSDjrmSLSEjrnSMSFjrogG)N) annotations)ABC)Counter) AsyncIterable AwaitableCallable CollectionSequence)KW_ONLY dataclass)chain) TYPE_CHECKINGAnyClassVarGenericLiteral TypeAlias)ValidationError) deprecated)_utils)AgentInstructionAgentInstructionsSourcedInstructionnormalize_instructionssourced_instruction)PydanticAIDeprecationWarning) ModelRetry UserError)AgentStreamEventCapabilityInstructionSource ModelResponse ToolCallPart) AgentDepsTAgentNativeToolDeferredToolRequestsDeferredToolResults RunContextSystemPromptFuncToolDefinition)AbstractToolset AgentToolsetmerge_capability_fields)collect_on_event_methodsmarked_listens_to) _agent_graph) AbstractAgentAgentModelSettings PrefixTools)KnownModelNameModelModelRequestContextModelResolutionContextModelSelectionContext) OutputContext) FinalResult)AgentRunResult)Endz'_agent_graph.AgentNode[AgentDepsT, Any]r AgentNodez?_agent_graph.AgentNode[AgentDepsT, Any] | End[FinalResult[Any]] NodeResultz,Callable[[], Awaitable[AgentRunResult[Any]]]WrapRunHandlerzCallable[[_agent_graph.AgentNode[AgentDepsT, Any]], Awaitable[_agent_graph.AgentNode[AgentDepsT, Any] | End[FinalResult[Any]]]]WrapNodeRunHandlerz9Callable[[ModelRequestContext], Awaitable[ModelResponse]]WrapModelRequestHandlerzModel | KnownModelName | strModelSelectionzYCallable[[ModelSelectionContext[AgentDepsT]], ModelSelection | Awaitable[ModelSelection]] ModelSelectorz*ModelSelection | ModelSelector[AgentDepsT] AgentModel RawToolArgsValidatedToolArgsWrapToolValidateHandlerWrapToolExecuteHandler RawOutputWrapOutputValidateHandlerWrapOutputProcessHandler) outermost innermostz7type[AbstractCapability[Any]] | AbstractCapability[Any] CapabilityRefcX\rSrSr%SrSrS\S'SrS\S'SrS\S 'Sr S \S 'Sr g) CapabilityOrderingaXOrdering constraints for a capability within a combined capability chain. Capabilities follow middleware semantics: the first capability in the list is the **outermost** layer, wrapping all others. Declare ordering constraints via [`get_ordering`][pydantic_ai.capabilities.AbstractCapability.get_ordering] to control a capability's position in the chain regardless of how the user lists them. When a [`CombinedCapability`][pydantic_ai.capabilities.CombinedCapability] is constructed, it topologically sorts its children to satisfy these constraints, preserving user-provided order as a tiebreaker. NzCapabilityPosition | NonepositionzSequence[CapabilityRef]wraps wrapped_byz'Sequence[type[AbstractCapability[Any]]]requires) __name__ __module__ __qualname____firstlineno____doc__rT__annotations__rVrWrX__static_attributes__rU^/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/capabilities/abstract.pyrRrRsI +/H'.I%'E "' +-J', 9;H5:Ir`rRF)initc\rSrSr%SrSrS\S'\SSSj5rS\S 'S r S \S 'S r S \S 'Sr S\S'\ STSj5r SUSjrSVSjr\\"S\S9SSSj55r\SSSj5r\SSSj5r\SSSj5r\SSSj5r\SSSj5r\SSSj5rSWSjr\ SXSj5r\ SYSj5rSZSjrS[SjrS\S jrS]S!jrS^S"jr S_S#jr!S`S$jr"S`S%jr#SaS&jr$SbS'jr%ScS(jr&SdS)jr'SeS*jr(\SSS+j5r)SfS,jr*SgS-jr+ShS.jr,SiS/jr-SjS0jr.SjS1jr/S\S2jr0SkS3jr1SlS4jr2SmS5jr3SnS6jr4SoS7jr5SpS8jr6SqS9jr7SrS:jr8SsS;jr9StS<jr:SuS=jr;SvS>jr<SwS?jr=SxS@jr>SySAjr?SzSBjr@S{SCjrASySDjrBS|SEjrCS}SFjrDS~SGjrESSHjrFSSIjrGSSJjrHSSKjrISSLjrJSSMjrKSSNjrLSSOjrMSSPjrNSSQjrOSRrPg )AbstractCapabilitya{Abstract base class for agent capabilities. A capability is a reusable, composable unit of agent behavior that can provide instructions, model settings, tools, and request/response hooks. Lifecycle: capabilities are passed to an [`Agent`][pydantic_ai.Agent] at construction time, where most `get_*` methods are called to collect static configuration (instructions, model settings, toolsets, native tools). When [`for_run`][pydantic_ai.capabilities.AbstractCapability.for_run] returns a replacement instance, that configuration is re-extracted from the replacement at run setup. The exception is [`get_wrapper_toolset`][pydantic_ai.capabilities.AbstractCapability.get_wrapper_toolset], which is always called per-run during toolset assembly. Then, on each model request during a run, the [`before_model_request`][pydantic_ai.capabilities.AbstractCapability.before_model_request] and [`after_model_request`][pydantic_ai.capabilities.AbstractCapability.after_model_request] hooks are called to allow dynamic adjustments. See the [capabilities documentation](../capabilities/overview.md) for built-in capabilities. [`get_serialization_name`][pydantic_ai.capabilities.AbstractCapability.get_serialization_name] and [`from_spec`][pydantic_ai.capabilities.AbstractCapability.from_spec] support YAML/JSON specs (via `Agent.from_spec`); they have sensible defaults and typically don't need to be overridden. FzClassVar[bool]_safe_at_runtimeboolcg)zWhether this app-facing capability may emit `CustomEvent`s while dispatching callbacks. A property rather than a flag so wrappers can derive it from the capability they wrap. FrUselfs ra_emits_app_events$AbstractCapability._emits_app_eventss r`r _N str | Noneid description defer_loadingc[U5$)aCombine capabilities that resolved to the same `id` into the one the run will use. Two capabilities under one `id` name the same thing, so exactly one of them can be what that `id` refers to. The default merges them field by field: a value only one of them states is kept, and a value both state takes the later one. That default needs no thought from most capabilities, because it follows from the `id`. Declaring a default `id` *is* the statement that an agent has one of these, so a repeat is one configuration stated twice and merging is what it meant. A capability that can legitimately appear several times declares no default `id` instead -- and then this is never reached, because the run tells anonymous capabilities apart itself, and an `id` the *user* passed to such a capability is a name they chose, so passing it twice is reported as a collision rather than merged. Override it when composing takes more than merging fields: `NativeOrLocalTool` rebuilds its native tool from the merged configuration, because that tool, not the capability, is what reaches the provider. Only reached *within* one layer: a capability supplied for a run overrides its agent-level namesake outright rather than composing with it. Args: capabilities: The two or more capabilities sharing an `id`, in application order. All are instances of `cls`; a shared `id` across *different* classes is always rejected, since no one class can say how it composes. Returns: The single capability the `id` refers to for this run. r-)cls capabilitiess racombineAbstractCapability.combines>'|44r`cU"U5 g)zRun a visitor function on all leaf capabilities in this tree. For a single capability, calls the visitor on itself. Overridden by [`CombinedCapability`][pydantic_ai.capabilities.CombinedCapability] to recursively visit all child capabilities. NrUrjvisitors raapplyAbstractCapability.applys   r`cU"U5$)aRun a visitor function on the same capabilities as `apply`, and replace them in this tree with its result. Analogous to [`AbstractToolset.visit_and_replace`][pydantic_ai.toolsets.AbstractToolset.visit_and_replace], except that returning `None` removes the visited capability instead of replacing it. Rewrites in place: containers and wrappers rebuild only the branches that changed, so what survives keeps its position in the hierarchy and a wrapper goes on wrapping whatever is left of its subtree. Rebuilding a tree from the flat list `apply` produces does neither: it loses the nesting, and re-adds a container's children next to the wrapper that already contributes them. Returns `self` when nothing changed, and `None` when the visitor removed everything. For a single capability, returns the visitor's result for itself. Overridden by [`CombinedCapability`][pydantic_ai.capabilities.CombinedCapability] and [`WrapperCapability`][pydantic_ai.capabilities.WrapperCapability] to rebuild their children; a custom capability that overrides `apply` because it holds children of its own should override this alongside it, or those children are invisible to callers rewriting the tree. rUrxs ravisit_and_replace$AbstractCapability.visit_and_replace's.t}r`z`has_wrap_node_run` is deprecated: `wrap_node_run` now runs under every way of driving a run, so there is nothing left to test for.)categorycUR$)zWhether this capability (or any sub-capability) overrides wrap_node_run. Deprecated: `wrap_node_run` runs under every way of driving a run, so there is nothing left to test for. )_has_wrap_node_runris rahas_wrap_node_run$AbstractCapability.has_wrap_node_run@s&&&r`cL[U5R[RL$N)type wrap_node_runrdris rar%AbstractCapability._has_wrap_node_runMsDz''/A/O/OOOr`cL[U5R[RL$r)ron_node_run_errorrdris ra_has_on_node_run_error)AbstractCapability._has_on_node_run_errorQsDz++3E3W3WWWr`cL[U5R[RL$r)rwrap_model_requestrdris ra_has_wrap_model_request*AbstractCapability._has_wrap_model_requestUsDz,,4F4Y4YYYr`cL[U5R[RL$r)ron_model_request_errorrdris ra_has_on_model_request_error.AbstractCapability._has_on_model_request_errorYsDz008J8a8aaar`cL[U5R[RL$)zPWhether this capability (or any sub-capability) overrides wrap_run_event_stream.)rwrap_run_event_streamrdris rahas_wrap_run_event_stream,AbstractCapability.has_wrap_run_event_stream]s Dz//7I7_7___r`c[U5R[RL=(d [[ [U555$)zNWhether this capability handles run events dynamically or with marked methods.)ron_eventrdrgr/ris ra has_on_eventAbstractCapability.has_on_eventbs7Dz""*<*E*EEsNfgklpgqNrIssr`c[U5R[RL=(d [[U5U5$)a&Whether [`on_event`][pydantic_ai.capabilities.AbstractCapability.on_event] would reach a listener for `event`. Dispatch asks this before descending, so a capability that listens to a few event classes isn't woken for every event in the run. The default reports `True` for any event a [`@on_event`][pydantic_ai.capabilities.on_event]-marked method accepts, and for every event when `on_event` is overridden directly, since what an override dispatches to isn't knowable here. Override this alongside `on_event` when you can report something narrower. )rrrdr0)rjevents ra listens_toAbstractCapability.listens_togs5Dz""*<*E*EEmIZ[_`d[eglImmr`cUR$)zReturn the name used for spec serialization (CamelCase class name by default). Return None to opt out of spec-based construction. rY)rss raget_serialization_name)AbstractCapability.get_serialization_namers ||r`cU"U0UD6$)zuCreate from spec arguments. Default: `cls(*args, **kwargs)`. Override when `__init__` takes non-serializable types. rU)rsargskwargss ra from_specAbstractCapability.from_speczs D#F##r`cg)aReturn ordering constraints for this capability, or `None` for default behavior. Override to declare a fixed position (`'outermost'` / `'innermost'`), relative ordering (`wraps` / `wrapped_by` other capability types or instances), or dependency requirements (`requires`). [`CombinedCapability`][pydantic_ai.capabilities.CombinedCapability] uses these to topologically sort its children at construction time. NrUris ra get_orderingAbstractCapability.get_orderingsr`cU$)aReturn the capability instance to use with an agent. Called after the agent's own configuration is available and before capability contributions are extracted. Constructor capabilities are bound once during agent construction; static run capabilities are bound once per run. Override this to inspect the agent and return an agent-bound copy. The default returns `self`. A [`CapabilityFunc`][pydantic_ai.capabilities.CapabilityFunc] result is also bound before its own [`for_run`][pydantic_ai.capabilities.AbstractCapability.for_run] hook. A specialized run-bound value returned by an ordinary capability's `for_run()` is not bound again. Capabilities in the `innermost` ordering tier (see [`get_ordering`][pydantic_ai.capabilities.AbstractCapability.get_ordering]), i.e. durability capabilities, bind in a second phase, after the other capabilities' contributed toolsets have been extracted, so `agent.toolsets` is complete when their `for_agent` wraps it. The flip side is that `innermost` capabilities can't contribute toolsets of their own. rU)rjagents ra for_agentAbstractCapability.for_agents $ r`cg)aInstall private per-run state before any capability lifecycle hook runs. Durable dispatch tables must be available before every capability's `before_run`, because one capability may call another capability's durable operation from its hook. This setup therefore cannot be implemented as a `before_run` hook itself. It stays private pending the capability surface decisions tracked in #5477. NrUrjctxs ra_prepare_run_context'AbstractCapability._prepare_run_contextr`c# U$7f)aReturn the capability instance to use for this agent run. Called once per run, before `get_*()` re-extraction and before any hooks fire. Override to return a fresh instance for per-run state isolation. Under durable execution, worker processes re-derive this instance from the deserialized run context, so all per-run state must be derivable from `ctx`. Default: return `self` (shared across runs). rUrs rafor_runAbstractCapability.for_runs  cg)aValidate capabilities contributed specifically for this run. Deliberately private: whether this becomes part of the public runtime extension surface (and in what shape) will be decided as part of [#5477](https://github.com/pydantic/pydantic-ai/issues/5477). NrU)rjrrts ra_validate_runtime_capabilities1AbstractCapability._validate_runtime_capabilitiesrr`cg)uReturn instructions to include in the system prompt, or None. Return static instruction text, a dynamic instruction callable, or a sequence containing either. For dynamic per-request behavior, return a callable that receives [`RunContext`][pydantic_ai.tools.RunContext] or a `TemplateStr` — not a dynamic string. When [`defer_loading`][pydantic_ai.capabilities.AbstractCapability.defer_loading] is True, these instructions are resolved only after the model calls the `load_capability` tool for this capability. NrUris raget_instructions#AbstractCapability.get_instructionssr`c"UR5$)uReturn this capability's instructions, each paired with the id to address it by. The agent uses this instead of [`get_instructions`][pydantic_ai.capabilities.AbstractCapability.get_instructions] so a capability with an [`id`][pydantic_ai.capabilities.AbstractCapability.id] gets its own [`InstructionPart`][pydantic_ai.messages.InstructionPart]s rather than being folded into the agent's — computed contributions included, since addressing the capability means addressing everything it tells the model. Container capabilities override this to keep each leaf's contribution attributed; every other capability inherits this default, so overriding `get_instructions` is enough. )_collect_own_instructionsris ra_collect_instructions(AbstractCapability._collect_instructionss--//r`c|[UR55Vs/sHoRU5PM sn$s snf)zJCollect this capability's public contribution without container recursion.)rr_attribute_instructionrj instructions rar,AbstractCapability._collect_own_instructionss@I__c_t_t_vHw Hw ' ' 4Hw   s9cd[XRb[UR55$S5$)z4Attribute one instruction recipe to this capability.N)rror rs rar)AbstractCapability._attribute_instructions+";X_X_Xk0KDGG0Tvvquvvr`cB[SU55nUVs0sH6oC[UR5S:XdM [UR5U_M8 nnUVs/sH3nUR[U55=ncUR U5OUPM5 sn$s snfs snf)aAttribute what an overriding container returned, keeping what it merely passed along. Public container overrides return bare recipes, so identity is the only information that connects a relayed recipe to the child that authored it. An object appearing under more than one child is deliberately not connected: equal interned strings can be the same object, and leaving their keys unidentified is safer than assigning either child at random. c3L# UHn[UR5v M g7fr)ror).0sourceds ra GAbstractCapability._attribute_container_instructions..sMW'b!4!455Ws"$r,)rrorgetr)rjauthoredrelayed occurrencesrrelayed_by_identityrs ra!_attribute_container_instructions4AbstractCapability._attribute_container_instructionssMWMM sr`c/$)z/Return native tools to register with the agent.rUris raget_native_tools#AbstractCapability.get_native_toolsBs r`cg)aWrap the agent's assembled toolset, or return None to leave it unchanged. Called per-run with the combined non-output toolset (after the [`prepare_tools`][pydantic_ai.capabilities.AbstractCapability.prepare_tools] hook has already wrapped it). Output tools are added separately and are not included. Unlike value-contribution methods such as [`get_instructions`][pydantic_ai.capabilities.AbstractCapability.get_instructions], this receives the already assembled toolset and is called each run (after [`for_run`][pydantic_ai.capabilities.AbstractCapability.for_run]). When multiple capabilities provide wrappers, they follow middleware semantics: the first capability in the list wraps outermost (matching `wrap_*` hooks). Use this to apply cross-cutting toolset wrappers like [`PreparedToolset`][pydantic_ai.toolsets.PreparedToolset], [`FilteredToolset`][pydantic_ai.toolsets.FilteredToolset], or custom [`WrapperToolset`][pydantic_ai.toolsets.WrapperToolset] subclasses. NrU)rjtoolsets raget_wrapper_toolset&AbstractCapability.get_wrapper_toolsetFs&r`c# U$7f)uaFilter or modify function tool definitions for this step. Receives **function** tools only. For [output tools][pydantic_ai.output.ToolOutput], override [`prepare_output_tools`][pydantic_ai.capabilities.AbstractCapability.prepare_output_tools] — it runs separately, with `ctx.retry`/`ctx.max_retries` reflecting the **output** retry budget instead of the function-tool budget. Return a filtered or modified list. The result flows into both the model's request parameters and `ToolManager.tools`, so filtering also blocks tool execution. On a deferred capability this runs only once the capability is loaded, and then receives every function tool, as an always-on capability does. There is nothing to govern before that: an unloaded capability's tools are neither advertised to the model nor callable, so no filtering here could change what the model can reach. rUrjr tool_defss ra prepare_tools AbstractCapability.prepare_tools]s *rc# U$7f)aFilter or modify output tool definitions for this step. Receives only [output tools][pydantic_ai.output.ToolOutput]. `ctx.retry` and `ctx.max_retries` reflect the **output** retry budget (agent-level `max_output_retries`), matching the output hook lifecycle. Return a filtered or modified list. The result flows into both the model's request parameters and `ToolManager.tools`, so filtering also blocks tool execution. rUrs raprepare_output_tools'AbstractCapability.prepare_output_toolsts rc # g7f)zCalled before the agent run starts. Observe-only; use `wrap_run` for modification. A realtime session is a run. ContextVars set here are ambient in its instruction resolution, pump and tool tasks, and the caller's `async with` block. NrUrs ra before_runAbstractCapability.before_runsrc# U$7f)uCalled after the agent run produces a result. Can modify the result. Not called when the run ends without a result (e.g. a cancellation that nothing recovered from). It IS called when a result was produced while a cancellation was pending or absorbed upstream — but before the backstop's cancellation re-check, so the cancellation still propagates after this hook returns and the run still ends cancelled. Put cancellation-safe cleanup in [`wrap_run`][pydantic_ai.capabilities.AbstractCapability.wrap_run] (a `try`/`finally` around `handler()`), which does observe the `CancelledError`. For a realtime session, the result is produced when the session closes; a transformed result becomes `session.result` before the caller leaves the `async with` boundary. rU)rjrresults ra after_runAbstractCapability.after_run $ rc,# U"5IShvN $N7f)a=Wraps the entire agent run. `handler()` executes the run. If `handler()` raises and this method catches the exception and returns a result instead, the error is suppressed and the recovery result is used. If this method does not call `handler()` (short-circuit), the run is skipped and the returned result is used directly. Note: if the caller cancels the run (e.g. by breaking out of an `iter()` loop), this method receives an `asyncio.CancelledError`. Implementations that hold resources should handle cleanup accordingly. Cancellation is terminal: the hook may observe it and clean up, but cannot recover the run to success. A realtime session is a run: `handler()` resolves when the session closes. ContextVars set before calling it are ambient in instruction resolution, pumps, tool tasks, and the caller's block. Downward ContextVar propagation is one-way; keep bidirectional per-run state on the `for_run` copy's instance attributes. Suppression and result transformation apply at the session's `async with` boundary, after the caller may have observed events in real time. NrU)rjrhandlers rawrap_runAbstractCapability.wrap_runs4Ys c# Ue7f)aaCalled when the agent run fails with an exception. This is the error counterpart to [`after_run`][pydantic_ai.capabilities.AbstractCapability.after_run]: while `after_run` is called on success, `on_run_error` is called on failure (after [`wrap_run`][pydantic_ai.capabilities.AbstractCapability.wrap_run] has had its chance to recover). **Raise** the original `error` (or a different exception) to propagate it. **Return** an [`AgentRunResult`][pydantic_ai.run.AgentRunResult] to suppress the error and recover the run. Cancellation is terminal: the hook may observe it and clean up, but cannot recover the run to success. Not called for `GeneratorExit` or `KeyboardInterrupt`. For a realtime session, returning a recovery result sets `session.result` and suppresses the error at the caller's `async with` boundary, after events may already have been observed. rU)rjrerrors ra on_run_errorAbstractCapability.on_run_errors 4 rc# U$7f)zHCalled before each graph node executes. Can observe or replace the node.rU)rjrnodes rabefore_node_run"AbstractCapability.before_node_runs  rc# U$7f)uCalled after each graph node succeeds. Can modify the result (next node or `End`). Not called for a node interrupted by cancellation — including a cancellation the node itself absorbed and completed through, which the framework re-asserts at the node boundary: cancellation skips downstream hooks. Put cancellation-safe cleanup in [`wrap_node_run`][pydantic_ai.capabilities.AbstractCapability.wrap_node_run] (a `try`/`finally` around `handler()`), which does observe the `CancelledError`. (A hook that catches the `CancelledError` *and* calls `Task.uncancel()` takes over the cancellation bookkeeping for that boundary, so this hook does fire for that node — the run itself still ends cancelled at the next boundary.) rU)rjrr rs raafter_node_run!AbstractCapability.after_node_runrrc.# U"U5IShvN $N7f)uwWraps execution of each agent graph node (run step). Called for every node in the agent graph (`UserPromptNode`, `ModelRequestNode`, `CallToolsNode`). `handler(node)` executes the node and returns the next node (or `End`). Override to inspect or modify nodes before execution, inspect or modify the returned next node, call `handler` multiple times (retry), or return a different node to redirect graph progression. Note: this hook fires however the run is driven -- [`agent.run()`][pydantic_ai.agent.AbstractAgent.run], [`agent.run_stream()`][pydantic_ai.agent.AbstractAgent.run_stream], an [`agent.iter()`][pydantic_ai.agent.Agent.iter] run advanced with [`agent_run.next()`][pydantic_ai.run.AgentRun.next], and a bare `async for node in agent_run:` loop, which advances through `next()` too. The one exception is the final [`ModelRequestNode`][pydantic_ai.agent.ModelRequestNode] under `run_stream()`, which hands back the result mid-stream and so only fires `before_node_run`. When using `agent.run()` with `event_stream_handler`, the handler wraps both streaming and graph advancement (i.e. the model call happens inside the wrapper). When using `agent.run_stream()`, the handler wraps only graph advancement — streaming happens before the wrapper because `run_stream()` must yield the stream to the caller while the stream context is still open, which cannot happen from inside a callback. A cancelled run delivers `asyncio.CancelledError` through `handler()`. Cancellation is terminal: the hook may observe it and clean up, but cannot recover the run to success — even a returned `End` result is discarded once a cancellation is pending. NrU)rjrr rs rar AbstractCapability.wrap_node_runsFT]""" c# Ue7f)aCalled when a graph node fails with an exception. This is the error counterpart to [`after_node_run`][pydantic_ai.capabilities.AbstractCapability.after_node_run]. **Raise** the original `error` (or a different exception) to propagate it. **Return** a next node or `End` to recover and continue the graph. Useful for recovering from [`UnexpectedModelBehavior`][pydantic_ai.exceptions.UnexpectedModelBehavior] by redirecting to a different node (e.g. retry with different model settings). rU)rjrr r s rar$AbstractCapability.on_node_run_error  & rc# [[U55HYnUR(a[X#R5(dM0UR U[U55"X5IShvN M[ gN 7f)asReact to every event in the run's event stream. This includes model response stream events, tool events, deferred and enqueued-message events, [`CustomEvent`][pydantic_ai.messages.CustomEvent]s, and [`CapabilityEvent`][pydantic_ai.messages.CapabilityEvent]s. The default implementation dispatches to methods marked with [`on_event`][pydantic_ai.capabilities.on_event], in definition order. Override this method for fully dynamic handling. Call `super().on_event(...)` to retain marked method dispatch. A capability receives events it emits itself. Events emitted by a listener enter the stream after the event being handled. N)r/r event_types isinstance__get__)rjrrmethods rarAbstractCapability.on_event7sS/tDz:F%%E;M;M)N)NnnT4:6sBBB;BsAA7$A7+A5, A7c# UShvN nU7v MN [R"U5IShvN g![R"U5IShvN f=f7f)uWrap a run or realtime session's consumer-facing event stream. For classic runs, the wrapper is applied where each node's stream is produced, so it fires however the run is driven — including under [`agent.iter()`][pydantic_ai.agent.Agent.iter] and when the caller streams a node itself with `node.stream()`. For realtime sessions, it wraps the `async for event in session` view. A wrapper must yield events appropriate for the stream it wraps. Transformations affect only what the stream consumer sees. They never change realtime session history, tool execution, or the classic run's accumulated response and output. Note: when this method is overridden (or [`Hooks.on.event`][pydantic_ai.capabilities.hooks.Hooks.on] / [`Hooks.on.run_event_stream`][pydantic_ai.capabilities.hooks.Hooks.on] are registered), `agent.run()` and [`AgentRun.next()`][pydantic_ai.run.AgentRun.next] automatically enable streaming mode so this hook fires even without an explicit `event_stream_handler`. N)raclose_if_supported)rjrstreamrs rar(AbstractCapability.wrap_run_event_streamGsJ, 5% e  v,,V4 4 4&,,V4 4 4sFA999A5AAAAAc# U$7f)a Called before each model request. Can modify messages, settings, and parameters. [`model_request_parameters.instruction_parts`][pydantic_ai.models.ModelRequestParameters.instruction_parts] is the source of truth for the instructions: rewriting them here changes what the model receives, and the request recorded in message history is re-rendered from them afterwards. Assigning to a [`ModelRequest.instructions`][pydantic_ai.messages.ModelRequest] in `request_context.messages` is not propagated the other way, so it does not reach the model. rU)rjrrequest_contexts rabefore_model_request'AbstractCapability.before_model_requestes rc# U$7f)afCalled after each model response. Can modify the response before further processing. Raise [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] to reject the response and ask the model to try again. The original response is still appended to message history so the model can see what it said. Retries count against the output side of the agent's retry budget. rU)rjrr$responses raafter_model_request&AbstractCapability.after_model_requestts rc.# U"U5IShvN $N7f)a;Wraps the model request. handler() calls the model. Raise [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] to skip `on_model_request_error` and directly retry the model request with a retry prompt. If the handler was called, the model response is preserved in history for context (same as `after_model_request`). NrU)rjrr$rs rar%AbstractCapability.wrap_model_requests_----rc# Ue7f)aCalled when a model request fails with an exception. This is the error counterpart to [`after_model_request`][pydantic_ai.capabilities.AbstractCapability.after_model_request]. **Raise** the original `error` (or a different exception) to propagate it. **Return** a [`ModelResponse`][pydantic_ai.messages.ModelResponse] to suppress the error and use the response as if the model call succeeded. **Raise** [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] to retry the model request with a retry prompt instead of recovering or propagating. Not called for [`SkipModelRequest`][pydantic_ai.exceptions.SkipModelRequest] or [`ModelRetry`][pydantic_ai.exceptions.ModelRetry]. rU)rjrr$r s rar)AbstractCapability.on_model_request_errors * rc# U$7f)aXModify raw args before validation. Raise [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] to skip validation and ask the model to redo the tool call. A tool call can only be deferred once its arguments have been validated, so raising [`CallDeferred`][pydantic_ai.exceptions.CallDeferred] or [`ApprovalRequired`][pydantic_ai.exceptions.ApprovalRequired] here is a `UserError`. Defer from [`after_tool_validate`][pydantic_ai.capabilities.AbstractCapability.after_tool_validate], a tool's `args_validator`, or [`before_tool_execute`][pydantic_ai.capabilities.AbstractCapability.before_tool_execute]. rUrjrcalltool_defrs rabefore_tool_validate'AbstractCapability.before_tool_validates ( rc# U$7f)u>Modify validated args. Called only on successful validation. Raise [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] to reject the validated args and ask the model to redo the tool call. The arguments are valid by this point, so raising [`CallDeferred`][pydantic_ai.exceptions.CallDeferred] or [`ApprovalRequired`][pydantic_ai.exceptions.ApprovalRequired] here defers the call — the tool isn't executed, and the deferral joins the run's [`DeferredToolRequests`][pydantic_ai.tools.DeferredToolRequests] with the validated arguments. This hook also runs when the tool's `args_validator` (or `wrap_tool_validate`) already deferred the call, so it stays a reliable gate on validated arguments: rejecting here wins over that deferral, deferring here replaces it, and the args returned here are the ones the deferred call carries. rUr0s raafter_tool_validate&AbstractCapability.after_tool_validates 0 rc.# U"U5IShvN $N7f)aGWraps tool argument validation. handler() runs the validation. Deferring with [`CallDeferred`][pydantic_ai.exceptions.CallDeferred] or [`ApprovalRequired`][pydantic_ai.exceptions.ApprovalRequired] is allowed *after* `handler()` has returned, when the arguments are known to be valid; raising one before that is a `UserError`. NrUrjrr1r2rrs rawrap_tool_validate%AbstractCapability.wrap_tool_validate T]"""rc# Ue7f)uCalled when tool argument validation fails. This is the error counterpart to [`after_tool_validate`][pydantic_ai.capabilities.AbstractCapability.after_tool_validate]. Fires for `ValidationError` (schema mismatch) and [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] (custom validator rejection). **Raise** the original `error` (or a different exception) to propagate it. **Return** validated args to suppress the error and continue as if validation passed. Not called for [`SkipToolValidation`][pydantic_ai.exceptions.SkipToolValidation], or when a tool's `args_validator` raises [`CallDeferred`][pydantic_ai.exceptions.CallDeferred] or [`ApprovalRequired`][pydantic_ai.exceptions.ApprovalRequired] — those are control flow, not errors, and the call is deferred instead of executed. Raising a deferral *from this hook* is a `UserError`: it only runs because validation failed, so there are no valid arguments to show whoever would resolve the deferral. rUrjrr1r2rr s raon_tool_validate_error)AbstractCapability.on_tool_validate_errors 6 rc# U$7f)aModify validated args before execution. Raise [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] to skip execution and ask the model to redo the tool call. This is the hook to defer from: raising [`ApprovalRequired`][pydantic_ai.exceptions.ApprovalRequired] or [`CallDeferred`][pydantic_ai.exceptions.CallDeferred] here defers the call *before* the tool function runs, so nothing happens until it's resolved. rUr0s rabefore_tool_execute&AbstractCapability.before_tool_execute s $ rc# U$7f)aModify result after execution. Raise [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] to reject the tool result and ask the model to redo the tool call. Deferring from here is accepted but rarely what you want: the tool function has already run, so its side effects happened and `result` is discarded. Defer from [`before_tool_execute`][pydantic_ai.capabilities.AbstractCapability.before_tool_execute] instead. rU)rjrr1r2rrs raafter_tool_execute%AbstractCapability.after_tool_execute s & rc.# U"U5IShvN $N7f)a3Wraps tool execution. handler() runs the tool. Defer before calling `handler()`: a deferral raised after it has returned is accepted, but the tool function already ran and its result is discarded. Defer from [`before_tool_execute`][pydantic_ai.capabilities.AbstractCapability.before_tool_execute] instead. NrUr9s rawrap_tool_execute$AbstractCapability.wrap_tool_execute5r<rc# Ue7f)a4Called when tool execution fails with an exception. This is the error counterpart to [`after_tool_execute`][pydantic_ai.capabilities.AbstractCapability.after_tool_execute]. **Raise** the original `error` (or a different exception) to propagate it. **Return** any value to suppress the error and use it as the tool result. **Raise** [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] to ask the model to redo the tool call instead of recovering or propagating. Not called for control flow exceptions ([`SkipToolExecution`][pydantic_ai.exceptions.SkipToolExecution], [`CallDeferred`][pydantic_ai.exceptions.CallDeferred], [`ApprovalRequired`][pydantic_ai.exceptions.ApprovalRequired]), retry signals ([`ToolRetryError`][pydantic_ai.exceptions.ToolRetryError] from [`ModelRetry`][pydantic_ai.exceptions.ModelRetry]), or failure signals ([`ToolFailedError`][pydantic_ai.exceptions.ToolFailedError] from [`ToolFailed`][pydantic_ai.exceptions.ToolFailed]). Use [`wrap_tool_execute`][pydantic_ai.capabilities.AbstractCapability.wrap_tool_execute] to intercept retries or failures. rUr>s raon_tool_execute_error(AbstractCapability.on_tool_execute_errorGs < rc# U$7f)aModify raw model output before validation/parsing. The primary hook for pre-parse repair and normalization of model output. Fires only for structured output that requires parsing: prompted, native, tool, and union output. Does **not** fire for plain text or image output. For structured text output, `output` is the raw text string from the model. For tool output, `output` is the raw tool arguments (string or dict). Raise [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] to skip validation and ask the model to try again with a custom message. During streaming, this hook fires on every partial validation attempt as well as the final result. Check `ctx.partial_output` to distinguish and avoid expensive work on partial results. rUrjroutput_contextoutputs rabefore_output_validate)AbstractCapability.before_output_validateis . rc# U$7f)uModify validated output after successful parsing. Called only on success. `output` is the **semantic value** the model was asked to produce — e.g., a `MyModel` instance for `output_type=MyModel`, or `42` for `output_type=int`, or the input to a single-arg output function. For multi-arg output functions, this is the `dict` of arguments (the genuine multi-value input). Note: this differs from *tool* hooks (`after_tool_validate`), which always see `dict[str, Any]` — tool args follow the schema contract. Output hooks see the semantic output value, regardless of how it's internally represented during validation. Raise [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] to reject the validated output and ask the model to try again. rUrNs raafter_output_validate(AbstractCapability.after_output_validates , rc.# U"U5IShvN $N7f)aFWraps output validation. handler(output) performs the validation. [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] from within the handler goes to [`on_output_validate_error`][pydantic_ai.capabilities.AbstractCapability.on_output_validate_error]. `ModelRetry` raised directly (not from the handler) bypasses the error hook. NrUrjrrOrPrs rawrap_output_validate'AbstractCapability.wrap_output_validatesV_$$$rc# Ue7f)a1Called when output validation fails. This is the error counterpart to [`after_output_validate`][pydantic_ai.capabilities.AbstractCapability.after_output_validate]. **Raise** the original `error` (or a different exception) to propagate it. **Return** validated output to suppress the error and continue. rUrjrrOrPr s raon_output_validate_error+AbstractCapability.on_output_validate_errors  rc# U$7f)uModify validated output before processing (extraction, output function call). `output` is the **semantic value** — e.g., a `MyModel` instance or `42`, matching `after_output_validate`. For multi-arg output functions, it's the `dict` of args. See [`after_output_validate`][pydantic_ai.capabilities.AbstractCapability.after_output_validate] for a full explanation of the semantic-value contract. Raise [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] to skip processing and ask the model to try again. rUrNs rabefore_output_process(AbstractCapability.before_output_processs " rc# U$7f)zModify result after output processing. Raise [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] to reject the result and ask the model to try again. rUrNs raafter_output_process'AbstractCapability.after_output_processs  rc.# U"U5IShvN $N7f)aWraps output processing. handler(output) runs extraction + output function call. [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] bypasses [`on_output_process_error`][pydantic_ai.capabilities.AbstractCapability.on_output_process_error] (treated as control flow, not an error). During streaming, this fires only when partial validation succeeds, and on the final result. Check `ctx.partial_output` to skip expensive work on partial results. NrUrWs rawrap_output_process&AbstractCapability.wrap_output_processs"V_$$$rc# Ue7f)aCalled when output processing fails with an exception. This is the error counterpart to [`after_output_process`][pydantic_ai.capabilities.AbstractCapability.after_output_process]. **Raise** the original `error` (or a different exception) to propagate it. **Return** any value to suppress the error and use it as the output. Not called for retry signals ([`ToolRetryError`][pydantic_ai.exceptions.ToolRetryError] from [`ModelRetry`][pydantic_ai.exceptions.ModelRetry]). rUr[s raon_output_process_error*AbstractCapability.on_output_process_errorrrc # g7f)aHandle deferred tool calls (approval-required or externally-executed) inline during an agent run. Called by `ToolManager` when: - a tool raises [`ApprovalRequired`][pydantic_ai.exceptions.ApprovalRequired] or [`CallDeferred`][pydantic_ai.exceptions.CallDeferred] during execution, or - the model calls a tool registered with `requires_approval=True` (see [Human-in-the-Loop Tool Approval](../deferred-tools.md#human-in-the-loop-tool-approval)) or a tool backed by [external execution](../deferred-tools.md#external-tool-execution). Uses accumulation dispatch: each capability in the chain receives remaining unresolved requests and can resolve some or all of them. Results are merged and unresolved calls are passed to the next capability. **Return** a [`DeferredToolResults`][pydantic_ai.tools.DeferredToolResults] to resolve some or all calls. **Return** `None` to leave all calls unresolved. NrU)rjrrequestss rahandle_deferred_tool_calls-AbstractCapability.handle_deferred_tool_calls s 0rcSSKJn U"XS9$)zReturns a new capability that wraps this one and prefixes its tool names. Only this capability's tools are prefixed; other agent tools are unaffected. r,r4)wrappedprefix) prefix_toolsr5)rjrpr5s rarqAbstractCapability.prefix_tools%s .477r`rU)returnrg)rt(Sequence[AbstractCapability[AgentDepsT]]rsAbstractCapability[AgentDepsT])ryz0Callable[[AbstractCapability[AgentDepsT]], None]rsNone)ryzQCallable[[AbstractCapability[AgentDepsT]], AbstractCapability[AgentDepsT] | None]rs%AbstractCapability[AgentDepsT] | None)rrrsrg)rsrn)rrrrrszAbstractCapability[Any])rszCapabilityOrdering | None)rzAbstractAgent[AgentDepsT, Any]rsru)rRunContext[AgentDepsT]rsrv)rrxrsru)rrxrtrtrsrv)rsz$AgentInstructions[AgentDepsT] | None)rs$list[SourcedInstruction[AgentDepsT]])rzAgentInstruction[AgentDepsT]rszSourcedInstruction[AgentDepsT])rz&Sequence[AgentInstruction[AgentDepsT]]rz(Sequence[SourcedInstruction[AgentDepsT]]rsry)rsz(CapabilityDescription[AgentDepsT] | None)rsz%AgentModelSettings[AgentDepsT] | None)rszAgentModel[AgentDepsT] | None)rz"ModelResolutionContext[AgentDepsT]rzKnownModelName | strrsz Model | None)rszAgentToolset[AgentDepsT] | None)rsz%Sequence[AgentNativeTool[AgentDepsT]])rzAbstractToolset[AgentDepsT]rsz"AbstractToolset[AgentDepsT] | None)rrxrlist[ToolDefinition]rsrz)rrxrAgentRunResult[Any]rsr{)rrxrrArsr{)rrxr  BaseExceptionrsr{)rrxr AgentNode[AgentDepsT]rsr})rrxr r}rNodeResult[AgentDepsT]rsr~)rrxr r}rzWrapNodeRunHandler[AgentDepsT]rsr~)rrxr r}r  Exceptionrsr~)rrxrrrsrv)rrxr!AsyncIterable[AgentStreamEvent]rsr)rrxr$r8rsr8)rrxr$r8r(r!rsr!)rrxr$r8rrCrsr!)rrxr$r8r rrsr!) rrxr1r"r2r)rrGrsrG) rrxr1r"r2r)rrHrsrH) rrxr1r"r2r)rrGrrIrsrH) rrxr1r"r2r)rrGr ValidationError | ModelRetryrsrH) rrxr1r"r2r)rrHrrrsr) rrxr1r"r2r)rrHrrJrsr) rrxr1r"r2r)rrHr rrsr)rrxrOr;rPrKrsrK)rrxrOr;rPrrsr) rrxrOr;rPrKrrLrsr) rrxrOr;rPrKr rrsr) rrxrOr;rPrrrMrsr) rrxrOr;rPrr rrsr)rrxrkr%rszDeferredToolResults | None)rpstrrszPrefixTools[AgentDepsT])QrYrZr[r\r]rfr^propertyrkrorprq classmethodrurzr}rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrr%r)rrr3r6r:r?rBrErHrKrQrTrXr\r_rbrerhrlrqr_rUr`rardrds0(-n, JB #K"(M4 55@h .2 0- '  'PPXXZZbb``tt n$$ (   ) 9a    0 w 8 :  .  0  " VV  / '   . #(  . #(  $ #    #$   ( #   8 #   < #$    #$  '  (## ###$ ## 0 ## ##J #$    .C 5 #50 5 ) 5<  # -     # -      . # .- . ) .  . #-     2 #  !    , #  !    4# ## # ! #  #)# #$ #  !   , > #  !    ( #  !    *# ## # ! #  #(# #$ #  !    D #&     2 #&    0% #%& %  % + % %  #&    ,  ( #&    &  # &    % #%& %  % * % %& #&      . #'  $ 88r`rdc@/nURUR5 U$)zICollect the leaf capabilities in a capability tree, in application order.)rzappend) capabilityleavess raleaf_capabilitiesr/s35FV]]# Mr`cLSSKJn [X5(a UR$U/$)zOReturn the branches a surrounding combined capability retains after flattening.r,)CombinedCapability)combinedrrrt)rrs ra_combination_rootsr6s$,&0&P&P: " "bWaVbbr`T)frozenc>\rSrSr%S\S'S\S'S\S'S\S'Srg ) _CapabilityOccurrencei=rurintoccurrence_index layer_indexrTrUN)rYrZr[r\r^r_rUr`rarr=s..Mr`rc z^SSKJn 0nSn[U5HupV[R"[ [ U55Hqn0n[U5H2n UR[U 5/5RU5 US- nM4 UR[U5/5RXX45 Ms M 0n 0n [ U5HnU[U5RS5upX[U5Hn U RcMU R[U 5S5n U S-U [U 5'U[U 5RS5n[XXT5n U RU R/5RU 5 M M U R5VVs0sH"up[U5S:dMU[!USS9_M$ nnn0mUR5GHup[#SU55nUVs/sH!nUR$U:XdMUR&PM# nnUUSR$:gn[)5nUHnUR&nU(a[+UU5(anURUR,R:XaJUR,nU(a7[+UU5(a&URUR,R:XaMJUR/[1U55 M [3UU5 USn[U5S:ad[3UUVs1sHn[1U5iM sn5 [5[1U55(d[7[9U55eUR;U5nTR=UVs0sH3n[UR&5S/U [UR&5-_M5 sn5 USnUT[UR&5UR>'GM T(dU$S U4S jjnURAU5nUcS 5eU$s snnfs snfs snfs snf) aResolve capabilities sharing an `id` in a tree down to one each. Two capabilities under one `id` mean different things depending on where they came from, so the rule is different in each direction: * **Within a layer** they are one configuration stated twice, and [`combine`][pydantic_ai.capabilities.AbstractCapability.combine] decides what that means. `Agent(capabilities=[Coder(), Researcher()])` brings two `WebSearch` capabilities with different allow-lists, and the agent should be able to reach both sets of domains. * **Across layers** the later layer *overrides* the earlier one outright, and `combine` is not consulted at all. `agent.run(capabilities=[WebSearch(allowed_domains=[...])])` states what this run may reach; merging it into the agent's list would widen the very restriction it was passed to impose. A run-level capability replaces its agent-level namesake, whole. `Agent.__init__` also runs this over the capabilities the agent was constructed with -- one layer, so within-layer rules -- because it goes on to bind them and read what they contribute long before a run exists, and two that will merge into one must not be read as two. Keeping both is not an option: `_build_run_capabilities` maps the id to exactly one of them, so the other would go on contributing tools and instructions while nothing could name it -- `resolve_capability_id` wouldn't find it, and it would be missing from `RunContext.active_capability_ids`. Rewrites the tree in place with [`visit_and_replace`][pydantic_ai.capabilities.AbstractCapability.visit_and_replace] rather than rebuilding it from the flat leaf list, which would drop the nesting and re-add a container's children beside the wrapper that already contributes them. Capabilities with `id=None` are left alone: the run tells those apart itself. `layers` is the application layers in order, each holding the capabilities supplied to it. The composed tree cannot answer either question: `CombinedCapability` sorts its leaves into ordering tiers, so a capability supplied later but positioned `'outermost'` moves ahead of one supplied earlier, and reading "last" off the tree would turn a run-level override into the agent-level capability winning. r,)WrapperCapabilityrNcUR$r)rT) occurrences ra1_combine_duplicate_capabilities..s ATATr`)keyc38# UHoRv M g7fr)r)r duplicates rar2_combine_duplicate_capabilities..sK 9.. cl>TR[U55nU(dU$URS5$)Nr)rropop)cap decisions replacementss rareplace_occurrence;_combine_duplicate_capabilities..replace_occurrences. $$RW- J}}Qr`z6combining duplicate capabilities cannot empty the tree)rrursrw)!wrapperr enumerater from_iterablemaprr setdefaultrorrrritemslensortedmaxrrsetrroaddr_reject_class_crossing_id_declares_default_idr_repeated_id_messageruupdaterr})rlayersrroot_locationsrTrlayerrootleaf_positionsleafoccurrence_countsby_idrr capability_id duplicatesduplicate_groups last_layerr surviving spans_layersidentity_typesidentitycombined_duplicatesurvivorlast_duplicaterrrs @ra_combine_duplicate_capabilitiesrEsP+ IKNH'/ '',>(FGD35N)$/))"T(B7>>xHA 0  % %bh 3 : :K;X Y H0)+@BE":.&4RX&>&B&B1&E# %d+Dww"#4#8#8D1#E .>.B!"T(+)"T(377:24;a   "-44Z@ ,/*/)6 %M z?Q  V vj.TUU)6LNL%5%;%;%=! K KK ;Em:iI^I^blIl)Y)): m "Z]%>%>> DGE#I ++H:h8I#J#Jx{{^f^n^n^q^qOq#++:h8I#J#Jx{{^f^n^n^q^qOq   tH~ . $ "-@&r] y>A  %mU^5_U^d8nU^5_ `'-?(@AA 4] CDD!3!;!;I!F mw xmw`iR $$ %v0A"YEYEYBZ0['[ [mw x $BWi R1123N4S4ST=&>@  ++,>?H  Y!YY  Ow(n"6` ys$"P(;P(<P.P.!P3 :P8 cSU<S3$)zWhy an `id` the user chose for two capabilities cannot resolve to one. Shared by `Agent(...)` validation and the run's own resolution so the two report it the same way, whichever notices first. Capability id zj is used by multiple capabilities. Ids identify one capability within a run, so give each a distinct `id`.rU)rs rarrs )*R Rr`c [USS5SL$)aWhether the class itself names the `id` its instances carry, rather than the user. A default `id` is a class saying "an agent has one of me", which is what makes a repeat something to combine rather than a collision. Without one, an `id` exists only because the user passed it, and two they passed the same are two capabilities they meant to tell apart. Read off the class attribute, so declaring a default means writing one -- `id: str | None = 'web_search'` in the class body. A capability that only passes `id=` up from inside its own `__init__` has not declared anything a reader or this check can see, and is treated as anonymous; two of it collide, loudly, and the fix is to hoist the default into the class body. roN)getattr)capability_types rarrs ?D$ /t ;;r`c[U5S:a4SR[SU555n[SU<SUS35eg)aReject an `id` two different capability classes both claim. No class can be asked to combine another's instances, so a shared id across classes is never resolvable however they were ordered. Shared with `Agent(...)` validation so the two report the same thing: construction sees only the capabilities it was handed, and this pass sees the tree a run resolves to, but neither one is a case the other should describe differently. r,z, c38# UHoRv M g7frr)rrss rar,_reject_class_crossing_id..s ?#rrz- is used by capabilities of different types (zJ). Ids identify one capability within a run, so give each a distinct `id`.N)rjoinrr)rtypesnamess rarrsX 5zA~ & ? ??@]--Z[`ZabV V  r`N)rrursz$list[AbstractCapability[AgentDepsT]])rrursrt)rrurz2Sequence[Sequence[AbstractCapability[AgentDepsT]]]rsru)rrrsr)rztype[AbstractCapability[Any]]rsrg)rrrz)Collection[type[AbstractCapability[Any]]]rsrv)p __future__rabcr collectionsrcollections.abcrrrr r dataclassesr r itertoolsr typingrrrrrrpydanticrtyping_extensionsr pydantic_airpydantic_ai._instructionsrrrrrpydantic_ai._warningsrpydantic_ai.exceptionsrrpydantic_ai.messagesrr r!r"pydantic_ai.toolsr#r$r%r&r'r(r)pydantic_ai.toolsetsr*r+_merger. _on_eventr/r0r1pydantic_ai.agent.abstractr2r3%pydantic_ai.capabilities.prefix_toolsr5pydantic_ai.modelsr6r7r8r9r:pydantic_ai.outputr;pydantic_ai.resultr<pydantic_ai.runr=pydantic_graphr>r?r^r@rArBrCrDrErFrdictrGrHrIrJrKrLrMCapabilityPositionrPCapabilityDescriptionrRrdrrrrrrrrUr`rars"TT*LL$(?8 ?+B(LA1.." A 9@aY IY`J JZ!bIbd%``n: :=v yv.D IDNtCH~- Y-9#CH~9-.%-{mYGX=Y.Y%ZZn$,.?-@)C.-P$Q QlT#s(^+ 9+9'/ Ys^0K'L9L,&.uin/D&E)E+56U yTE.z:: )J)J )JX {8gj1{8{8|#c $GJ/. >$D  <  r`