Module `adcp.types.capabilities`

Capability sub-models surfaced from the bundled get_adcp_capabilities_response schema.

Adopters declaring DecisioningCapabilities for a platform (see :mod:adcp.decisioning.platform) need access to the full set of typed capability sub-models — Account, MediaBuy, Targeting, GeoMetros, Idempotency etc. The generated Pydantic classes already exist in adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response, but three of them (Account, MediaBuy, Creative) collide on name with unrelated wire types already exported from :mod:adcp.types.

This module sits in the import-architecture whitelist (alongside aliases.py, _ergonomic.py, _forward_compat.py, _generated.py) for direct generated_poc imports. It pulls the capabilities sub-models out under disambiguated names, so the colliding three don't shadow the wire types when re-exported from :mod:adcp.types. Adopters never import from this module directly — :mod:adcp.decisioning.capabilities is the canonical adopter-facing namespace and re-aliases the three disambiguated names back to their wire-spec form.

Layering::

generated_poc/bundled/protocol/get_adcp_capabilities_response.py
    ↓ (this module — disambiguates colliding names)
adcp.types.capabilities
    ↓ (re-exported from)
adcp.types.__init__
    ↓ (re-aliased to wire-spec names within submodule namespace)
adcp.decisioning.capabilities  ← adopter-facing import path

Classes

class A2ui (**data: Any)

Expand source code

class A2ui(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported: Annotated[bool | None, Field(description='Supports A2UI surface rendering')] = False
    catalogs: Annotated[
        list[str] | None,
        Field(description="Supported A2UI component catalogs (e.g., 'si-standard', 'standard')"),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var catalogs : list[str] | None
var model_config
var supported : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class CapabilitiesAccount (**data: Any)

Expand source code

class Account(AdCPBaseModel):
    require_operator_auth: Annotated[
        bool | None,
        Field(
            description="Whether the seller requires operator-level credentials. This declares who must authenticate; it does not by itself declare whether OAuth is used, whether list_accounts is exposed, or which sync_accounts modes are supported. When true, operators authenticate independently with the seller and account-scoped calls use seller-assigned account_id values because the seller or upstream platform owns the canonical account namespace. If a credential may access more than one account, the seller MUST expose list_accounts and buyers MUST resolve an explicit account_id before the first account-scoped request. If a credential is bound to exactly one account, the seller SHOULD expose list_accounts returning that singleton; a seller MAY omit list_accounts only when it provides the same explicit account_id through another declared path or out-of-band onboarding. When false (default, buyer-declared accounts), the seller trusts the agent's identity claims — the agent authenticates once and declares brands/operators via sync_accounts, then references accounts by natural key."
        ),
    ] = False
    authorization_endpoint: Annotated[
        AnyUrl | None,
        Field(
            description='OAuth authorization endpoint for obtaining operator-level credentials. Present when the seller supports OAuth for operator authentication. The agent directs the operator to this URL to authenticate and obtain a bearer token. If absent and require_operator_auth is true, operators obtain credentials out-of-band (e.g., seller portal, API key).'
        ),
    ] = None
    supported_billing: Annotated[
        list[SupportedBillingEnum],
        Field(
            description='Billing models this seller supports. operator: seller invoices the operator (agency or brand buying direct). agent: agent consolidates billing. advertiser: seller invoices the advertiser directly, even when a different operator places orders on their behalf. The buyer must pass one of these values in sync_accounts.',
            min_length=1,
        ),
    ]
    required_for_products: Annotated[
        bool | None,
        Field(
            description='Whether an account reference is required for get_products. When true, the buyer must establish an account before browsing products. When false (default), the buyer can browse products without an account — useful for price comparison and discovery before committing to a seller.'
        ),
    ] = False
    account_financials: Annotated[
        bool | None,
        Field(
            description='Whether this seller exposes the `get_account_financials` task for querying account-level financial status (spend, credit, invoices). Acts as a **pre-call discriminator** — buyers MUST consult this field before issuing `get_account_financials`; when `false` (or absent), sellers MAY reject the call with an `UNSUPPORTED_FEATURE` / `OPERATION_NOT_SUPPORTED` error. Companion pattern to `creative.bills_through_adcp` (issue #2881) — both fields let buyers gate optional capability calls on a single declared boolean rather than probing for support. Only applicable to operator-billed accounts; sellers using buyer-billed flows omit or set to `false`.'
        ),
    ] = False
    sandbox: Annotated[
        bool | None,
        Field(
            description='Whether this seller supports sandbox accounts for testing. Buyer-declared account sellers provision sandbox accounts via sync_accounts with sandbox: true. Sellers with account_id namespaces expose sandbox accounts as pre-existing test accounts through list_accounts or supply them out-of-band. Requests using a sandbox account perform no real platform calls or spend.'
        ),
    ] = False

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var account_financials : bool | None
var authorization_endpoint : pydantic.networks.AnyUrl | None
var model_config
var require_operator_auth : bool | None
var required_for_products : bool | None
var sandbox : bool | None
var supported_billing : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.SupportedBillingEnum]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Accreditation (**data: Any)

Expand source code

class Accreditation(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    accrediting_body: Annotated[
        str,
        Field(
            description='Accrediting organization — open string (the global landscape includes MRC, ARF, ABC, BARB, JICWEBS, AGOF, JIC bodies in many markets). Use the canonical short name where one exists.',
            examples=['MRC', 'ARF', 'ABC', 'BARB', 'JICWEBS', 'AGOF'],
        ),
    ]
    certification_id: Annotated[
        str | None,
        Field(
            description="Optional identifier for the certification in the accrediting body's records (when one exists; many bodies do not issue stable IDs)."
        ),
    ] = None
    valid_until: Annotated[
        date_aliased | None,
        Field(
            description="Optional ISO 8601 date when the current accreditation expires. Buyers MAY treat post-expiry data as un-accredited. Absence means the vendor does not assert an expiry — buyers SHOULD verify currency at the accrediting body's directory."
        ),
    ] = None
    evidence_url: Annotated[
        AnyUrl | None,
        Field(
            description="Optional URL pointing at the accrediting body's public listing for this certification (the buyer's path to verify the claim independently)."
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var accrediting_body : str
var certification_id : str | None
var evidence_url : pydantic.networks.AnyUrl | None
var model_config
var valid_until : datetime.date | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Adcp (**data: Any)

Expand source code

class Adcp(AdCPBaseModel):
    major_versions: Annotated[
        list[MajorVersion],
        Field(
            description='DEPRECATED in favor of `supported_versions` (release-precision strings). Servers MUST continue to emit this field through 3.x for backwards compatibility. Removed in 4.0. Original semantics: AdCP major versions supported by this seller. Major versions indicate breaking changes.',
            min_length=1,
        ),
    ]
    supported_versions: Annotated[
        list[SupportedVersion] | None,
        Field(
            description='Release-precision (VERSION.RELEASE) AdCP versions this seller speaks. Authoritative for buyer-side release pinning — buyers SHOULD declare `adcp_version` (release-precision string) on each request. Sellers downshift to the highest supported release ≤ the buyer\'s pin within the same major; cross-major mismatch returns VERSION_UNSUPPORTED. Pre-release tags (e.g. `"3.1-beta"`) hang off release.',
            examples=[['3.0'], ['3.0', '3.1'], ['3.0', '3.1-beta']],
            min_length=1,
        ),
    ] = None
    build_version: Annotated[
        str | None,
        Field(
            description="Optional advisory metadata: full semver build identifier of the seller's deployment — MAJOR.MINOR.PATCH plus optional pre-release and build-metadata segments per semver §9–§10. Patches are not part of the wire contract — semver patch by definition introduces no contract change — but surfacing the build helps buyers triage incidents and bug reports against a specific seller deployment lineage. Buyers MUST NOT use this field for negotiation; use `supported_versions` (release-precision) instead.",
            examples=[
                '3.0.1',
                '3.1.2',
                '3.1.0-beta.3',
                '3.1.2+scope3.deploy.4821',
                '3.1.0-beta.3+sha.a1b2c3d',
            ],
            pattern='^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?(\\+[a-zA-Z0-9.-]+)?$',
        ),
    ] = None
    idempotency: Annotated[
        Idempotency | Idempotency1,
        Field(
            description='Idempotency semantics for mutating requests. Sellers MUST declare whether they honor idempotency_key replay protection so buyers can reason about safe retry behavior. Modeled as a discriminated union on the supported boolean so that code generators produce two named types (IdempotencySupported, IdempotencyUnsupported) with the replay_ttl_seconds invariant enforced at the type level — draft-07 if/then would be dropped by most generators (openapi-typescript, zod-to-json-schema, datamodel-code-generator pre-0.25, quicktype). Clients MUST NOT assume a default — a seller without this declaration is non-compliant and should be treated as unsafe for retry-sensitive operations.'
        ),
    ]

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var build_version : str | None
var idempotency : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Idempotency | adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Idempotency1
var major_versions : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.MajorVersion]
var model_config
var supported_versions : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.SupportedVersion] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class AgeRestriction (**data: Any)

Expand source code

class AgeRestriction(AdCPBaseModel):
    supported: Annotated[
        bool | None, Field(description='Whether seller supports age restrictions')
    ] = None
    verification_methods: Annotated[
        list[VerificationMethod] | None,
        Field(description='Age verification methods this seller supports'),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config
var supported : bool | None
var verification_methods : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.VerificationMethod] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class AttributionWindow (**data: Any)

Expand source code

class AttributionWindow(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    event_type: EventType | None = None
    post_click: Annotated[
        list[PostClickItem],
        Field(
            description='Available post-click attribution windows (e.g. [{"interval": 7, "unit": "days"}])',
            min_length=1,
        ),
    ]
    post_view: Annotated[
        list[PostViewItem] | None,
        Field(
            description='Available post-view attribution windows (e.g. [{"interval": 1, "unit": "days"}])',
            min_length=1,
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var event_type : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.EventType | None
var model_config
var post_click : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.PostClickItem]
var post_view : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.PostViewItem] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class AudienceTargeting (**data: Any)

Expand source code

class AudienceTargeting(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported_identifier_types: Annotated[
        list[SupportedIdentifierType],
        Field(
            description='PII-derived identifier types accepted for audience matching. Buyers should only send identifiers the seller supports.',
            min_length=1,
        ),
    ]
    supports_platform_customer_id: Annotated[
        bool | None,
        Field(
            description="Whether the seller accepts the buyer's CRM/loyalty ID as a matchable identifier. Only applicable when the seller operates a closed ecosystem with a shared ID namespace (e.g., a retailer matching against their loyalty program). When true, buyers can include platform_customer_id values in AudienceMember.identifiers for matching against the seller's identity graph. Reporting on matched platform_customer_ids typically requires a clean room or the seller's own reporting surface."
        ),
    ] = None
    supported_uid_types: Annotated[
        list[UIDType] | None,
        Field(
            description='Universal ID types accepted for audience matching (MAIDs, RampID, UID2, etc.). MAID support varies significantly by platform — check this field before sending uids with type: maid.',
            min_length=1,
        ),
    ] = None
    minimum_audience_size: Annotated[
        int,
        Field(
            description='Minimum matched audience size required for targeting. Audiences below this threshold will have status: too_small. Varies by platform (100–1000 is typical).',
            ge=1,
        ),
    ]
    matching_latency_hours: Annotated[
        MatchingLatencyHours | None,
        Field(
            description='Expected matching latency range in hours after upload. Use to calibrate polling cadence and set appropriate expectations before configuring push_notification_config.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var matching_latency_hours : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.MatchingLatencyHours | None
var minimum_audience_size : int
var model_config
var supported_identifier_types : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.SupportedIdentifierType]
var supported_uid_types : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.UIDType] | None
var supports_platform_customer_id : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Avatar (**data: Any)

Expand source code

class Avatar(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    provider: Annotated[
        str | None, Field(description='Avatar provider (d-id, heygen, synthesia, etc.)')
    ] = None
    avatar_id: Annotated[str | None, Field(description='Brand avatar identifier')] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var avatar_id : str | None
var model_config
var provider : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Brand (**data: Any)

Expand source code

class Brand(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    rights: Annotated[
        bool | None,
        Field(
            description='Supports get_rights and acquire_rights for rights discovery and clearance'
        ),
    ] = False
    right_types: Annotated[
        list[RightType] | None, Field(description='Types of rights available through this agent')
    ] = None
    available_uses: Annotated[
        list[AvailableUs] | None,
        Field(description="Rights uses available across this agent's roster"),
    ] = None
    generation_providers: Annotated[
        list[str] | None,
        Field(description='LLM/generation providers this agent can issue credentials for'),
    ] = None
    description: Annotated[
        str | None,
        Field(
            description="Description of the agent's brand protocol capabilities", max_length=5000
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var available_uses : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.AvailableUs] | None
var description : str | None
var generation_providers : list[str] | None
var model_config
var right_types : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.RightType] | None
var rights : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class SiCapabilities (**data: Any)

Expand source code

class Capabilities(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    modalities: Annotated[
        Modalities | None, Field(description='Interaction modalities supported')
    ] = None
    components: Annotated[Components | None, Field(description='Visual components supported')] = (
        None
    )
    commerce: Annotated[Commerce | None, Field(description='Commerce capabilities')] = None
    a2ui: Annotated[A2ui | None, Field(description='A2UI (Agent-to-UI) capabilities')] = None
    mcp_apps: Annotated[
        bool | None, Field(description='Supports MCP Apps for rendering A2UI surfaces in iframes')
    ] = False

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var a2ui : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.A2ui | None
var commerce : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Commerce | None
var components : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Components | None
var mcp_apps : bool | None
var modalities : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Modalities | None
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Commerce (**data: Any)

Expand source code

class Commerce(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    acp_checkout: Annotated[
        bool | None, Field(description='Supports ACP (Agentic Commerce Protocol) checkout handoff')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var acp_checkout : bool | None
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ComplianceTesting (**data: Any)

Expand source code

class ComplianceTesting(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    scenarios: Annotated[
        list[str],
        Field(
            description="Compliance testing scenarios this agent supports. Must be non-empty — at least one scenario. Values SHOULD include every canonical controller scenario the agent implements, excluding list_scenarios because that value is a discovery operation rather than a test capability. Values MAY also include implementation-specific scenarios. Callers can use comply_test_controller with scenario: 'list_scenarios' to discover supported scenarios at runtime.",
            min_length=1,
        ),
    ]

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config
var scenarios : list[str]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Components (**data: Any)

Expand source code

class Components(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    standard: Annotated[
        list[StandardEnum] | None,
        Field(description='Standard components that all SI hosts must render'),
    ] = None
    extensions: Annotated[
        dict[str, Any] | None,
        Field(description='Platform-specific extensions (chatgpt_apps_sdk, maps, forms, etc.)'),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var extensions : dict[str, typing.Any] | None
var model_config
var standard : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.StandardEnum] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class CompromiseNotification (**data: Any)

Expand source code

class CompromiseNotification(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    emits: Annotated[
        bool | None,
        Field(description='Whether this agent emits `identity.compromise_notification` events.'),
    ] = False
    accepts: Annotated[
        bool | None,
        Field(
            description='Whether this agent subscribes to `identity.compromise_notification` events from counterparties it verifies signatures from.'
        ),
    ] = False

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var accepts : bool | None
var emits : bool | None
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class CapabilitiesContentStandards (**data: Any)

Expand source code

class ContentStandards(AdCPBaseModel):
    supports_local_evaluation: Annotated[
        bool | None,
        Field(
            description="Whether the seller runs a local evaluation model. When false, all artifacts will have local_verdict: 'unevaluated' and the failures_only filter on get_media_buy_artifacts is not useful."
        ),
    ] = None
    supported_channels: Annotated[
        list[MediaChannel] | None,
        Field(
            description='Channels for which the seller can provide content artifacts. Helps buyers understand which parts of a mixed-channel buy will have content standards coverage.',
            min_length=1,
        ),
    ] = None
    supports_webhook_delivery: Annotated[
        bool | None,
        Field(
            description='Whether the seller supports push-based artifact delivery via artifact_webhook configured at buy creation time.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config
var supported_channels : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.MediaChannel] | None
var supports_local_evaluation : bool | None
var supports_webhook_delivery : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ConversionTracking (**data: Any)

Expand source code

class ConversionTracking(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    multi_source_event_dedup: Annotated[
        bool | None,
        Field(
            description='Whether this seller can deduplicate conversion events across multiple event sources within a single goal. When true, the seller honors the deduplication semantics in optimization_goals event_sources arrays — the same event_id from multiple sources counts once. When false or absent, buyers should use a single event source per goal; multi-source arrays will be treated as first-source-wins. Most social platforms cannot deduplicate across independently-managed pixel and CAPI sources.'
        ),
    ] = None
    per_creative_attribution: Annotated[
        bool | None,
        Field(
            description='Whether the seller can attribute conversions to specific creatives within a package and surface that breakdown via media_buy_deliveries[].by_package[].by_creative[].conversions in get_media_buy_delivery. Defaults to false when omitted. Sellers that report conversions only at the line / package / placement / campaign granularity (retail-media, MMP-mediated mobile, CTV performance) declare false (or omit) and the per-creative scenario grades not_applicable for them. Sellers that surface ad-level conversion attribution (most social platforms) declare true and the scenario asserts the breakdown is populated end-to-end. Defaults to false to preserve backward compatibility.'
        ),
    ] = None
    supported_event_types: Annotated[
        list[EventType] | None,
        Field(
            description='Event types this seller can track and attribute. If omitted, all standard event types are supported.',
            min_length=1,
        ),
    ] = None
    supported_targets: Annotated[
        list[SupportedTarget1] | None,
        Field(
            description='Event-goal target kinds this seller can compute against. Buyers should only submit event-kind optimization goals whose target.kind is listed here — sellers MUST reject goals with unlisted target kinds. When omitted, only target-less event goals (maximize conversion count within budget) are guaranteed; sellers MAY accept specific target kinds but buyers should not rely on it. Named to parallel `metric_optimization.supported_targets` at the product level — same concept (which target kinds are supported), one at seller-capability granularity and one at product granularity.',
            min_length=1,
        ),
    ] = None
    supported_uid_types: Annotated[
        list[UIDType] | None,
        Field(description='Universal ID types accepted for user matching', min_length=1),
    ] = None
    supported_hashed_identifiers: Annotated[
        list[SupportedIdentifierType] | None,
        Field(
            description='Hashed PII types accepted for user matching. Buyers must hash before sending (SHA-256, normalized).',
            min_length=1,
        ),
    ] = None
    supported_action_sources: Annotated[
        list[SupportedActionSource] | None,
        Field(description='Action sources this seller accepts events from', min_length=1),
    ] = None
    attribution_windows: Annotated[
        list[AttributionWindow] | None,
        Field(
            description='Attribution windows available from this seller. Single-element arrays indicate fixed windows; multi-element arrays indicate configurable options the buyer can choose from via attribution_window on optimization goals.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var attribution_windows : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.AttributionWindow] | None
var model_config
var multi_source_event_dedup : bool | None
var per_creative_attribution : bool | None
var supported_action_sources : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.SupportedActionSource] | None
var supported_event_types : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.EventType] | None
var supported_hashed_identifiers : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.SupportedIdentifierType] | None
var supported_targets : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.SupportedTarget1] | None
var supported_uid_types : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.UIDType] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class CapabilitiesCreative (**data: Any)

Expand source code

class Creative(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supports_compliance: Annotated[
        bool | None,
        Field(
            description='When true, this creative agent can process briefs with compliance requirements (required_disclosures, prohibited_claims) and will validate that disclosures can be satisfied by the target format.'
        ),
    ] = None
    has_creative_library: Annotated[
        bool | None,
        Field(
            description='When true, this agent hosts a creative library and supports list_creatives and creative_id references in build_creative. Creative agents with a library should also implement the accounts protocol (sync_accounts / list_accounts) so buyers can establish access.'
        ),
    ] = False
    supports_generation: Annotated[
        bool | None,
        Field(
            description='When true, this agent can generate creatives from natural language briefs via build_creative. The buyer provides a message with creative direction, and the agent produces a manifest with generated assets. When false, build_creative only supports transformation or library retrieval.'
        ),
    ] = False
    supports_transformation: Annotated[
        bool | None,
        Field(
            description='When true, this agent can transform or resize existing manifests via build_creative. The buyer provides a creative_manifest and a target_format_id, and the agent adapts the creative to the new format.'
        ),
    ] = False
    supports_transformers: Annotated[
        bool | None,
        Field(
            description='When true, this agent exposes account-scoped creative transformers via list_transformers (the creative analog of media-buy products) and accepts transformer_id + config on build_creative. Buyers SHOULD call list_transformers to discover available transformers, their typed config params (and account-scoped enumerable option values via expand_params), and pricing. When false or absent, the agent does not offer the transformer surface.'
        ),
    ] = False
    supports_refinement: Annotated[
        bool | None,
        Field(
            description="When true, this agent retains produced build_variant leaves for an agent-defined retention window and can re-build from one via build_creative's refine_from_build_variant_id — applying a natural-language instruction in message plus an optional config delta, returning new lineage-linked variants. A build-time agent capability independent of generation/transformation. When false or absent, refine_from_build_variant_id is rejected with UNSUPPORTED_FEATURE; buyers refine instead via the transform path (creative_manifest + message)."
        ),
    ] = False
    supports_spend_controls: Annotated[
        bool | None,
        Field(
            description='When true, build_creative honors a per-call `max_spend` ceiling (producing partial paid results and returning budget_status:"capped" + a BUDGET_CAP_REACHED advisory rather than overspending) AND supports mode:"estimate" dry-runs (a projected cost band, producing/billing nothing). When false or absent, max_spend / mode:estimate are rejected with UNSUPPORTED_FEATURE. Out-of-band billers (bills_through_adcp:false) have no AdCP cost truth to cap against, so this is meaningful only alongside bills_through_adcp:true.'
        ),
    ] = False
    supports_evaluator: Annotated[
        bool | None,
        Field(
            description="Experimental (x-status: experimental) — agents setting this true MUST also list `creative.evaluator` in `experimental_features`; the surface MAY change between 3.x releases with notice (see docs/reference/experimental-status). When true, build_creative accepts an advisory `evaluator` input (exemplars / account-arranged evaluator_id / agent_url, plus an optional `feature_requirement[]` gate, a `rank_by` ordering, and an allowlisted `feature_agent` pointer). Feature discovery uses this response's governance.creative_features catalog: rank_by, feature_requirement, and eval.features[] all share the same creative-feature vocabulary as get_creative_features. evaluator_id is not discovered from this catalog; it is a pre-provisioned account preset whose emitted feature_ids still come from it. The evaluator populates a per-leaf `eval` block of creative-feature values (creative-feature-result[], the same shape get_creative_features returns) on BuildCreativeVariantSuccess leaves, which is what the recommended/rank it sets on the best_of_n axis are computed over. The agent runs a gate-then-rank pipeline over its best_of_n exploration: it evaluates each leaf, DROPS leaves failing `feature_requirement[]` from its recommended survivors, then orders survivors by `rank_by`. The gate is internal pruning of which leaves the agent recommends/returns from its own exploration — it never blocks an already-produced billable leaf: what is produced and billed is governed by max_variants/max_creatives/max_spend, not the evaluator. When the evaluator names an external agent, it MUST appear in `creative_policy.accepted_verifiers[]` (off-list → EVALUATOR_AGENT_NOT_ACCEPTED), and the producing agent authenticates the outbound evaluator call on the transport. Evaluator credentials and caller-supplied trust material MUST NOT be passed in the build_creative payload; credential- or trust-material payload keys should be rejected with CREDENTIAL_IN_ARGS. When false or absent, the `evaluator` input is ignored and no `eval` block is emitted."
        ),
    ] = False
    refinable_retention_seconds: Annotated[
        int | None,
        Field(
            description='When supports_refinement is true, the GUARANTEED-MINIMUM window (a floor, not a ceiling) during which a produced build_variant_id remains refinable via refine_from_build_variant_id: a ref within this window from production SHOULD resolve; the agent MAY retain longer. Omit when the retention window is agent-defined and not advertised — buyers then treat refinability as best-effort and handle REFERENCE_NOT_FOUND.',
            ge=0,
        ),
    ] = None
    multiplicity: Annotated[
        Multiplicity | None,
        Field(
            description="Pre-call discriminators for build_creative fan-out, so a buyer knows BEFORE sending max_creatives / max_variants whether this agent supports them and the ceilings. Over-limit requests are CLAMPED to these ceilings (the agent produces up to the limit and signals the shortfall via items_returned < items_total on BuildCreativeVariantSuccess), not rejected — consistent with item_limit's 'use the lesser' rule. Absent means no fan-out: build_creative produces a single creative and max_creatives/max_variants>1 are not supported."
        ),
    ] = None
    supported_formats: Annotated[
        list[SupportedFormat] | None,
        Field(
            description="Canonical-formats path: format declarations describing which canonical formats this creative agent can produce via `build_creative`. Each entry uses the same `ProductFormatDeclaration` shape as a product's inline `format_options[i]` — `format_kind` discriminator + `params` (canonical's parameter schema including `slots`, dimensions, durations, codecs, character limits, platform_extensions, tracking_extensions). Replaces the v1 `list_creative_formats` discovery surface for creative agents."
        ),
    ] = None
    bills_through_adcp: Annotated[
        bool | None,
        Field(
            description='When true, this creative agent bills through the AdCP rate-card surface: list_creatives returns pricing_options when include_pricing=true with an authenticated account, build_creative populates pricing_option_id and vendor_cost on the response, and report_usage accepts records against the rate card. When false or absent, the agent bills out of band (flat license, SaaS contract, bundled enterprise agreement) and buyers should skip pricing fields and tolerate report_usage returning accepted: 0 with errors carrying BILLING_OUT_OF_BAND. A pre-call discriminator so buyer agents can route across many creative agents without first establishing an account to probe pricing.'
        ),
    ] = False
    canonical_catalog_version: Annotated[
        str | None,
        Field(
            description="Optional. The AdCP canonical-formats catalog version this agent's runtime is built against (e.g., `3.1`, `3.2.0`). Lets buyer SDKs detect canonical-catalog skew between their generated types and the seller's actual support. SDKs MAY declare the version they were generated against (typically the AdCP version they ship for); when seller and SDK versions disagree, SDKs SHOULD soft-warn rather than fail (the open-enum semantics on `canonical-format-kind.json` make unknown canonicals safe to retain, so skew is not a hard error — it just means the older side might not understand newer canonical values). Omitted by sellers who haven't yet generated against a versioned catalog; absence is interpreted as the AdCP version advertised by the broader capabilities response.",
            pattern='^\\d+\\.\\d+(\\.\\d+)?$',
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var bills_through_adcp : bool | None
var canonical_catalog_version : str | None
var has_creative_library : bool | None
var model_config
var multiplicity : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Multiplicity | None
var refinable_retention_seconds : int | None
var supported_formats : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.SupportedFormat] | None
var supports_compliance : bool | None
var supports_evaluator : bool | None
var supports_generation : bool | None
var supports_refinement : bool | None
var supports_spend_controls : bool | None
var supports_transformation : bool | None
var supports_transformers : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class CreativeSpecs (**data: Any)

Expand source code

class CreativeSpecs(AdCPBaseModel):
    vast_versions: Annotated[
        list[VastVersion] | None, Field(description='VAST versions supported for video creatives')
    ] = None
    mraid_versions: Annotated[
        list[MraidVersion] | None,
        Field(description='MRAID versions supported for rich media mobile creatives'),
    ] = None
    vpaid: Annotated[bool | None, Field(description='VPAID support for interactive video ads')] = (
        None
    )
    simid: Annotated[bool | None, Field(description='SIMID support for interactive video ads')] = (
        None
    )

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config
var mraid_versions : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.MraidVersion] | None
var simid : bool | None
var vast_versions : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.VastVersion] | None
var vpaid : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Endpoint (**data: Any)

Expand source code

class Endpoint(AdCPBaseModel):
    transports: Annotated[
        list[Transport],
        Field(
            description='Available protocol transports. Hosts select based on their capabilities.',
            min_length=1,
        ),
    ]
    preferred: Annotated[
        Type9 | None, Field(description='Preferred transport when host supports multiple')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config
var preferred : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Type9 | None
var transports : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Transport]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Execution (**data: Any)

Expand source code

class Execution(AdCPBaseModel):
    trusted_match: Annotated[
        TrustedMatch | None,
        Field(
            description='Trusted Match Protocol (TMP) support. Presence of this object indicates the seller has TMP infrastructure deployed. Check individual products via get_products for per-product TMP capabilities.'
        ),
    ] = None
    axe_integrations: Annotated[
        list[AnyUrl] | None,
        Field(
            description='Deprecated. Legacy AXE integrations. Use trusted_match for new integrations.'
        ),
    ] = None
    creative_specs: Annotated[
        CreativeSpecs | None, Field(description='Creative specification support')
    ] = None
    targeting: Annotated[
        Targeting | None,
        Field(
            description='Targeting capabilities. If declared true/supported, buyer can use these targeting parameters and seller MUST honor them.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var axe_integrations : list[pydantic.networks.AnyUrl] | None
var creative_specs : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.CreativeSpecs | None
var model_config
var targeting : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Targeting | None
var trusted_match : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.TrustedMatch | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ExperimentalFeature (root: RootModelRootType = PydanticUndefined, **data)

Expand source code

class ExperimentalFeature(RootModel[str]):
    root: Annotated[
        str,
        Field(
            description="Experimental feature id (dot-separated lowercase identifiers, e.g., 'brand.rights_lifecycle', 'governance.campaign', 'measurement.core', 'trusted_match.core')",
            pattern='^[a-z][a-z0-9_]*(\\.[a-z][a-z0-9_]*)*$',
        ),
    ]

Usage Documentation

RootModel and Custom Root Types

A Pydantic BaseModel for the root object of the model.

Attributes

root: The root object of the model.
__pydantic_root_model__: Whether the model is a RootModel.
__pydantic_private__: Private fields in the model.
__pydantic_extra__: Extra fields in the model.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

pydantic.root_model.RootModel[str]
pydantic.root_model.RootModel
pydantic.main.BaseModel
typing.Generic

Class variables

var model_config
var root : str

class Features (**data: Any)

Expand source code

class Features(AdCPBaseModel):
    inline_creative_management: Annotated[
        bool | None,
        Field(
            description='Supports creatives provided inline in create_media_buy and update_media_buy package payloads. This flag does not imply a creative library: an inline-only seller can accept packages[].creatives without advertising sync_creatives, list_creatives, or reusable creative IDs.'
        ),
    ] = None
    property_list_filtering: Annotated[
        bool | None,
        Field(
            description='Honors property_list parameter in get_products to filter results to buyer-approved properties'
        ),
    ] = None
    catalog_management: Annotated[
        bool | None,
        Field(
            description='Supports sync_catalogs task for catalog feed management with platform review and approval'
        ),
    ] = None
    committed_metrics_supported: Annotated[
        bool | None,
        Field(
            description="Seller has per-package snapshot infrastructure for the reporting contract. When true, the seller MUST populate `package.committed_metrics` on committed `create_media_buy` responses where `confirmed_at` is non-null, MUST omit `package.committed_metrics` while `confirmed_at` is null for a provisional buy, and MUST honor append-only mid-flight metric additions via `update_media_buy`. The unified `committed_metrics` array (per the metric-accountability design) covers both standard and vendor-defined metric entries, so a single flag is load-bearing. Buyers filtering on this flag are detecting 'this seller can stamp the reporting contract,' which closes the audit gap from PR #3510 where absence of `committed_metrics` was indistinguishable between 'didn't snapshot' and 'snapshot infrastructure not implemented.'"
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var catalog_management : bool | None
var committed_metrics_supported : bool | None
var inline_creative_management : bool | None
var model_config
var property_list_filtering : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class SignalsFeatures (**data: Any)

Expand source code

class Features1(AdCPBaseModel):
    catalog_signals: Annotated[
        bool | None,
        Field(
            deprecated=True,
            description='DEPRECATED. Legacy wire flag for structured signal_ref references to provider-published signal definitions. New agents SHOULD omit this flag; callers MUST NOT require it before using signal_ref with the Signals protocol.',
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var catalog_signals : bool | None
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class GeoMetros (**data: Any)

Expand source code

class GeoMetros(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    nielsen_dma: bool | None = None
    uk_itl1: bool | None = None
    uk_itl2: bool | None = None
    eurostat_nuts2: bool | None = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var eurostat_nuts2 : bool | None
var model_config
var nielsen_dma : bool | None
var uk_itl1 : bool | None
var uk_itl2 : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class GeoPostalAreas (**data: Any)

Expand source code

class GeoPostalAreas(AdCPBaseModel):
    US: Annotated[list[ME] | None, Field(min_length=1)] = None
    GB: Annotated[list[GBEnum] | None, Field(min_length=1)] = None
    CA: Annotated[list[CAEnum] | None, Field(min_length=1)] = None
    DE: Annotated[list[Literal['plz']] | None, Field(min_length=1)] = None
    CH: Annotated[list[Literal['plz']] | None, Field(min_length=1)] = None
    AT: Annotated[list[Literal['plz']] | None, Field(min_length=1)] = None
    FR: Annotated[list[Literal['code_postal']] | None, Field(min_length=1)] = None
    AU: Annotated[list[Literal['postcode']] | None, Field(min_length=1)] = None
    BR: Annotated[list[Literal['cep']] | None, Field(min_length=1)] = None
    IN: Annotated[list[Literal['pin']] | None, Field(min_length=1)] = None
    ZA: Annotated[list[Literal['postal_code']] | None, Field(min_length=1)] = None
    us_zip: Annotated[bool | None, Field(deprecated=True)] = None
    us_zip_plus_four: Annotated[bool | None, Field(deprecated=True)] = None
    gb_outward: Annotated[bool | None, Field(deprecated=True)] = None
    gb_full: Annotated[bool | None, Field(deprecated=True)] = None
    ca_fsa: Annotated[bool | None, Field(deprecated=True)] = None
    ca_full: Annotated[bool | None, Field(deprecated=True)] = None
    de_plz: Annotated[bool | None, Field(deprecated=True)] = None
    fr_code_postal: Annotated[bool | None, Field(deprecated=True)] = None
    au_postcode: Annotated[bool | None, Field(deprecated=True)] = None
    ch_plz: Annotated[bool | None, Field(deprecated=True)] = None
    at_plz: Annotated[bool | None, Field(deprecated=True)] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var AT : list[typing.Literal['plz']] | None
var AU : list[typing.Literal['postcode']] | None
var BR : list[typing.Literal['cep']] | None
var CA : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.CAEnum] | None
var CH : list[typing.Literal['plz']] | None
var DE : list[typing.Literal['plz']] | None
var FR : list[typing.Literal['code_postal']] | None
var GB : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.GBEnum] | None
var IN : list[typing.Literal['pin']] | None
var US : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.ME] | None
var ZA : list[typing.Literal['postal_code']] | None
var at_plz : bool | None
var au_postcode : bool | None
var ca_fsa : bool | None
var ca_full : bool | None
var ch_plz : bool | None
var de_plz : bool | None
var fr_code_postal : bool | None
var gb_full : bool | None
var gb_outward : bool | None
var model_config
var us_zip : bool | None
var us_zip_plus_four : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class GeoProximity (**data: Any)

Expand source code

class GeoProximity(AdCPBaseModel):
    radius: Annotated[
        bool | None,
        Field(
            description='Whether seller supports simple radius targeting (distance circle from a point)'
        ),
    ] = None
    travel_time: Annotated[
        bool | None,
        Field(
            description='Whether seller supports travel time isochrone targeting (requires a routing engine)'
        ),
    ] = None
    geometry: Annotated[
        bool | None,
        Field(
            description='Whether seller supports pre-computed GeoJSON geometry (buyer provides the polygon)'
        ),
    ] = None
    transport_modes: Annotated[
        list[TransportMode] | None,
        Field(
            description='Transport modes supported for travel_time isochrones. Only relevant when travel_time is true.',
            min_length=1,
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var geometry : bool | None
var model_config
var radius : bool | None
var transport_modes : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.TransportMode] | None
var travel_time : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Governance (**data: Any)

Expand source code

class Governance(AdCPBaseModel):
    aggregation_window_days: Annotated[
        int | None,
        Field(
            description='Trailing window (in days) over which this governance agent aggregates committed spend when evaluating dollar-valued thresholds (reallocation_threshold, human_review triggers, registry-policy floors). Required for fragmentation defense: without aggregation, a buyer can split a single large spend into many sub-threshold commits across plans / task surfaces / time and bypass every dollar-gated escalation. Aggregation is keyed on (buyer_agent, seller_agent, account_id) and spans all spend-commit task types. Upper bound 365 represents a one-year trailing window (fiscal-year alignment with grace); governance agents needing longer scopes negotiate via operator sign-off, not this capability. No schema default: absence of this field indicates the governance agent has not committed to any aggregation window and buyers MUST assume per-commit evaluation only (the fragmentation attack surface is open). A declared value of 30 is a common starting point but is not implied by omission. Buyers depending on a specific window for compliance MUST check this capability before relying on aggregation semantics — an agent declaring 7 days does not defend against fragmentation spread across a 30-day quarter-end push.',
            ge=1,
            le=365,
        ),
    ] = None
    property_features: Annotated[
        list[PropertyFeature] | None,
        Field(
            description='Property features this governance agent can evaluate. Each feature describes a score, rating, or certification the agent can provide for properties.'
        ),
    ] = None
    creative_features: Annotated[
        list[CreativeFeature] | None,
        Field(
            description='Creative features this governance agent can evaluate. Each feature describes a score, rating, or assessment the agent can provide for creatives (e.g., security scanning, creative quality, content categorization).'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var aggregation_window_days : int | None
var creative_features : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.CreativeFeature] | None
var model_config
var property_features : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.PropertyFeature] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Idempotency (**data: Any)

Expand source code

class Idempotency(AdCPBaseModel):
    supported: Annotated[
        Literal[True],
        Field(
            description='Discriminator. True means the seller deduplicates replays — a repeat of the same idempotency_key within replay_ttl_seconds returns the cached response without re-executing side effects.'
        ),
    ]
    replay_ttl_seconds: Annotated[
        int,
        Field(
            description="How long the seller retains a canonical response for an idempotency_key. Within this window, a replay with the same key + equivalent canonical payload returns the cached response; a replay with a different canonical payload returns IDEMPOTENCY_CONFLICT; a replay past the window returns IDEMPOTENCY_EXPIRED when the seller can still distinguish 'seen and evicted' from 'never seen'. Minimum 3600 (1h); recommended 86400 (24h). Maximum 604800 (7 days) — longer windows force buyers to retain secret keys at rest for extended periods and grow the seller's cache table without bounded benefit.",
            ge=3600,
            le=604800,
        ),
    ]
    in_flight_max_seconds: Annotated[
        int | None,
        Field(
            description="Maximum lifetime in seconds of an in-flight idempotency row before the seller releases it per L1/security.mdx rule 9 (treat the in-flight attempt as failed if the handler does not complete within this bound). Buyer SDKs use this value to compute a retry budget when they see `IDEMPOTENCY_IN_FLIGHT` — cap individual retry waits at this value rather than the much-wider `replay_ttl_seconds` ceiling. Optional in 3.1 (additive declaration); SDKs that don't see the field fall back to rule 9's order-of-magnitude SHOULD heuristic. Required when `supported: true` in 4.0. MUST be no greater than `replay_ttl_seconds` (a bound larger than the replay window is vacuous — any retry past the TTL hits IDEMPOTENCY_EXPIRED regardless of in-flight state); validators MUST enforce this cross-field constraint at the test layer since JSON Schema cannot express field-relative bounds. A buyer that observes `error.details.retry_after` exceeding this value MAY treat that as a seller bug — the in-flight row cannot legitimately outlive the bound the seller declared.",
            ge=1,
            le=604800,
        ),
    ] = None
    account_id_is_opaque: Annotated[
        bool | None,
        Field(
            description="When true, the seller derives `account_id` via an HKDF-based one-way transform of the buyer's natural account key rather than echoing the natural key on the wire. Buyers MUST NOT attempt to invert the opaque id and MUST treat it as a blind handle scoped to this seller. Absent or false, callers should assume `account_id` is the natural key (or a server-assigned but non-opaque id). This flag does not change the wire shape, but it DOES change buyer behavior — buyers MUST NOT cache, log, or treat `account_id` as a natural-key analog when this flag is true. Migration note for sellers already returning an opaque id without this flag: set it to true at the next capabilities refresh so buyers stop inferring natural-key semantics; until set, new-buyer replay/retry logic will misclassify these ids as natural keys."
        ),
    ] = False

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var account_id_is_opaque : bool | None
var in_flight_max_seconds : int | None
var model_config
var replay_ttl_seconds : int
var supported : Literal[True]

class IdempotencySupported (**data: Any)

Expand source code

class Idempotency(AdCPBaseModel):
    supported: Annotated[
        Literal[True],
        Field(
            description='Discriminator. True means the seller deduplicates replays — a repeat of the same idempotency_key within replay_ttl_seconds returns the cached response without re-executing side effects.'
        ),
    ]
    replay_ttl_seconds: Annotated[
        int,
        Field(
            description="How long the seller retains a canonical response for an idempotency_key. Within this window, a replay with the same key + equivalent canonical payload returns the cached response; a replay with a different canonical payload returns IDEMPOTENCY_CONFLICT; a replay past the window returns IDEMPOTENCY_EXPIRED when the seller can still distinguish 'seen and evicted' from 'never seen'. Minimum 3600 (1h); recommended 86400 (24h). Maximum 604800 (7 days) — longer windows force buyers to retain secret keys at rest for extended periods and grow the seller's cache table without bounded benefit.",
            ge=3600,
            le=604800,
        ),
    ]
    in_flight_max_seconds: Annotated[
        int | None,
        Field(
            description="Maximum lifetime in seconds of an in-flight idempotency row before the seller releases it per L1/security.mdx rule 9 (treat the in-flight attempt as failed if the handler does not complete within this bound). Buyer SDKs use this value to compute a retry budget when they see `IDEMPOTENCY_IN_FLIGHT` — cap individual retry waits at this value rather than the much-wider `replay_ttl_seconds` ceiling. Optional in 3.1 (additive declaration); SDKs that don't see the field fall back to rule 9's order-of-magnitude SHOULD heuristic. Required when `supported: true` in 4.0. MUST be no greater than `replay_ttl_seconds` (a bound larger than the replay window is vacuous — any retry past the TTL hits IDEMPOTENCY_EXPIRED regardless of in-flight state); validators MUST enforce this cross-field constraint at the test layer since JSON Schema cannot express field-relative bounds. A buyer that observes `error.details.retry_after` exceeding this value MAY treat that as a seller bug — the in-flight row cannot legitimately outlive the bound the seller declared.",
            ge=1,
            le=604800,
        ),
    ] = None
    account_id_is_opaque: Annotated[
        bool | None,
        Field(
            description="When true, the seller derives `account_id` via an HKDF-based one-way transform of the buyer's natural account key rather than echoing the natural key on the wire. Buyers MUST NOT attempt to invert the opaque id and MUST treat it as a blind handle scoped to this seller. Absent or false, callers should assume `account_id` is the natural key (or a server-assigned but non-opaque id). This flag does not change the wire shape, but it DOES change buyer behavior — buyers MUST NOT cache, log, or treat `account_id` as a natural-key analog when this flag is true. Migration note for sellers already returning an opaque id without this flag: set it to true at the next capabilities refresh so buyers stop inferring natural-key semantics; until set, new-buyer replay/retry logic will misclassify these ids as natural keys."
        ),
    ] = False

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var account_id_is_opaque : bool | None
var in_flight_max_seconds : int | None
var model_config
var replay_ttl_seconds : int
var supported : Literal[True]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class IdempotencyUnsupported (**data: Any)

Expand source code

class Idempotency1(AdCPBaseModel):
    supported: Annotated[
        Literal[False],
        Field(description='Discriminator. False means the seller does not deduplicate retries.'),
    ]

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config
var supported : Literal[False]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Identity (**data: Any)

Expand source code

class Identity(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    brand_json_url: Annotated[
        AnyUrl | None,
        Field(
            description="HTTPS URL of the operator's brand.json (typically `https://{operator-domain}/.well-known/brand.json`). Trust-root pointer for this agent's signing keys. See [security.mdx §Discovering an agent's signing keys via `brand_json_url`](https://adcontextprotocol.org/docs/building/by-layer/L1/security#discovering-an-agents-signing-keys-via-brand_json_url) for the verifier algorithm and `x-adcp-validation` for structured constraints. Distinct from `sponsored_intelligence.brand_url`, which is a rendering pointer for SI agent visuals — verifiers MUST use this field for key discovery and MUST NOT fall back to `sponsored_intelligence.brand_url` as a trust-root pointer."
        ),
    ] = None
    per_principal_key_isolation: Annotated[
        bool | None,
        Field(
            description="When true, this multi-principal operator scopes signing keys per-principal so a single principal's key compromise does not silently re-scope across principals served by the same operator. `kid` values remain opaque to verifiers per RFC 7517; any operator-side naming convention (e.g., `{operator}:{principal}:{key_version}`) is internal bookkeeping and MUST NOT be parsed by verifiers. See docs/building/understanding/security-model.mdx."
        ),
    ] = False
    key_origins: Annotated[
        KeyOrigins | None,
        Field(
            description='Map of signing-key surface/purpose → publishing origin, so counterparties can verify origin separation (e.g., governance keys served from a separate origin than transport/webhook keys) at onboarding. Absent means the operator has not declared a separation scheme; receivers SHOULD assume shared-origin. Every entry listed MUST have a corresponding signing posture declared elsewhere — `request_signing` requires non-empty `request_signing.supported_for`/`required_for`/`protocol_methods_supported_for`/`protocol_methods_required_for`; `webhook_signing` requires `webhook_signing.supported === true` and names the webhook delivery surface, not a required live `adcp_use: "webhook-signing"` key purpose — otherwise the consistency check at signature-verification time has nothing to anchor against. See `x-adcp-validation` and docs/building/implementation/security.mdx §Origin separation.'
        ),
    ] = None
    compromise_notification: Annotated[
        CompromiseNotification | None,
        Field(
            description='Whether this agent emits the `identity.compromise_notification` webhook event on key revocation due to known or suspected compromise (as opposed to scheduled rotation). Subscribers use this to bound the window between compromise detected and verifiers converging on revocation. See docs/building/implementation/webhooks.mdx §identity.compromise_notification.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var brand_json_url : pydantic.networks.AnyUrl | None
var compromise_notification : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.CompromiseNotification | None
var key_origins : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.KeyOrigins | None
var model_config
var per_principal_key_isolation : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class KeyOrigins (**data: Any)

Expand source code

class KeyOrigins(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    governance_signing: Annotated[
        AnyUrl | None,
        Field(description='Origin (scheme + host) serving the governance-signing JWKS.'),
    ] = None
    request_signing: Annotated[
        AnyUrl | None, Field(description='Origin (scheme + host) serving the request-signing JWKS.')
    ] = None
    webhook_signing: Annotated[
        AnyUrl | None,
        Field(
            description='Origin (scheme + host) serving the JWKS used for webhook delivery. Webhooks are signed with `adcp_use: "request-signing"` keys; the deprecated `adcp_use: "webhook-signing"` value remains accepted during the backward-compatibility window.'
        ),
    ] = None
    tmp_signing: Annotated[
        AnyUrl | None,
        Field(
            description='Origin (scheme + host) serving the TMP-signing JWKS, when this operator participates in TMP.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var governance_signing : pydantic.networks.AnyUrl | None
var model_config
var request_signing : pydantic.networks.AnyUrl | None
var tmp_signing : pydantic.networks.AnyUrl | None
var webhook_signing : pydantic.networks.AnyUrl | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class KeywordTargets (**data: Any)

Expand source code

class KeywordTargets(AdCPBaseModel):
    supported_match_types: Annotated[
        list[MatchType],
        Field(
            description='Match types this seller supports for keyword targets. Sellers must reject goals with unsupported match types.',
            min_length=1,
        ),
    ]

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config
var supported_match_types : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.MatchType]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class LegacyPostalCodeSystem (*args, **kwds)

Expand source code

class LegacyPostalCodeSystem(StrEnum):
    us_zip = 'us_zip'
    us_zip_plus_four = 'us_zip_plus_four'
    gb_outward = 'gb_outward'
    gb_full = 'gb_full'
    ca_fsa = 'ca_fsa'
    ca_full = 'ca_full'
    de_plz = 'de_plz'
    fr_code_postal = 'fr_code_postal'
    au_postcode = 'au_postcode'
    ch_plz = 'ch_plz'
    at_plz = 'at_plz'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var at_plz
var au_postcode
var ca_fsa
var ca_full
var ch_plz
var de_plz
var fr_code_postal
var gb_full
var gb_outward
var us_zip
var us_zip_plus_four

class MatchingLatencyHours (**data: Any)

Expand source code

class MatchingLatencyHours(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    min: Annotated[int | None, Field(ge=0)] = None
    max: Annotated[int | None, Field(ge=0)] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var max : int | None
var min : int | None
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Measurement (**data: Any)

Expand source code

class Measurement(AdCPBaseModel):
    metrics: Annotated[
        list[Metric],
        Field(
            description="Metrics this agent computes. Each entry is identified by `metric_id` within the vendor's vocabulary; the canonical reference everywhere a measurement value appears (`committed_metrics`, `vendor_metric_values`, `missing_metrics`) is the tuple `(vendor.domain, vendor.brand_id, metric_id)`.",
            min_length=1,
        ),
    ]

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var metrics : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Metric]
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class CapabilitiesMediaBuy (**data: Any)

Expand source code

class MediaBuy(AdCPBaseModel):
    supported_pricing_models: Annotated[
        list[SupportedPricingModel] | None,
        Field(
            description='Pricing models this seller supports across its product portfolio. Buyers can use this for pre-flight filtering before querying individual products. Individual products may support a subset of these models.',
            min_length=1,
        ),
    ] = None
    buying_modes: Annotated[
        list[BuyingMode] | None,
        Field(
            description="Buying modes this seller supports on get_products. 'brief' (semantic discovery driven by the brief) is universally supported and implicit. 'wholesale' (raw wholesale product feed enumeration — caller omits brief and the seller returns the full priced product feed, paginated) is opt-in and SHOULD be declared explicitly so buyers can probe before issuing wholesale calls. 'refine' lets buyers iterate on prior products/proposals and is also the vehicle for finalizing draft proposals when the seller returns them. Sellers MAY declare ['brief', 'wholesale'] to signal wholesale support; absent declaration is treated as ['brief'] for wholesale-feed probing purposes and sellers MAY return INVALID_REQUEST for wholesale calls they do not support. Symmetric with signals.discovery_modes.",
            min_length=1,
        ),
    ] = [BuyingMode.brief]
    reporting_delivery_methods: Annotated[
        list[ReportingDeliveryMethod] | None,
        Field(
            description="How this seller delivers reporting data to buyers. Polling via get_media_buy_delivery is always available as a baseline regardless of this field. This array declares additional push-based delivery methods the seller supports. 'webhook': seller pushes to buyer-provided URL (configured per buy via reporting_webhook). 'offline': seller pushes batch files to a cloud storage bucket (seller-provisioned per account via reporting_bucket on the account object). When absent, only polling is available.",
            min_length=1,
        ),
    ] = None
    offline_delivery_protocols: Annotated[
        list[OfflineDeliveryProtocol] | None,
        Field(
            description="Cloud storage protocols this seller supports for offline file delivery. Only meaningful when reporting_delivery_methods includes 'offline'. Buyers express a protocol preference in sync_accounts; the seller provisions the account's reporting_bucket using a supported protocol.",
            min_length=1,
        ),
    ] = None
    supports_proposals: Annotated[
        bool | None,
        Field(
            description="Conformance declaration that this seller supports the full proposal lifecycle on get_products: returned proposals are actionable, draft proposals can be finalized with buying_mode: 'refine' + action: 'finalize', and committed proposals can be executed via create_media_buy with proposal_id before expires_at. Buyers SHOULD NOT use this field to decide whether a specific returned proposal is executable; proposal_status is the per-proposal source of truth. A declaration of true opts the seller into proposal-lifecycle grading. When false or absent, conformance runners skip proposal-lifecycle storyboards, but buyers should still honor any proposals the seller actually returns."
        ),
    ] = False
    governance_aware: Annotated[
        bool | None,
        Field(
            description='Conformance declaration that this seller consults a registered governance agent (via sync_governance plus an outbound check_governance call) before committing a media buy, and surfaces GOVERNANCE_DENIED when the governance agent denies. A declaration of true opts the seller into governance-denial grading (media_buy_seller/governance_denied, media_buy_seller/governance_denied_recovery). When false or absent, conformance runners skip those storyboards - a seller that does not implement outbound governance consultation is not expected to produce GOVERNANCE_DENIED. This is independent of baseline sync_governance registration, which remains gradeable on its own.'
        ),
    ] = False
    propagation_surfaces: Annotated[
        list[PropagationSurface] | None,
        Field(
            description='Where this seller surfaces dependency-resource impairments (creative suspended/rejected post-approval, audience suspended, catalog item withdrawn, event source insufficient, property depublished) to buyers. Non-exclusive: a seller mirroring impairments on both the buy snapshot AND firing webhooks declares `["snapshot", "webhook"]` (the common case for premium guaranteed sellers). Each value names one surface where buyers can observe an impairment:\n\n- **`snapshot`** — seller propagates resource transitions into `media_buy.health` and `media_buy.impairments[]` on the next `get_media_buys` read. The `impairment.coherence` compliance assertion grades this surface; storyboards that exercise it (`media_buy_seller/dependency_impairment`, `media_buy_seller/dependency_impairment_cardinality`) require `"snapshot"` to be declared, else they grade `not_applicable`.\n- **`webhook`** — seller fires `notification-type: impairment` webhooks (configured via `push_notification_config`). Sellers declaring `"webhook"` MUST satisfy the persistent-channel webhook contract for the impairment event type. A seller declaring `["webhook"]` without `"snapshot"` is webhook-only — buyers reconcile state from the push channel alone, and snapshot-coherence storyboards grade `not_applicable`.\n- **`out_of_band`** — seller propagates via channels outside the AdCP protocol surface entirely (email to trafficker, separate dashboard, partner-specific notification feed). Long-tail and enterprise-bundled platforms commonly use this when impairment workflows are managed in human channels. Sellers declaring only `["out_of_band"]` are not graded by snapshot or webhook compliance — their bar is the offline agreement, not a protocol assertion. If a seller has impairment data in their API under a non-AdCP field name (a mapping gap, not truly out-of-band), they SHOULD document the mapping rather than declare `out_of_band` — the spec\'s gap, not the seller\'s posture, is what `out_of_band` legitimately covers.\n\nDefault: `["snapshot"]` when absent (preserves the existing snapshot-coherence contract for sellers that don\'t declare). Empty array `[]` is invalid (`minItems: 1`) — omit the field to inherit the default rather than declaring no surfaces. Pick the surfaces that honestly describe where buyers will see impairments on this agent. Mixing is normative — `["snapshot", "webhook"]` is the documented common case; `["snapshot", "webhook", "out_of_band"]` is valid for sellers that ship all three surfaces (rare but legal). See lifecycle.mdx § Compliance for the per-surface contract.',
            min_length=1,
        ),
    ] = [PropagationSurface.snapshot]
    creative_approval_mode: Annotated[
        CreativeApprovalMode | None,
        Field(
            description="Tenant-wide applicability signal for media-buy creative approval behavior. This is not a notification or new approval workflow. `auto_approve` means human review does not block serving eligibility after creatives are assigned and automated validation passes. `require_human` means one or more products/accounts may require manual review before creatives become eligible to serve; buyers and compliance runners MUST treat this as a worst-case ceiling across this seller's portfolio unless a future product-level override says otherwise. Compliance runners use this mainly to decide whether auto-approval-dependent storyboards apply. When absent, approval behavior is legacy-unspecified; runners SHOULD NOT treat omission as an affirmative auto-approval claim. `ai_assisted` is intentionally not part of the enum until a behavioral contract is defined."
        ),
    ] = None
    features: Annotated[
        Features | None,
        Field(
            description='Optional media-buy protocol features. Used in capability declarations (seller declares support) and product filters (buyer requires support). If a seller declares a feature as true, they MUST honor requests using that feature.',
            title='Media Buy Features',
        ),
    ] = None
    execution: Annotated[
        Execution | None, Field(description='Technical execution capabilities for media buying')
    ] = None
    audience_targeting: Annotated[
        AudienceTargeting | None,
        Field(
            description='Audience targeting capabilities. Presence of this object indicates the seller supports audience targeting, including sync_audiences and audience_include/audience_exclude in targeting overlays.'
        ),
    ] = None
    supported_optimization_metrics: Annotated[
        list[SupportedOptimizationMetric] | None,
        Field(
            description='Optimization metrics this seller can support on at least one of their products. Seller-level rollup of product-level metric_optimization.supported_metrics declarations (core/product.json). Buyers SHOULD filter their requested optimization goals against this list before submitting briefs. Sellers MUST keep this in sync with their product catalog — if no products support a metric, it must not appear here. Omitting this field means the seller declares no specific guarantees about which metrics they support; buyers should fall back to per-product inspection of metric_optimization.supported_metrics.',
            min_length=1,
        ),
    ] = None
    vendor_metric_optimization: Annotated[
        VendorMetricOptimization | None,
        Field(
            description='Seller-level rollup of vendor-metric optimization capabilities supported by at least one product. Product-level vendor_metric_optimization.supported_metrics[] remains authoritative for the specific (vendor, metric_id) pairs and target kinds a buyer may bind on a package; this seller-level object exists so buyers and compliance runners can discover whether vendor_metric goals are in scope before walking the catalog. Sellers MUST keep this in sync with product-level vendor_metric_optimization declarations.'
        ),
    ] = None
    conversion_tracking: Annotated[
        ConversionTracking | None,
        Field(
            description='Seller-level conversion tracking capabilities. Presence of this object indicates the seller supports sync_event_sources and log_event for conversion event tracking.'
        ),
    ] = None
    frequency_capping: Annotated[
        FrequencyCapping | None,
        Field(
            description='Frequency capping capabilities. Presence of this object indicates the seller honors targeting.frequency_cap on packages and MUST reject caps it cannot enforce rather than silently dropping them. Buyers SHOULD inspect supported_per_units and supported_window_units before submitting caps; sellers without these sub-fields populated MAY accept any reach-unit / duration-unit combination they can enforce. Per-product overrides (for sellers with mixed addressable/non-addressable inventory) are a likely follow-up — file a separate RFC if needed.'
        ),
    ] = None
    content_standards: Annotated[
        ContentStandards | None,
        Field(
            description='Content standards implementation details. Presence of this object indicates the seller supports content_standards configuration including sampling rates and category filtering. Gives buyers pre-buy visibility into local evaluation and artifact delivery capabilities. This is a seller-side media-buy capability; governance agents providing content standards services declare `specialisms: ["content-standards"]` instead.'
        ),
    ] = None
    portfolio: Annotated[
        Portfolio | None,
        Field(
            description="Information about the seller's media inventory portfolio. Expected for media_buy sellers — buyers use this to understand inventory coverage and verify authorization via adagents.json."
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var audience_targeting : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.AudienceTargeting | None
var buying_modes : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.BuyingMode] | None
var content_standards : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.ContentStandards | None
var conversion_tracking : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.ConversionTracking | None
var creative_approval_mode : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.CreativeApprovalMode | None
var execution : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Execution | None
var features : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Features | None
var frequency_capping : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.FrequencyCapping | None
var governance_aware : bool | None
var model_config
var offline_delivery_protocols : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.OfflineDeliveryProtocol] | None
var portfolio : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Portfolio | None
var propagation_surfaces : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.PropagationSurface] | None
var reporting_delivery_methods : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.ReportingDeliveryMethod] | None
var supported_optimization_metrics : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.SupportedOptimizationMetric] | None
var supported_pricing_models : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.SupportedPricingModel] | None
var supports_proposals : bool | None
var vendor_metric_optimization : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.VendorMetricOptimization | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Metric (**data: Any)

Expand source code

class Metric(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    metric_id: Annotated[
        str,
        Field(
            description="Identifier for the metric within the vendor's vocabulary. Combined with the agent's BrandRef, forms the canonical tuple `(vendor.domain, vendor.brand_id, metric_id)`. Each metric_id MUST be unique within a single agent's catalog.",
            examples=[
                'attention_units',
                'gco2e_per_impression',
                'demographic_reach',
                'co_view_index',
                'incremental_lift_percent',
            ],
            max_length=64,
            min_length=1,
            pattern='^[a-z][a-z0-9_]*$',
            title='Vendor Metric ID',
        ),
    ]
    standard_reference: Annotated[
        AnyUrl | None,
        Field(
            description='Optional URI pointing at the published standard this metric IMPLEMENTS (e.g., IAB Attention Measurement Guidelines, MRC Viewable Impression Measurement, GARM emissions framework). Distinct from `accreditations[]` — `standard_reference` is what the metric is built against; `accreditations[]` is third-party certification that the implementation actually conforms. Buyer agents normalizing across vendors SHOULD apply the AdCP URL canonicalization rules before comparing — vendors implementing the same standard MAY use different URL forms for the same canonical document.'
        ),
    ] = None
    accreditations: Annotated[
        list[Accreditation] | None,
        Field(
            description="Third-party accreditations this metric holds (MRC, ARF, JIC, ABC, BARB, AGOF, etc.). Distinct from `standard_reference`: a metric can implement a standard without being independently accredited. Buyers asking 'is this MRC-accredited?' SHOULD check this array, not just `standard_reference`. Each entry names the accrediting body and optionally pins a certification ID, validity date, and evidence URL."
        ),
    ] = None
    unit: Annotated[
        str | None,
        Field(
            description='Unit of the metric value when reported via `vendor_metric_values.value` (e.g., `score`, `seconds`, `persons`, `gCO2e`, `lift_percent`, `USD`). Buyers SHOULD render the unit alongside the value rather than computing units locally; sellers populating `vendor_metric_values.unit` MUST match this declaration when present.',
            examples=['score', 'seconds', 'persons', 'gCO2e', 'lift_percent', 'index', 'USD'],
        ),
    ] = None
    description: Annotated[
        str | None,
        Field(
            description='Human-readable description of what this metric measures and any relevant methodology notes. Surfaced in buyer-agent UX when explaining the metric to humans.'
        ),
    ] = None
    methodology_url: Annotated[
        AnyUrl | None,
        Field(
            description="URL to the vendor's full methodology documentation for this metric. Buyers SHOULD link or fetch this when human review of the methodology is in scope (compliance, RFP review, accreditation audit). Field name mirrors `governance.property_features[].methodology_url`."
        ),
    ] = None
    methodology_version: Annotated[
        str | None,
        Field(
            description='Optional version identifier (semver, ISO date, or vendor-defined version string) for the methodology this metric currently implements. When present, buyer agents pin the contracted version on `committed_metrics` so silent vendor methodology changes are detectable; absence means the vendor does not version their methodology and buyers MUST treat any change as untracked.',
            examples=['v2.1', '2026-Q1', '1.0'],
        ),
    ] = None
    ext: Annotated[
        dict[str, Any] | None,
        Field(
            description='Extension object for platform-specific, vendor-namespaced parameters. Extensions are always optional and must be namespaced under a vendor/platform key (e.g., ext.gam, ext.roku). Used for custom capabilities, partner-specific configuration, and features being proposed for standardization.',
            title='Extension Object',
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var accreditations : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Accreditation] | None
var description : str | None
var ext : dict[str, typing.Any] | None
var methodology_url : pydantic.networks.AnyUrl | None
var methodology_version : str | None
var metric_id : str
var model_config
var standard_reference : pydantic.networks.AnyUrl | None
var unit : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Modalities (**data: Any)

Expand source code

class Modalities(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    conversational: Annotated[
        bool | None, Field(description='Pure text exchange - the baseline modality')
    ] = True
    voice: Annotated[
        bool | Voice | None, Field(description='Audio-based interaction using brand voice')
    ] = None
    video: Annotated[bool | Video | None, Field(description='Brand video content playback')] = None
    avatar: Annotated[
        bool | Avatar | None, Field(description='Animated video presence with brand avatar')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var avatar : bool | adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Avatar | None
var conversational : bool | None
var model_config
var video : bool | adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Video | None
var voice : bool | adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Voice | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class NegativeKeywords (**data: Any)

Expand source code

class NegativeKeywords(AdCPBaseModel):
    supported_match_types: Annotated[
        list[MatchType],
        Field(
            description='Match types this seller supports for negative keywords. Sellers must reject goals with unsupported match types.',
            min_length=1,
        ),
    ]

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config
var supported_match_types : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.MatchType]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Portfolio (**data: Any)

Expand source code

class Portfolio(AdCPBaseModel):
    publisher_domains: Annotated[
        list[PublisherDomain],
        Field(
            description="Publisher domains this seller is authorized to represent. Buyers should fetch each publisher's adagents.json for property definitions.",
            min_length=1,
        ),
    ]
    primary_channels: Annotated[
        list[MediaChannel] | None,
        Field(description='Primary advertising channels in this portfolio'),
    ] = None
    primary_countries: Annotated[
        list[PrimaryCountry] | None,
        Field(description='Primary countries (ISO 3166-1 alpha-2) where inventory is concentrated'),
    ] = None
    description: Annotated[
        str | None,
        Field(
            description='Markdown-formatted description of the inventory portfolio', max_length=5000
        ),
    ] = None
    advertising_policies: Annotated[
        str | None,
        Field(
            description='Advertising content policies, restrictions, and guidelines',
            max_length=10000,
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var advertising_policies : str | None
var description : str | None
var model_config
var primary_channels : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.MediaChannel] | None
var primary_countries : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.PrimaryCountry] | None
var publisher_domains : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.PublisherDomain]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class RequestSigning (**data: Any)

Expand source code

class RequestSigning(AdCPBaseModel):
    supported: Annotated[
        bool,
        Field(
            description='Whether this agent verifies RFC 9421 signatures on incoming requests. When true, signatures present on requests are validated per the AdCP request-signing profile. When false or absent, signatures are ignored (requests are bearer-authenticated only).'
        ),
    ]
    covers_content_digest: Annotated[
        CoversContentDigest | None,
        Field(
            description="Policy for content-digest coverage in request signatures. 'required': signers MUST cover content-digest (body is bound to the signature); body-unbound signatures rejected with request_signature_components_incomplete. 'forbidden': signers MUST NOT cover content-digest; body-bound signatures rejected with request_signature_components_unexpected. This is an opt-out for the narrow case of legacy infrastructure that cannot preserve body bytes. 'either' (default): signer chooses per-request; verifier accepts both covered and uncovered forms. 'required' is recommended for spend-committing operations in production; 4.0 recommends 'required' for those operations."
        ),
    ] = CoversContentDigest.either
    required_for: Annotated[
        list[str] | None,
        Field(
            description="AdCP protocol operation names (e.g., 'create_media_buy') for which this agent rejects unsigned requests with request_signature_required. Not MCP tool names, A2A skill names, or any transport-specific rename — verifiers MUST NOT accept operation names that are not defined by the AdCP protocol spec. JSON-RPC protocol method names like `tasks/cancel` belong in `protocol_methods_required_for`, not here. Empty in 3.0 by default; sellers populate selectively during per-counterparty pilots. In 4.0 this list MUST include all spend-committing operations the agent supports (create_media_buy, acquire_*, etc.). Counterparties MUST sign any listed operation. Every operation listed MUST also appear in `supported_for` (an operation can't be required without being supported); see `x-adcp-validation`."
        ),
    ] = []
    warn_for: Annotated[
        list[str] | None,
        Field(
            description='AdCP protocol operation names for which this agent verifies signatures when present and logs failures but does NOT reject the request. Used as a shadow-mode bridge between supported_for and required_for: the verifier surfaces failure rates in monitoring before flipping an operation to required. Precedence: required_for > warn_for > supported_for. An operation in required_for ignores warn_for. Counterparties SHOULD sign operations in warn_for; verifiers MUST NOT reject if the signature is missing or invalid. An operation MUST NOT appear in both `warn_for` and `required_for`; see `x-adcp-validation`.'
        ),
    ] = []
    supported_for: Annotated[
        list[str] | None,
        Field(
            description='AdCP protocol operation names for which this agent verifies signatures when present but does not require them. Counterparties SHOULD sign operations in this list. Typically a superset of required_for and warn_for.'
        ),
    ] = None
    protocol_methods_supported_for: Annotated[
        list[ProtocolMethodsSupportedForItem] | None,
        Field(
            description="JSON-RPC protocol method names (e.g., 'tasks/cancel', 'tasks/get') for which this agent verifies signatures when present. Disjoint from `supported_for`, which carries AdCP tool names only. Counterparties SHOULD sign listed methods. The `tasks/*` family enumerated here matches the A2A 0.3.0 task-lifecycle methods (§7.x); future protocol additions extend this list, not `supported_for`. Items MUST be wire-format JSON-RPC method strings (containing `/`); plain AdCP tool names belong in `supported_for`.",
            validate_default=True,
        ),
    ] = []
    protocol_methods_warn_for: Annotated[
        list[ProtocolMethodsWarnForItem] | None,
        Field(
            description='Protocol method names for which this agent verifies signatures when present and logs failures but does NOT reject. Shadow-mode bridge between `protocol_methods_supported_for` and `protocol_methods_required_for`, mirroring `warn_for` semantics in the AdCP-tool namespace. An item MUST NOT appear in both `protocol_methods_warn_for` and `protocol_methods_required_for`; see `x-adcp-validation`.',
            validate_default=True,
        ),
    ] = []
    protocol_methods_required_for: Annotated[
        list[ProtocolMethodsRequiredForItem] | None,
        Field(
            description="JSON-RPC protocol method names for which this agent rejects unsigned requests with `request_signature_required`. Separate namespace from `required_for` (which carries AdCP tool names) so verifiers and storyboard runners don't conflate the two — an AdCP tool name and an A2A method name could in principle collide as bare strings, but the protocol_methods_* bucket binds the match against the JSON-RPC `method` field, not the `tools/call` `params.name`. Every method listed MUST also appear in `protocol_methods_supported_for`; see `x-adcp-validation`.",
            validate_default=True,
        ),
    ] = []

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var covers_content_digest : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.CoversContentDigest | None
var model_config
var protocol_methods_required_for : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.ProtocolMethodsRequiredForItem] | None
var protocol_methods_supported_for : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.ProtocolMethodsSupportedForItem] | None
var protocol_methods_warn_for : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.ProtocolMethodsWarnForItem] | None
var required_for : list[str] | None
var supported : bool
var supported_for : list[str] | None
var warn_for : list[str] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Signals (**data: Any)

Expand source code

class Signals(AdCPBaseModel):
    data_provider_domains: Annotated[
        list[DataProviderDomain] | None,
        Field(
            description="Data provider domains this signals agent is authorized to resell. Buyers should fetch each data provider's adagents.json for published signal definitions and to verify authorization.",
            min_length=1,
        ),
    ] = None
    discovery_modes: Annotated[
        list[DiscoveryMode] | None,
        Field(
            description="Discovery modes this signals agent supports on get_signals. 'brief' (default — every signals agent supports this): semantic discovery driven by signal_spec or signal_refs, with deprecated signal_ids accepted for older clients. 'wholesale': raw wholesale signals feed enumeration — caller omits signal_spec, signal_refs, and signal_ids and the agent returns its full priced signals feed, paginated, scoped by filters/account/destinations/countries. Agents that do not declare 'wholesale' MAY return INVALID_REQUEST for wholesale calls. Absent declaration is treated as ['brief'].",
            min_length=1,
        ),
    ] = [DiscoveryMode.brief]
    features: Annotated[
        Features1 | None, Field(description='Optional signals features supported')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var data_provider_domains : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.DataProviderDomain] | None
var discovery_modes : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.DiscoveryMode] | None
var features : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Features1 | None
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Specialism (*args, **kwds)

Expand source code

class Specialism(StrEnum):
    audience_sync = 'audience-sync'
    brand_rights = 'brand-rights'
    collection_lists = 'collection-lists'
    content_standards = 'content-standards'
    creative_ad_server = 'creative-ad-server'
    creative_generative = 'creative-generative'
    creative_template = 'creative-template'
    creative_transformers = 'creative-transformers'
    governance_aware_seller = 'governance-aware-seller'
    governance_delivery_monitor = 'governance-delivery-monitor'
    governance_spend_authority = 'governance-spend-authority'
    property_lists = 'property-lists'
    sales_broadcast_tv = 'sales-broadcast-tv'
    sales_catalog_driven = 'sales-catalog-driven'
    sales_guaranteed = 'sales-guaranteed'
    sales_non_guaranteed = 'sales-non-guaranteed'
    sales_proposal_mode = 'sales-proposal-mode'
    sales_social = 'sales-social'
    signal_marketplace = 'signal-marketplace'
    signal_owned = 'signal-owned'
    signed_requests = 'signed-requests'
    sponsored_intelligence = 'sponsored-intelligence'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var audience_sync
var brand_rights
var collection_lists
var content_standards
var creative_ad_server
var creative_generative
var creative_template
var creative_transformers
var governance_aware_seller
var governance_delivery_monitor
var governance_spend_authority
var property_lists
var sales_broadcast_tv
var sales_catalog_driven
var sales_guaranteed
var sales_non_guaranteed
var sales_proposal_mode
var sales_social
var signal_marketplace
var signal_owned
var signed_requests
var sponsored_intelligence

class SponsoredIntelligence (**data: Any)

Expand source code

class SponsoredIntelligence(AdCPBaseModel):
    endpoint: Annotated[Endpoint, Field(description='SI agent endpoint configuration')]
    capabilities: Annotated[
        Capabilities,
        Field(
            description='Modalities, components, and commerce capabilities', title='SI Capabilities'
        ),
    ]
    brand_url: Annotated[
        AnyUrl | None, Field(description='URL to brand.json with colors, fonts, logos, tone')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var brand_url : pydantic.networks.AnyUrl | None
var capabilities : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Capabilities
var endpoint : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Endpoint
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class SupportedProtocol (*args, **kwds)

Expand source code

class SupportedProtocol(StrEnum):
    media_buy = 'media_buy'
    signals = 'signals'
    governance = 'governance'
    sponsored_intelligence = 'sponsored_intelligence'
    creative = 'creative'
    brand = 'brand'
    measurement = 'measurement'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var brand
var creative
var governance
var measurement
var media_buy
var signals
var sponsored_intelligence

class Targeting (**data: Any)

Expand source code

class Targeting(AdCPBaseModel):
    geo_countries: Annotated[
        bool | None, Field(description='Country-level targeting using ISO 3166-1 alpha-2 codes')
    ] = None
    geo_regions: Annotated[
        bool | None,
        Field(
            description='Region/state-level targeting using ISO 3166-2 codes (e.g., US-NY, GB-SCT)'
        ),
    ] = None
    geo_metros: Annotated[
        GeoMetros | None,
        Field(
            description='Metro area targeting. Properties indicate which classification systems are supported.'
        ),
    ] = None
    geo_postal_areas: Annotated[
        GeoPostalAreas | None,
        Field(
            description='Declares supported postal area systems. Native support is keyed by ISO 3166-1 alpha-2 country with arrays of country-local postal systems. Deprecated country-fused boolean aliases may be included during migration.',
            title='Postal Area Support',
        ),
    ] = None
    age_restriction: Annotated[
        AgeRestriction | None,
        Field(description='Age restriction capabilities for compliance (alcohol, gambling)'),
    ] = None
    language: Annotated[
        bool | None,
        Field(description='Whether seller supports language targeting (ISO 639-1 codes)'),
    ] = None
    keyword_targets: Annotated[
        KeywordTargets | None,
        Field(
            description='Keyword targeting capabilities. Presence indicates support for targeting_overlay.keyword_targets and keyword_targets_add/remove in update_media_buy.'
        ),
    ] = None
    negative_keywords: Annotated[
        NegativeKeywords | None,
        Field(
            description='Negative keyword capabilities. Presence indicates support for targeting_overlay.negative_keywords and negative_keywords_add/remove in update_media_buy.'
        ),
    ] = None
    geo_proximity: Annotated[
        GeoProximity | None,
        Field(
            description='Proximity targeting capabilities from arbitrary coordinates via targeting_overlay.geo_proximity.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var age_restriction : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.AgeRestriction | None
var geo_countries : bool | None
var geo_metros : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.GeoMetros | None
var geo_postal_areas : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.GeoPostalAreas | None
var geo_proximity : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.GeoProximity | None
var geo_regions : bool | None
var keyword_targets : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.KeywordTargets | None
var language : bool | None
var model_config
var negative_keywords : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.NegativeKeywords | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Transport (**data: Any)

Expand source code

class Transport(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    type: Annotated[Type9, Field(description='Protocol transport type')]
    url: Annotated[AnyUrl, Field(description='Agent endpoint URL for this transport')]

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config
var type : adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Type9
var url : pydantic.networks.AnyUrl

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class TrustedMatch (**data: Any)

Expand source code

class TrustedMatch(AdCPBaseModel):
    surfaces: Annotated[
        list[Surface] | None, Field(description='Surface types this seller supports via TMP.')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config
var surfaces : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Surface] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Video (**data: Any)

Expand source code

class Video(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    formats: Annotated[
        list[str] | None, Field(description='Supported video formats (mp4, webm, etc.)')
    ] = None
    max_duration_seconds: Annotated[int | None, Field(description='Maximum video duration')] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var formats : list[str] | None
var max_duration_seconds : int | None
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Voice (**data: Any)

Expand source code

class Voice(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    provider: Annotated[
        str | None, Field(description='TTS provider (elevenlabs, openai, etc.)')
    ] = None
    voice_id: Annotated[str | None, Field(description='Brand voice identifier')] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config
var provider : str | None
var voice_id : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class WebhookSigning (**data: Any)

Expand source code

class WebhookSigning(AdCPBaseModel):
    supported: Annotated[
        bool,
        Field(
            description='Whether this agent signs outbound webhooks with the AdCP RFC 9421 webhook profile. When false or absent, webhooks are delivered with legacy Bearer or HMAC-SHA256 auth only and receivers MUST NOT expect a Signature header. When the seller advertises mutating-webhook emission (i.e., `media_buy.reporting_delivery_methods` includes `webhook`, `media_buy.content_standards.supports_webhook_delivery` is true, or `wholesale_feed_webhooks.supported` is true), this MUST be `true` — emitting state-changing webhooks unsigned is a downgrade vector that lets an on-path attacker forge delivery callbacks. See `x-adcp-validation`.'
        ),
    ]
    profile: Annotated[
        Literal['adcp/webhook-signing/v1'] | None,
        Field(
            description='Identifier of the webhook-signing profile version the agent emits. Value MUST match the `tag=` parameter emitted in the RFC 9421 `Signature-Input` header (see docs/building/implementation/webhooks.mdx) so receivers can statically validate the declared profile against the on-wire tag. Closed enum; future profile revisions will extend this enum in a follow-up schema bump.'
        ),
    ] = None
    algorithms: Annotated[
        list[Algorithm] | None,
        Field(
            description="Signature algorithms this agent uses on outbound webhooks. 3.0 profile permits 'ed25519' and 'ecdsa-p256-sha256' only; other values are reserved for future profile versions and MUST NOT be emitted under adcp/webhook-signing/v1.",
            min_length=1,
        ),
    ] = None
    legacy_hmac_fallback: Annotated[
        bool | None,
        Field(
            description='Whether this agent will fall back to HMAC-SHA256 on the legacy push_notification_config.authentication or accounts[].notification_configs[].authentication paths for receivers that have not adopted RFC 9421. Deprecated; removed in AdCP 4.0.'
        ),
    ] = False

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Class variables

var algorithms : list[adcp.types.generated_poc.bundled.protocol.get_adcp_capabilities_response.Algorithm] | None
var legacy_hmac_fallback : bool | None
var model_config
var profile : Literal['adcp/webhook-signing/v1'] | None
var supported : bool

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary