"j%1SrSSKJr SSKrSSKJrJrJr SSK J r SSK J r J r Jr SSKJr SSKJr SS KJr \ (aS S KJr SS jr\"S 15rSSjrSSjrSSjrSSjrSSjrg)azMerging two capabilities that resolved to the same `id` into the one a run uses. Private to the package: this is what `AbstractCapability.combine` does by default, so a capability that wants it gets it by declaring a default `id` and writing no `combine` at all. One that wants something else overrides `combine` and writes the merge it needs, rather than parameterizing this. ) annotationsN)MappingSequenceSet)cached_property) TYPE_CHECKINGAnycast)replace_no_init) UserError) AgentDepsT)AbstractCapabilityctUSn[R"U5Vs1sHo"RiM nn[[ U55U- nUHn[ [ U55U- U- [- nU(dM-[ U5RnSR[U55n[SUR<SUSUSUSUS3 5e 0n [R"U5HwnUR(dM[XR5n [UVs/sHn[XRR5PM snURS 9n XLdMiXUR'My U (a [!U40U D6OUn U (a-[#S U R$5n U[ U 5-HnX M U $s snfs snf) uO Merge same-class capabilities field by field, the way overlapping dicts merge. The `combine` implementation for a capability an agent has one of, where two of them are one configuration stated twice and nothing either of them states should be dropped: | both sides | result | |---|---| | neither states a value | unset | | only one states a value | that value survives | | both state a mapping, sequence, or set | the union, later entries winning a shared key | | anything else | the later value | `None` reads as "not stated", which is what makes a restriction survive being composed with a capability that doesn't mention it: `WebSearch(allowed_domains=[...])` beside a plain `WebSearch()` keeps the allow-list, rather than the plain one silently widening it. Merging starts from the last capability so the fields that can't be reconciled — and the subclass state `replace_no_init` carries over — are the last one's, matching the "later wins" fallback. Fields declared `compare=False` are per-run bookkeeping rather than configuration, so they are left as the last capability's rather than merged. Two limits worth knowing, both from configuration that is resolved before `combine` sees it: a field a `__post_init__` has already materialized (`NativeOrLocalTool` turns `native=True` into a tool instance and `local=None` into its default) can no longer be told apart from one the user stated, so those take the later value; and two objects that carry no meaningful equality (two stores, two clients) likewise take the later. A capability that needs either reconciled — or needs a numeric budget to take the *smaller* value rather than the later one — overrides `combine` itself. An attribute no field declares is a harder limit, and is refused. The table above is what the merge promises, and its first row is the load-bearing one: a value only one side states survives. That cannot hold for an attribute the merge cannot enumerate -- `replace_no_init` copies the last instance, so such an attribute silently takes the last value even where an earlier instance was the only one to state it. Refusing says so instead. A leading underscore does not exempt an attribute from that: it does not distinguish configuration from derived state, and configuration is exactly what must not be dropped. Two kinds are exempt, and they are exempt for different reasons. State the class can produce again -- a `cached_property` -- is *dropped* from the copy, so it is recomputed from the merged fields rather than carried over stale. `__orig_class__` is not the capability's state at all, so it is left alone and simply not counted against it. Nothing here re-runs `__post_init__` (`replace_no_init` exists precisely to skip it), so state a `__post_init__` derives is declared as a field and recomputed in the capability's own `combine`, the way `NativeOrLocalTool` rebuilds its native tool. z, zCapability id z is used by multiple z capabilities, but z sets z outside its dataclass fields. Merging keeps a value only one of them states, and cannot do that for an attribute it cannot enumerate -- the last instance would win silently. Declare a as dataclass fields to have them merged; or, for state derived from other fields, make it a `cached_property` so merging can recompute it, or declare it as a field and override `combine` to recompute it after merging, since this does not re-run `__post_init__`.) field_namezdict[str, Any]) dataclassesfieldsname_rebuildable_attributestypesetvars_NOT_CAPABILITY_STATE__name__joinsortedr idcomparegetattrmerge_field_valuesr r __dict__) capabilitiesmergedfield field_names rebuildable capability undeclaredcls_namenameschangescurrentvalueresult instance_dictrs \/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/capabilities/_merge.pymerge_capability_fieldsr2sd" F+6+=+=f+EF+E%::+EKF*$v,7+EK" j)*[8;FI^^ :F|,,HIIfZ01E  -B8*L_`h_ijw%%*G,** #$!G##F+}} &**-"?K L|WZ ,| LY^YcYc   "'EJJ ,4;_V /w /F-v? #m"44D#5 MQG8 Ms F0F5 __orig_class__c[5nURH2nURS[U5R 555 M4 [ U5$)aAttribute names the class can produce again on demand, so merging drops rather than keeps them. A `cached_property` is the supported way to derive state from fields. It is declared on the class, so this can find it without a list of exceptions to maintain, and discarding the cached value is what makes the merged capability recompute against the merged fields instead of reporting what the last instance happened to have cached. Only names that can actually be recomputed belong here, since everything here is deleted from the merged copy -- an attribute that is merely uninteresting to the merge goes in `_NOT_CAPABILITY_STATE` instead, where it is exempt from the check without being destroyed. c3X# UH up[U[5(dMUv M" g7fN) isinstancer).0rr.s r1 *_rebuildable_attributes..s g-@kdJuVeDfTT-@s* *)r__mro__updateritems frozenset)clsr+klasss r1rr~sCeE gT%[->->-@gg U ch^^UVs/sH o"cMUPM nnU(dgUtmn[U4SjU55(aT$[SU55(a20n[SU5HnURU5 M [TXQ5$[SU55(a5[[ "5R "[SU56n[TXa5$[SU55(a=/m[SU5HnTRU4S jU55 M [TTU5$US $s snf) a]Merge one field's values across the capabilities sharing an id, in application order. `field_name` names the field in the error raised when a declared collection type cannot be rebuilt; the merge itself does not depend on it. Required rather than defaulted, so no caller can produce an error that leaves its reader guessing which field to look at. Nc3<># UHn[TU5v M g7fr6 _same_value)r8otherfirsts r1r9%merge_field_values..s 7$;ue $ $$c3B# UHn[U[5v M g7fr6)r7rr8r.s r1r9rHs :6%:eW % %6zlist[Mapping[Any, Any]]c3B# UHn[U[5v M g7fr6)r7 AbstractSetrKs r1r9rHs >ve:e[ ) )vrLzlist[AbstractSet[Any]]c3p# UH,n[U[5=(a [U5(+v M. g7fr6)r7r _is_recordrKs r1r9rHs' UfU:eX & @z%/@+@ @fs46zlist[Sequence[Any]]c3b>^# UH#m[U4SjT55(aMTv M% g7f)c3<># UHn[TU5v M g7fr6rD)r8keptentrys r1r9/merge_field_values...s3iYhQUKt4L4LYhrIN)any)r8rTmerged_sequences @r1r9rHs$##(%3iYh3i0i5s/ /r)allr r< _as_declaredrr unionextend) valuesrr.statedrestmerged_mapping merged_setrGrWs @@r1r!r!s "( =eF = LED 7$ 777  :6 :::)+3V>> >v >>>XZ%%t,Df'MN E::: Uf UUU%'/8E  " "##(# 9E?J?? ":->s D/D/c[U[[45(ag[U[5=(a [ [ SU5S5$)aWhether a value is a record that merely satisfies `Sequence`, rather than a collection. A `str` is a sequence of characters and a `NamedTuple` a sequence of its fields, but neither is something two capabilities are contributing *entries* to: unioning them would splice one value's characters or columns into the other's. They take the later value, which is what the table gives everything the merge cannot combine. Tr _fields)r7strbytestuplehasattrr )r.s r1rPrPs:%#u&& eU # NUE0BI(NNrAcZ[U5[U5LaU$[U5"U5$![[4ann[SU<S[U5RS[U5RS[U5RS[U5RS3 5UeSnAff=f)aBRebuild `merged` as the collection type the field already held, or refuse. The union is computed in a plain `dict`/`set`/`list`, which would hand a field annotated `tuple[str, ...]` or `frozenset[str]` a value of the wrong type -- and `replace_no_init` skips the `__post_init__` that might otherwise have caught it. A collection type that cannot be rebuilt from its contents leaves no answer worth guessing. Handing back the plain union gives the field a value its own annotation says it cannot hold; handing back one instance's value drops entries the other stated, which is the one thing the merge promises not to do. Records that only look like collections are already gone by here (see `_is_record`), so what is left is a real collection with no way to rebuild it -- and saying so is what the capability's author needs to hear. z2Merging capabilities under one `id` unioned field z into a z, but its declared type zM cannot be rebuilt from that. Keeping the union would give the field a value zT does not describe, and keeping one instance would drop what the other stated. Give z a constructor that takes its contents, declare the field as a plain collection type, or override `combine` to merge this field itself.N)r TypeError ValueErrorr r)rGr$rexcs r1rYrYs E{d6l"  E{6"" z " @hF|$$%%=d5k>R>R=ST&&*5k&:&:%;<66:5k6J6J5KL     s,B*A)B%%B*cHXLag[X:H5$![a gf=f)zTWhether two field values are interchangeable, treating an unusable `__eq__` as "no".TF)bool Exception)leftrights r1rErEs. }DM"" s  !!)r#z(Sequence[AbstractCapability[AgentDepsT]]returnzAbstractCapability[AgentDepsT])r?ztype[AbstractCapability[Any]]rpzfrozenset[str])r\z Sequence[Any]rrcrpr )r.r rprl)rGr r$r rrcrpr )rnr ror rprl)__doc__ __future__rrcollections.abcrrrrN functoolsrtypingrr r pydantic_ai._utilsr pydantic_ai.exceptionsr pydantic_ai.toolsr abstractrr2r>rrr!rPrYrErAr1r{sz#AA%++.,(,[:[#[|"#3"45$@ O<rA