"jD*SSKJr SSKJrJrJr SSKJrJrJ r SSK J r J r SSK Jr SSKJrJrJrJrJr SSKJrJr SSKJrJr SS KJrJr SS KJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r( SS K)J*r*J+r+J,r, SS K-J.r. SS K/J0r0 \"SS9"SS\\55r1g)) annotations) AwaitableCallableSequence)KW_ONLY dataclassfield)Anyoverload)GenerateJsonSchema)AgentInstructionsSourcedInstructionnormalize_instructionsvalidate_instruction_id_segmentvalidate_instruction_name) AgentDepsT RunContext)AbstractCapabilityCapabilityDescription)CapabilityInstructionSource InstructionId) ArgsValidatorFuncDocstringFormatGenerateToolJsonSchemaSystemPromptFuncToolToolFuncContextToolFuncEither ToolFuncPlain ToolParamsToolPrepareFunc)AbstractToolset AgentToolsetFunctionToolset)DynamicToolset)CombinedToolsetF)initc^\rSrSr%SrS\S'SrS\S'SrS\S 'S rS \S '\ "S S S9r S\S'\ "S S SS9r S\S'\ "S S S S9r S\S'S S SS S S S.S0Sjjr \S1Sj5rS2SjrS3SjrS4U4SjjrS5SjrS6Sjr\S7S j5r\S S S S S S!S \S S S S S S S S".S8S#jj5rS9S S S S S S!S \S S S S S S S S".S:S$jjjr\S;S%j5r\S S S S S S!S \S S S S S S S S".SS(j5r\S?S)j5r\S@S*j5r\SAS+j5r\S S,.SBS-jj5rS9S S,.SCS.jjjrS/rU=r$)D Capability$aConvenience capability for bundling instructions, tools, and toolsets without subclassing. This groups related instructions, descriptions, function tools, and toolsets under a capability identity. Instructions passed via `instructions=` are available through `get_instructions()`; [`instructions`][pydantic_ai.capabilities.Capability.instructions] is the decorator for registering instruction functions. The constructor accepts static or callable `description=` values. For model settings, lifecycle hooks, native tools, wrapper toolsets, or custom per-run logic, subclass [`AbstractCapability`][pydantic_ai.capabilities.AbstractCapability]. r_z"Sequence[AgentToolset[AgentDepsT]]toolsetsCapability.Bsprr6)r'r2default_factory$list[SourcedInstruction[AgentDepsT]] _instructions)r'r2default(CapabilityDescription[AgentDepsT] | None _description) instructionsr-r/idr1 defer_loadingcLUb [U5nOSnUb [USS9 X@l[U[5(aUOSUlXPlX`lXplX0l [["X4S9Ul [U5Vs/sHoRU5PM snUlgs snf)a~Build a capability from instructions, tools, toolsets, and an optional description. Args: instructions: Static instructions and/or instruction function(s), available via `get_instructions()`. Pass an [`InstructionPart`][pydantic_ai.messages.InstructionPart] to declare a part's [`name`][pydantic_ai.messages.InstructionPart.name] or mark it [`dynamic`][pydantic_ai.messages.InstructionPart.dynamic]. Register more with the [`instructions`][pydantic_ai.capabilities.Capability.instructions] decorator. toolsets: Toolsets to register with the agent. tools: Function tools to register with the agent. id: Stable identifier for the capability. Required when `defer_loading=True`, so the model's `load_capability` call can reference it. description: Static string or callable description, returned from `get_description()`. For a deferred capability it is shown to the model so it can decide whether to load it. defer_loading: When `True`, the capability's tools and instructions stay hidden until the model loads it on demand via the `load_capability` tool; requires `id`. Nr,z Capability id)kindrA)tuplerrA isinstancestrr1r?rBr-r/r$rr3r_attribute_instructionr<) selfr@r-r/rAr1rBresolved_toolsets instructions r7__init__Capability.__init__Es8   %h  "  > +B_ E*4[#*F*F;D'*)  "1!B!cgr5r,)clss r7get_serialization_name!Capability.get_serialization_nameus r6cUR$r5)r?)rJs r7get_descriptionCapability.get_description|s   r6cjURVs/sHoRPM sn=(d S$s snfr5)r<rL)rJsourceds r7get_instructionsCapability.get_instructionss+373E3EF3E##3EFN$NFs0c>[U5R[RLa[TU]5$[ UR 5$r5)typerXr)super_collect_instructionslistr<)rJ __class__s r7r] Capability._collect_instructionss: : & &j.I.I I702 2D&&''r6c [UR5VVs/sH<up[U[5(aUO[[ "X R U5S9PM> nnnURR(aUR/UQOUnU(d UR$[U5S:XaUS$[[ "U5$s snnf)N) toolset_funcrAr) enumerater-rGr"r%r _toolset_idr3r/lenr&)rJindextsleaves materializeds r7 get_toolsetCapability.get_toolsets't}}5 5 6 "o..  +@P@PQV@WX Y6 5 261G1G1M1MT # # -f -SY )) ) |  !? "z*<88#5 sACcBURcS$URSU3$)aThe `id` for the leaf toolset this capability builds around the callable at `index`. Durable execution identifies a leaf toolset by `id`, so a capability the user named has to pass that name down or the toolset it contributes stays anonymous and unusable there (#7274). One capability can contribute several leaves, though -- `tools=` builds a `FunctionToolset` that already took the bare `id` -- so the position within this capability's own arguments distinguishes them. That position is stable because it is the order the user wrote in `toolsets=`, not an order the run happened to compose, and not one that shifts when a `@tool` is registered later. Pass a `DynamicToolset` with its own `id` instead of a bare callable to name one yourself. Nr+rE)rJrgs r7reCapability._toolset_ids&wwt@twwiq,@@r6cgr5r,rJfuncs r7 tool_plainCapability.tool_plain[^r6autonamer1retriesprepareargs_validatordocstring_formatrequire_parameter_descriptionsschema_generatorstrict sequentialrequires_approvalmetadatatimeoutrBinclude_return_schemacgr5r,rJrwr1rxryrzr{r|r}r~rrrrrBrs r7rrrss (LOr6cjURRUUUUUUUU U U U U UUUS9nUcU$U"U5$)a.Decorator to register a plain (no-[`RunContext`][pydantic_ai.tools.RunContext]) function tool on this capability. Mirrors [`Agent.tool_plain`][pydantic_ai.agent.Agent.tool_plain]: the tool is added to this capability's function toolset and registered with the agent whenever the capability is active. rv)r3rrrJrqrwr1rxryrzr{r|r}r~rrrrrBr decorators r7rrrssa4**55#)-+I-!/'"76 "!Ly=io=r6cgr5r,rps r7toolCapability.toolqtr6cgr5r,rs r7rrs (hkr6cjURRUUUUUUUU U U U U UUUS9nUcU$U"U5$)a Decorator to register a function tool (taking [`RunContext`][pydantic_ai.tools.RunContext]) on this capability. Mirrors [`Agent.tool`][pydantic_ai.agent.Agent.tool]: the tool is added to this capability's function toolset and registered with the agent whenever the capability is active. rv)r3rrs r7rr sa4**//#)-+I-!/'"70 "!Ly=io=r6cgr5r,rps r7r@Capability.instructions9s:=r6cgr5r,rps r7r@r>s EHr6cgr5r,rps r7r@rCrtr6cgr5r,rps r7r@rFrr6rwcgr5r,)rJrws r7r@rIs RUr6cV^^Tb [T5 SUU4SjjnUcU$U"U5$)uDecorator to register an instructions function on this capability. Mirrors `Agent.instructions`: the function may take [`RunContext`][pydantic_ai.tools.RunContext] (or no arguments), may be sync or async, and is appended to any instructions provided via the `instructions=` field. Example: ```python from pydantic_ai import RunContext from pydantic_ai.capabilities import Capability cap = Capability[str](instructions='base instructions') @cap.instructions async def dynamic(ctx: RunContext[str]) -> str: return f'extra: {ctx.deps}' ``` Args: func: The instructions function to register. name: An optional name for the instruction part this function produces, keyed as `'capability::'` on [`InstructionPart.id`][pydantic_ai.messages.InstructionPart.id] so an application can address this part specifically, where the capability's own key addresses everything it contributes. Requires the capability to have an [`id`][pydantic_ai.capabilities.AbstractCapability.id] — without one there is no source key to qualify the name against, so the part stays unaddressable. See [instruction parts](../agent.md#instruction-parts). c >TRb[TR5OSnTRR[ UTUb [ UTS9OSSS95 U$)NrT)rwrAdynamic)rArr<appendrr)func_sourcerwrJs r7r*Capability.instructions..decoratorus_>BWW=P09VZF    % %";A;M}V$7SW  Lr6)rSystemPromptFunc[AgentDepsT]returnr)r)rJrqrwrs` ` r7r@rNsCH   %d + /  )  !Ly=io=r6)r?r3r<rBr1rAr/r-)r@$AgentInstructions[AgentDepsT] | Noner-z)Sequence[AgentToolset[AgentDepsT]] | Noner/r.rAr0r1r>rBboolrNone)rr0)rr>)rr)rr;)rzAgentToolset[AgentDepsT] | None)rgintrr0)rqToolFuncPlain[ToolParams]rr) rwr0r1r0rx int | Nonery"ToolPrepareFunc[AgentDepsT] | Nonerz0ArgsValidatorFunc[AgentDepsT, ToolParams] | Noner{rr|rr}type[GenerateJsonSchema]r~ bool | Nonerrrrrdict[str, Any] | Noner float | NonerBrrrrz@Callable[[ToolFuncPlain[ToolParams]], ToolFuncPlain[ToolParams]]r5)"rqz ToolFuncPlain[ToolParams] | Nonerwr0r1r0rxrryrrzrr{rr|rr}rr~rrrrrrrrrrBrrrrr )rq'ToolFuncContext[AgentDepsT, ToolParams]rr) rwr0r1r0rxrryrrzrr{rr|rr}rr~rrrrrrrrrrBrrrrz\Callable[[ToolFuncContext[AgentDepsT, ToolParams]], ToolFuncContext[AgentDepsT, ToolParams]])"rqz.ToolFuncContext[AgentDepsT, ToolParams] | Nonerwr0r1r0rxrryrrzrr{rr|rr}rr~rrrrrrrrrrBrrrrr )rq.Callable[[RunContext[AgentDepsT]], str | None]rr)rq9Callable[[RunContext[AgentDepsT]], Awaitable[str | None]]rr)rqCallable[[], str | None]rr)rq#Callable[[], Awaitable[str | None]]rr)rwr0rzFCallable[[SystemPromptFunc[AgentDepsT]], SystemPromptFunc[AgentDepsT]])rqz#SystemPromptFunc[AgentDepsT] | Nonerwr0rzeCallable[[SystemPromptFunc[AgentDepsT]], SystemPromptFunc[AgentDepsT]] | SystemPromptFunc[AgentDepsT])__name__ __module__ __qualname____firstlineno____doc____annotations__r-r/r1r r3r<r?rM classmethodrQrTrXr]rkrer rrrrr@__static_attributes__ __classcell__)r_s@r7r)r)$s J35H05VJLE GL4"K" 6;E5R2R:?UQVhr:sM7s=BTYcg=hL:h >B>BNP@D#. ;. < . L .  . >. .  . ` !O( 9, A^^  "&"6:KO,2/45K" "'*. $#-1%O O  O  O4OIO*O)-O3OOO O(O !O"#O$ +%O& J'OO.26+>  "&"6:KO,2/45K" "'*. $#-1'+>.+>  +>  +>+>4+>I+>*+>)-+>3+>+>+> +> (!+>"#+>$%+>& +'+>( )+>Ztt  "&"6:KO,2/45K" "'*. $#-1%k k  k  k4kIk*k)-k3kkk k(k !k"#k$ +%k& f'kk.@D+>  "&"6:KO,2/45K" "'*. $#-1'+><+>  +>  +>+>4+>I+>*+>)-+>3+>+>+> +> (!+>"#+>$%+>& +'+>( )+>Z=B= 7==HMH BHH^^ tt '+U$U OUU 595>  5>15>  5> o 5>5>r6r)N)2 __future__rcollections.abcrrr dataclassesrrr typingr r pydantic.json_schemar pydantic_ai._instructionsr rrrrpydantic_ai._run_contextrr!pydantic_ai.capabilities.abstractrrpydantic_ai.messagesrrpydantic_ai.toolsrrrrrrrrr r!pydantic_ai.toolsetsr"r#r$pydantic_ai.toolsets._dynamicr%pydantic_ai.toolsets.combinedr&r)r,r6r7rsv"9911 3<WK   PO89 ^>#J/^>^>r6