Module `adcp.types.domains.protocol.get_adcp_capabilities_response`

Classes

class AcceptancePolicyDiscovery (**data: Any)

Expand source code

class AcceptancePolicyDiscovery(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    catalog_url: Annotated[
        AnyUrl,
        Field(description='HTTPS document that validates against acceptance-policy-catalog.json.'),
    ]
    catalog_digest: Annotated[
        str,
        Field(
            description='SHA-256 digest of the exact catalog representation fetched from catalog_url.',
            pattern='^sha256:[a-f0-9]{64}$',
        ),
    ]
    default_profile_ids: Annotated[
        list[DefaultProfileId] | None,
        Field(
            description='Local or registry-referenced catalog profiles that apply seller-wide unless a product adds further profiles. IDs MUST resolve uniquely across profiles and registry_profiles; all referenced profiles compose restrictively.',
            min_length=1,
        ),
    ] = 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 catalog_digest : str
var catalog_url : pydantic.networks.AnyUrl
var default_profile_ids : list[DefaultProfileId] | None
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class AccessMode (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class AccessMode(Transport):
    pass

A str generated from a JSON Schema string root.

Ancestors

Transport
adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class Account (**data: Any)

Expand source code

class Account(AdCPBaseModel):
    require_operator_auth: Annotated[
        StrictBool | 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/storefront-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 and account-scoped calls use the advertiser natural key: brand + operator + optional operator_unit, fixed currency, optional buyer-selected account timezone, and sandbox. operator_unit.id is owned by the operator and is distinct from the seller's account_id. The seller normally provisions through sync_accounts, but MAY lazily provision on the first account-scoped request when billing and other required settings are unambiguous from capabilities or onboarding defaults. A lazy-provisioning seller MUST keep accepting the natural key and MUST expose list_accounts for recovery; if buyer input is needed before use, the seller MUST expose sync_accounts."
        ),
    ] = 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[billing_party.BillingParty],
        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. When the buyer calls sync_accounts, it must pass one of these values. A lazy-provisioning seller may omit sync_accounts only when billing can be resolved unambiguously from this capability or the authenticated agent's onboarding defaults.",
            min_length=1,
        ),
    ]
    supported_account_currency_modes: Annotated[
        list[account_currency_mode.AccountCurrencyMode] | None,
        Field(
            description='Required for sellers implementing AdCP 3.2 advertiser-account provisioning, but optional in this shared 3.x response schema so existing 3.0 and 3.1 capability responses remain valid. Declares whether advertiser accounts are bound to one immutable currency (`fixed`), select currency independently per proposal or media buy (`per_media_buy`), or support both models. When only `fixed` is advertised, buyer-declared provisioning entries MUST include `currency`. When only `per_media_buy` is advertised, they MUST omit it. When both are advertised, presence of `currency` selects a fixed-currency account and omission selects per-media-buy currency. Buyers MUST treat absence as an older seller whose currency mode is not discoverable, not as support for either mode.',
            min_length=1,
        ),
    ] = None
    timezone: Annotated[
        account_timezone_capability.AccountTimezoneCapability | None,
        Field(
            description='Required for sellers implementing AdCP 3.2 advertiser-account provisioning, but optional in the shared 3.x response schema for compatibility. Declares whether the account timezone is seller-wide or fixed per account and whether a buyer must select it during sync_accounts provisioning. Account timezone is the default for account-scoped calendar semantics; feature-specific capability fields explicitly declare exceptions.'
        ),
    ] = None
    required_for_products: Annotated[
        StrictBool | 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[
        StrictBool | 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
    notifications: Annotated[
        Notifications2 | Notifications3 | None,
        Field(
            description='Whether the seller supports durable account-lifecycle webhooks through account-level `notification_configs[]`. This capability is specifically for account status changes such as approval, rejection, payment-required, suspension, recovery, and closure. When supported, buyers register subscribers with `sync_accounts.accounts[].notification_configs[]`; each `account.status_changed` fire is an invalidation payload, and buyers repair by re-reading `list_accounts` for the account_id.'
        ),
    ] = None
    change_feed: Annotated[
        ChangeFeed | ChangeFeed1 | None,
        Field(
            description='Whether the seller exposes a durable, ordered feed of material changes to authoritative account-scoped state. This is distinct from webhook_activity transport diagnostics and from current-state reads. Sellers claiming support MUST retain changes for at least 90 days after recording and MUST produce records regardless of whether a mutation originated through AdCP, a seller surface, another authorized principal, seller automation, or a connected platform within declared coverage. Experimental in 3.2 (RFC #6810): sellers advertising supported: true MUST list account.change_feed in experimental_features.'
        ),
    ] = None
    identity_updates: Annotated[
        IdentityUpdates | IdentityUpdates1 | None,
        Field(
            description='Whether the seller accepts buyer-desired operator identity reconciliation through sync_accounts settings-update entries. Sellers declaring support expose the exact identity transitions they implement, MUST return account revisions from sync_accounts and list_accounts, and MUST return identity_change_preview for dry-run identity updates.'
        ),
    ] = None
    sandbox: Annotated[
        StrictBool | None,
        Field(
            description='Whether this seller supports sandbox accounts for testing. Buyer-declared accounts use sandbox: true in sync_accounts or, for an unambiguous lazy-provisioning seller, in the natural-key account reference. 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 change_feed : ChangeFeed | ChangeFeed1 | None
var identity_updates : IdentityUpdates | IdentityUpdates1 | None
var model_config
var notifications : Notifications2 | Notifications3 | None
var require_operator_auth : bool | None
var required_for_products : bool | None
var sandbox : bool | None
var supported_account_currency_modes : list[AccountCurrencyMode] | None
var supported_billing : list[BillingParty]
var timezone : AccountTimezoneCapability | None

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 | 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(
            deprecated=True,
            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.'
        ),
    ]
    principal: Annotated[
        Principal | None,
        Field(
            description='Caller-scoped durable connection configuration accepted by this agent. This is the buyer-to-seller configuration half of negotiation, not a second seller capability document: the seller advertises its objective offering here, while each authenticated caller submits its desired webhooks and reusable destinations through sync_principal and reads them back through get_principal. Per-account authority and feed selection remain in account/reporting configuration. Sellers exposing this block MUST list protocol.principal in experimental_features.'
        ),
    ] = None
    capability_changes: Annotated[
        CapabilityChanges | None,
        Field(
            description='Freshness metadata and optional invalidation webhooks for this `get_adcp_capabilities` document. Buyers and registries MAY cache capabilities for up to `cache_ttl_seconds` when present, SHOULD compare `capabilities_version` across refreshes when present, and SHOULD re-run `get_adcp_capabilities` after receiving a `capabilities.changed` webhook. This block describes the agent-wide capability document, not per-caller authorization or account-scoped settings. A material capability change is any externally advertised contract change that can affect routing, validation, conformance coverage, task availability, auth/account handling, sandbox support, billing support, reporting delivery methods, creative-library support, targeting support, protocol versions, or other buyer-visible feature gates. Non-contract operational changes that do not alter the response body do not require a revision or webhook fire.'
        ),
    ] = None
    governance_enforcement: Annotated[
        GovernanceEnforcement | None,
        Field(
            description='Cross-role declaration that this agent enforces buyer-provided governance authorization when performing consequential tasks. This is distinct from the top-level `governance` capability block, which describes an agent that provides governance services. An agent can enforce governance without implementing the governance protocol itself. Absence means the agent makes no governance-enforcement conformance claim.'
        ),
    ] = None
    attestations: Annotated[
        attestation_capabilities.AttestationCapabilities | None,
        Field(
            description='Portable-attestation trust and delivery capabilities for this evaluator. Present only when the agent accepts AttestationReference inputs on one or more domain task surfaces. This block is an allowlist: presenters cannot expand accepted issuers, resolver endpoints, verifier agents, claim types, or proof formats by supplying values in a request.'
        ),
    ] = 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 attestations : AttestationCapabilities | None
var build_version : str | None
var capability_changes : CapabilityChanges | None
var governance_enforcement : GovernanceEnforcement | None
var idempotency : Idempotency | Idempotency1
var major_versions : list[MajorVersion]
var model_config
var principal : Principal | None
var supported_versions : list[SupportedVersion] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class AgeRestriction (**data: Any)

Expand source code

class AgeRestriction(AdCPBaseModel):
    supported: Annotated[
        StrictBool | None, Field(description='Whether seller supports age restrictions')
    ] = None
    verification_methods: Annotated[
        list[age_verification_method.AgeVerificationMethod] | 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[AgeVerificationMethod] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Algorithm (*args, **kwds)

Expand source code

class Algorithm(StrEnum):
    ed25519 = 'ed25519'
    ecdsa_p256_sha256 = 'ecdsa-p256-sha256'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var ecdsa_p256_sha256
var ed25519

class AttributionWindow (**data: Any)

Expand source code

class AttributionWindow(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    event_type: Annotated[
        event_type_1.EventType | None,
        Field(description='Event type this window applies to, or omit for default window'),
    ] = None
    post_click: Annotated[
        list[duration.Duration],
        Field(
            description='Available post-click attribution windows (e.g. [{"interval": 7, "unit": "days"}])',
            min_length=1,
        ),
    ]
    post_view: Annotated[
        list[duration.Duration] | 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 : EventType | None
var model_config
var post_click : list[Duration]
var post_view : list[Duration] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class AudienceEvidence (**data: Any)

Expand source code

class AudienceEvidence(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported_requirement_modes: Annotated[
        list[SupportedRequirementMode],
        Field(
            description='Buyer policy modes the seller evaluates. A seller MUST NOT silently ignore a mode it does not list.',
            min_length=1,
        ),
    ]
    supported_presence_modes: Annotated[
        list[SupportedPresenceMode],
        Field(description='Evidence-presence semantics the seller supports.', min_length=1),
    ]
    supports_attestation_evaluation: Annotated[
        StrictBool,
        Field(
            description='Whether the seller evaluates audience-evidence attestation_refs under its core adcp.attestations policy and returns the exact reference and AttestationEvaluation in package readback.'
        ),
    ]

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_presence_modes : list[SupportedPresenceMode]
var supported_requirement_modes : list[SupportedRequirementMode]
var supports_attestation_evaluation : bool

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[
        StrictBool | 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[uid_type.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[
        SchemaInt,
        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,
        ),
    ]
    supported_activation_methods: Annotated[
        list[audience_activation_method.AudienceActivationMethod] | None,
        Field(
            description="Union of audience_activation.methods across the seller's products. Fast-fail discovery: a buyer reads this once and skips the catalog walk when nothing overlaps its pipeline. Per-product declarations are the source of truth; sellers MUST keep this consistent with the catalog. Operational coordinates are account-scoped: the union MAY omit consumer_identities and destination_ref until bilateral account setup establishes them, and MUST NOT expose another account's coordinates. Absence of this field with media_buy.audience_activation listed in experimental_features means walk the catalog; only a present, non-overlapping union is a fast-fail signal. Experimental (x-status: experimental): sellers implementing audience activation declarations MUST list media_buy.audience_activation in experimental_features. Per docs/reference/experimental-status, this surface MAY change between 3.x releases with notice.",
            min_length=1,
        ),
    ] = None
    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 : MatchingLatencyHours | None
var minimum_audience_size : int
var model_config
var supported_activation_methods : list[AudienceActivationMethod1 | AudienceActivationMethod2 | AudienceActivationMethod3 | AudienceActivationMethod4 | AudienceActivationMethod5 | AudienceActivationMethod6] | None
var supported_identifier_types : list[SupportedIdentifierType]
var supported_uid_types : list[UidType] | None
var supports_platform_customer_id : bool | 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[
        StrictBool | None,
        Field(
            description='Supports get_rights and acquire_rights for rights discovery and clearance'
        ),
    ] = False
    right_types: Annotated[
        list[right_type.RightType] | None,
        Field(description='Types of rights available through this agent'),
    ] = None
    available_uses: Annotated[
        list[right_use.RightUse] | 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[RightUse] | None
var description : str | None
var generation_providers : list[str] | None
var model_config
var right_types : list[RightType] | None
var rights : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class BudgetCapping (**data: Any)

Expand source code

class BudgetCapping(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported_scopes: Annotated[
        list[SupportedScope],
        Field(
            description='Scopes where the seller enforces hard daily caps. media_buy bounds aggregate spend across all packages without allocating it. package bounds one package and remains subordinate to any aggregate cap.',
            min_length=1,
        ),
    ]
    supported_periods: Annotated[
        list[Literal['day']],
        Field(
            description='Cap reset periods the seller enforces. AdCP 3.2 defines day only; the array form reserves room for future periods as an additive change.',
            min_length=1,
        ),
    ]
    timezone_basis: Annotated[
        BudgetCappingTimezoneBasis,
        Field(
            description='Source of the default cap-day boundary. account uses the selected Account.timezone and therefore supports different boundaries for different accounts. fixed uses fixed_timezone for every media buy regardless of account timezone.'
        ),
    ]
    fixed_timezone: Annotated[
        str | None,
        Field(
            description='Feature-specific default cap-day timezone used when timezone_basis is fixed. Use UTC or an IANA timezone identifier.',
            min_length=1,
        ),
    ] = None
    buyer_timezone_override: Annotated[
        StrictBool | None,
        Field(
            description='When true, buyers MAY override the default cap-day boundary via media-buy-level budget_cap_timezone. The accepted timezone applies to aggregate and package caps alike. When false or absent, a submitted override is rejected with UNSUPPORTED_FEATURE.'
        ),
    ] = 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 buyer_timezone_override : bool | None
var fixed_timezone : str | None
var model_config
var supported_periods : list[typing.Literal['day']]
var supported_scopes : list[SupportedScope]
var timezone_basis : BudgetCappingTimezoneBasis

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class BudgetCappingTimezoneBasis (*args, **kwds)

Expand source code

class BudgetCappingTimezoneBasis(StrEnum):
    account = 'account'
    fixed = 'fixed'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var account
var fixed

class BuyingMode (*args, **kwds)

Expand source code

class BuyingMode(StrEnum):
    brief = 'brief'
    wholesale = 'wholesale'
    refine = 'refine'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var brief
var refine
var wholesale

class CapabilityChanges (**data: Any)

Expand source code

class CapabilityChanges(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    capabilities_version: Annotated[
        str | None,
        Field(
            description='Opaque revision token for the full capability document. Required when `notifications.supported: true` because `capabilities.changed` webhooks use this as the read-after-notify fence. Sellers SHOULD change this value whenever any material field in `get_adcp_capabilities` changes. Buyers MUST treat it as opaque and compare it only for equality.',
            max_length=255,
            min_length=1,
        ),
    ] = None
    last_modified: Annotated[
        AwareDatetime | None,
        Field(
            description='ISO 8601 timestamp when the seller last changed the advertised capability document. This is the scoped replacement for legacy top-level `last_updated` when buyers need cache validation semantics.'
        ),
    ] = None
    cache_ttl_seconds: Annotated[
        SchemaInt | None,
        Field(
            description='Maximum time a buyer or registry SHOULD reuse this capability response before refreshing when it has no fresher invalidation signal. Sellers that emit `capabilities.changed` webhooks SHOULD still set a bounded TTL so consumers can recover from missed notifications. This is a cache hint, not an authorization lifetime.',
            ge=60,
            le=604800,
        ),
    ] = None
    notifications: Annotated[
        Notifications | Notifications1 | None,
        Field(
            description='Whether the seller supports agent-level capability-change webhooks. When supported, interested consumers register endpoint subscribers with the declared registration_task; sync_principal is preferred when the broader connection surface is available, while sync_agent_notification_configs remains the specialized compatibility task. Each capabilities.changed fire is a small invalidation payload, and consumers repair by re-reading get_adcp_capabilities.'
        ),
    ] = 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 cache_ttl_seconds : int | None
var capabilities_version : str | None
var last_modified : pydantic.types.AwareDatetime | None
var model_config
var notifications : Notifications | Notifications1 | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class CapabilityReportingDeliveryMethod (*args, **kwds)

Expand source code

class CapabilityReportingDeliveryMethod(StrEnum):
    webhook = 'webhook'
    offline = 'offline'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var offline
var webhook

class ChangeFeed (**data: Any)

Expand source code

class ChangeFeed(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported: Literal[True]
    read_task: Literal['list_account_changes'] = 'list_account_changes'
    registration_task: Literal['sync_accounts'] = 'sync_accounts'
    event_type: Literal['account.change_recorded'] = 'account.change_recorded'
    retention_days: Annotated[
        SchemaInt,
        Field(
            description='Minimum number of days committed change records remain readable.', ge=90
        ),
    ]
    resource_types: Annotated[
        list[ResourceType],
        Field(
            description='Resource families for which this seller can produce change records. Account-specific connected-source status and freshness are returned by list_account_changes.',
            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 event_type : Literal['account.change_recorded']
var model_config
var read_task : Literal['list_account_changes']
var registration_task : Literal['sync_accounts']
var resource_types : list[ResourceType]
var retention_days : int
var supported : Literal[True]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ChangeFeed1 (**data: Any)

Expand source code

class ChangeFeed1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported: Literal[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 model_config
var supported : Literal[False]

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 CompromiseNotification (**data: Any)

Expand source code

class CompromiseNotification(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    emits: Annotated[
        StrictBool | None,
        Field(description='Whether this agent emits `identity.compromise_notification` events.'),
    ] = False
    accepts: Annotated[
        StrictBool | 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 ContentStandards (**data: Any)

Expand source code

class ContentStandards(AdCPBaseModel):
    supports_local_evaluation: Annotated[
        StrictBool | 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[channels.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[
        StrictBool | 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[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[
        StrictBool | 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[
        StrictBool | 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[event_type_1.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[uid_type.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[action_source.ActionSource] | 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[AttributionWindow] | None
var model_config
var multi_source_event_dedup : bool | None
var per_creative_attribution : bool | None
var supported_action_sources : list[ActionSource] | None
var supported_event_types : list[EventType] | None
var supported_hashed_identifiers : list[SupportedIdentifierType] | None
var supported_targets : list[SupportedTarget1] | None
var supported_uid_types : list[UidType] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class CoversContentDigest (*args, **kwds)

Expand source code

class CoversContentDigest(StrEnum):
    required = 'required'
    forbidden = 'forbidden'
    either = 'either'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var either
var forbidden
var required

class Creative (**data: Any)

Expand source code

class Creative(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supports_compliance: Annotated[
        StrictBool | 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[
        StrictBool | 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_revisions: Annotated[
        StrictBool | None,
        Field(
            description='When true, this agent accepts buyer-assigned revision_id on sync_creatives, enforces immutable revision content, echoes accepted revision identity, returns it from list_creatives, and attributes delivered executions to it. Revision support does not imply revision history, rollback, or staged activation.'
        ),
    ] = False
    supports_generation: Annotated[
        StrictBool | 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[
        StrictBool | None,
        Field(
            description='When true, this agent can transform or resize existing canonical manifests via build_creative. The buyer supplies a creative_manifest and an advertised target_capability_id.'
        ),
    ] = False
    representation_resolution: Annotated[
        RepresentationResolution | None,
        Field(
            description='Explicit opt-in for deterministic seller-bound selection from `build_creative.creative_representation_set`. Only the destination sales agent may advertise and exercise this capability because resolution requires its current product, placement/publisher narrowings, and seller-wide execution ceilings. A standalone creative agent may help a buyer select locally but MUST NOT advertise this capability or claim seller deliverability. Absence means the caller selects a representation before sending a seller-bound manifest; the agent MUST NOT guess silently.'
        ),
    ] = None
    supports_transformers: Annotated[
        StrictBool | 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[
        StrictBool | 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[
        StrictBool | 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[
        StrictBool | 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[
        SchemaInt | 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-format capability catalog for this creative agent. This is the 3.2 source of truth for discovering which format contracts the agent can build, validate, or preview; it replaces the deprecated `list_creative_formats` task. Each entry uses the authority-free `CreativeOperationFormatDeclaration` projection of a product format declaration: canonical shape and creative-route macro processing are preserved, while seller production commitments are excluded. New 3.2 producers MUST publish a stable agent-local `capability_id` and explicit `operations` for task routing. Every emitted `capability_id` MUST be unique within this catalog so a route selects exactly one entry. During the 3.x compatibility window, consumers MUST also accept legacy entries that omit either field; absent `operations` means `["build"]`, while an absent `capability_id` means the entry is discoverable by canonical contract but cannot be selected through a capability-ID route.\n\n**Publisher-specific support.** To claim exact support for a publisher declaration, `format` carries the declaration\'s `{publisher_domain, format_option_id}` pair plus its canonical `format_kind` and narrowed `params`. Generic creative agents MAY instead advertise a canonical parameter envelope without publisher identity. A generic capability matches a target declaration only when the capability can satisfy every target constraint; matching canonical names alone is insufficient. Registries MAY reverse-index these entries by `format.format_kind`, `format.publisher_domain`, and `format.format_option_id`.\n\nThis catalog describes creative operations, not sales-agent inventory deliverability. Sales agents publish the purchasable closed set on each `Product.format_options[]`; publisher acceptance lives in `adagents.json.formats[]`.'
        ),
    ] = None
    preview: Annotated[
        Preview | None,
        Field(
            description='Per-route preview_creative capability metadata. New 3.2 producers whose supported_formats[] explicitly advertises a routable preview operation MUST emit this block. rendering_origin describes how each route is implemented but is informational and never grants presentation authority: only a matching publisher-origin placement preview_provider delegation can do that. routes[].capability_id MUST equal the set of capability IDs on supported_formats[] entries whose operations contains preview.'
        ),
    ] = None
    localization: Annotated[
        Localization | None,
        Field(
            description='Materialized creative-localization support for sync_creatives/list_creatives, including source-only monolingual topology. Presence opts the agent into exact locale-variant round-trip, strict RFC 4647 Lookup, optional buyer-declared language-family fallback rules, explicit final default/unmatched behavior, creative-wide review, transactional replacement, seller product-format locale-policy enforcement, and delivery attribution. This is a coarse structural capability, not a promise that every locale/format/account combination is accepted; sellers publish accepted ranges on product format declarations and validate each write before mutation. Omit this object when localization is unsupported.'
        ),
    ] = None
    bills_through_adcp: Annotated[
        StrictBool | 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 localization : Localization | None
var model_config
var multiplicity : Multiplicity | None
var preview : Preview | None
var refinable_retention_seconds : int | None
var representation_resolution : RepresentationResolution | None
var supported_formats : list[SupportedFormat] | None
var supports_compliance : bool | None
var supports_evaluator : bool | None
var supports_generation : bool | None
var supports_refinement : bool | None
var supports_revisions : 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 CreativeApprovalMode (*args, **kwds)

Expand source code

class CreativeApprovalMode(StrEnum):
    auto_approve = 'auto_approve'
    require_human = 'require_human'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var auto_approve
var require_human

class CreativeFeature (**data: Any)

Expand source code

class CreativeFeature(AdCPBaseModel):
    feature_id: Annotated[
        str,
        Field(
            description="Unique identifier for this feature (e.g., 'auto_redirect', 'brand_consistency', 'iab_casinos_gambling')"
        ),
    ]
    type: Annotated[
        Type,
        Field(
            description="Data type: 'binary' for yes/no, 'quantitative' for numeric scores, 'categorical' for enum values"
        ),
    ]
    range: Annotated[
        Range | None, Field(description='For quantitative features, the valid range')
    ] = None
    categories: Annotated[
        list[str] | None, Field(description='For categorical features, the valid values')
    ] = None
    description: Annotated[
        str | None, Field(description='Human-readable description of what this feature measures')
    ] = None
    methodology_url: Annotated[
        AnyUrl | None,
        Field(
            description='URL to documentation explaining how this feature is calculated or measured.'
        ),
    ] = 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 categories : list[str] | None
var description : str | None
var feature_id : str
var methodology_url : pydantic.networks.AnyUrl | None
var model_config
var range : Range | None
var type : Type

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class CreativeSpecs (**data: Any)

Expand source code

class CreativeSpecs(AdCPBaseModel):
    vast_versions: Annotated[
        list[vast_version.VastVersion] | None,
        Field(
            description='Seller-wide VAST execution ceiling. Each product format option declares its binding accepted subset in `params.vast_versions`.',
            min_length=1,
        ),
    ] = None
    macro_resolution_capabilities: Annotated[
        list[macro_resolution_capability.MacroProcessingCapability] | None,
        Field(
            description='Seller-wide ceiling for exact macro processing tuples (dialect identity/revision, semantic mapping, operation, actor, context, and encoding). It never proves a product execution path supports the same tuple and does not claim tracker firing; inspect the selected format option and, when standardized, product tracker capabilities.',
            min_length=1,
        ),
    ] = None
    mraid_versions: Annotated[
        list[MraidVersion] | None,
        Field(description='MRAID versions supported for rich media mobile creatives'),
    ] = None
    vpaid: Annotated[
        StrictBool | None, Field(description='VPAID support for interactive video ads')
    ] = None
    simid: Annotated[
        StrictBool | None, Field(description='SIMID support for interactive video ads')
    ] = None
    vast_validation: Annotated[
        VastValidation | None,
        Field(
            description="Level of VAST asset validation the seller performs at sync_creatives (including dry_run): 'structural' checks manifest shape and format requirements only and never inspects the VAST document; 'document' additionally parses the VAST document and can return VAST_PARSE_FAILED / VAST_VERSION_MISMATCH; 'wrapper' additionally resolves the wrapper chain and can return VAST_WRAPPER_DEPTH_EXCEEDED. Absent means 'structural'. See the VAST Validation section of the video channel documentation for the normative checks at each level."
        ),
    ] = VastValidation.structural

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 macro_resolution_capabilities : list[MacroProcessingCapability] | None
var model_config
var mraid_versions : list[MraidVersion] | None
var simid : bool | None
var vast_validation : VastValidation | None
var vast_versions : list[VastVersion] | None
var vpaid : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class DataProviderDomain (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class DataProviderDomain(PublisherDomain):
    pass

A str generated from a JSON Schema string root.

Ancestors

PublisherDomain
adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class DefaultProfileId (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class DefaultProfileId(ScalarStr):
    __slots__ = ()
    _constraints = {'min_length': 1}

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class Demographics (**data: Any)

Expand source code

class Demographics(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported: Annotated[
        StrictBool,
        Field(
            description='Whether at least one seller product supports canonical demographic targeting.'
        ),
    ]

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

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class DiscoveryMode (*args, **kwds)

Expand source code

class DiscoveryMode(StrEnum):
    brief = 'brief'
    wholesale = 'wholesale'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var brief
var wholesale

class Endpoint (**data: Any)

Expand source code

class Endpoint(AdCPBaseModel):
    transports: Annotated[
        list[Transport1],
        Field(
            description='Available protocol transports. Hosts select based on their capabilities.',
            min_length=1,
        ),
    ]
    preferred: Annotated[
        Type6 | 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 : Type6 | None
var transports : list[Transport1]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class EventType (*args, **kwds)

Expand source code

class EventType(StrEnum):
    indicators_changed = 'indicators.changed'
    creative_assignment_changed = 'creative.assignment_changed'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var creative_assignment_changed
var indicators_changed

class EventType3 (*args, **kwds)

Expand source code

class EventType3(StrEnum):
    product_created = 'product.created'
    product_updated = 'product.updated'
    product_priced = 'product.priced'
    product_removed = 'product.removed'
    signal_created = 'signal.created'
    signal_updated = 'signal.updated'
    signal_priced = 'signal.priced'
    signal_removed = 'signal.removed'
    wholesale_feed_bulk_change = 'wholesale_feed.bulk_change'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var product_created
var product_priced
var product_removed
var product_updated
var signal_created
var signal_priced
var signal_removed
var signal_updated
var wholesale_feed_bulk_change

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(
            deprecated=True,
            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 : CreativeSpecs | None
var model_config
var targeting : Targeting | None
var trusted_match : TrustedMatch | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ExtensionsSupportedItem (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class ExtensionsSupportedItem(ScalarStr):
    __slots__ = ()
    _constraints = {'pattern': '^[a-z][a-z0-9_]*$'}
    _json_schema_extra = {
        'description': "Extension namespace (lowercase alphanumeric with underscores, e.g., 'iab_tcf', 'iab_gpp')",
    }

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class Features (**data: Any)

Expand source code

class Features(AdCPBaseModel):
    __pydantic_extra__: Dict[str, StrictBool]
    model_config = ConfigDict(
        extra='allow',
    )
    catalog_signals: Annotated[
        StrictBool | 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 Format (*args, **kwds)

Expand source code

class Format(StrEnum):
    jsonl = 'jsonl'
    csv = 'csv'
    parquet = 'parquet'
    avro = 'avro'
    orc = 'orc'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var avro
var csv
var jsonl
var orc
var parquet

class FrequencyCapping (**data: Any)

Expand source code

class FrequencyCapping(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported_per_units: Annotated[
        list[reach_unit.ReachUnit] | None,
        Field(
            description='Entity granularities the seller can enforce caps against. Values from the reach-unit enum. Omit to indicate all reach-unit values are supported.',
            min_length=1,
        ),
    ] = None
    supported_window_units: Annotated[
        list[str] | None,
        Field(
            description="Duration units the seller supports for frequency cap windows. Values must match the duration.json unit enum (e.g., 'hours', 'days', 'campaign'). Omit to indicate all duration units are supported.",
            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 model_config
var supported_per_units : list[ReachUnit] | None
var supported_window_units : list[str] | None

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: StrictBool | None = None
    uk_itl1: StrictBool | None = None
    uk_itl2: StrictBool | None = None
    eurostat_nuts2: StrictBool | 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 GeoProximity (**data: Any)

Expand source code

class GeoProximity(AdCPBaseModel):
    radius: Annotated[
        StrictBool | None,
        Field(
            description='Whether seller supports simple radius targeting (distance circle from a point)'
        ),
    ] = None
    travel_time: Annotated[
        StrictBool | None,
        Field(
            description='Whether seller supports travel time isochrone targeting (requires a routing engine)'
        ),
    ] = None
    geometry: Annotated[
        StrictBool | None,
        Field(
            description='Whether seller supports pre-computed GeoJSON geometry (buyer provides the polygon)'
        ),
    ] = None
    transport_modes: Annotated[
        list[transport_mode.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[TransportMode] | None
var travel_time : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class GetAdcpCapabilitiesResponse (**data: Any)

Expand source code

class GetAdcpCapabilitiesResponse(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    adcp: Annotated[Adcp, Field(description='Core AdCP protocol information')]
    supported_protocols: Annotated[
        list[SupportedProtocol],
        Field(
            description='AdCP protocols this agent supports. Stable values both (a) declare which tools the agent implements and (b) commit the agent to pass the baseline compliance storyboard at /compliance/{version}/protocols/{protocol}/ (with snake_case → kebab-case path mapping, e.g. media_buy → /compliance/.../protocols/media-buy/). The `measurement` protocol is experimental and currently covers provider catalog/output declaration (`measurement.core`) and buyer-orchestrator interchange gateways (`measurement.gateway`). Measurement agents exchange delivery and feedback with the gateway rather than receiving direct seller access. Additional provider tasks and a baseline storyboard land only when concrete workflows require them. Compliance testing support is declared separately via the `compliance_testing` capability block (below), not as a protocol claim.',
            min_length=1,
        ),
    ]
    account: Annotated[
        Account | None,
        Field(
            description='Account management capabilities. Describes how accounts are established, what billing models are supported, and whether an account is required before browsing products.'
        ),
    ] = None
    media_buy: Annotated[
        MediaBuy | None,
        Field(
            description='Media-buy protocol capabilities. Expected when media_buy is in supported_protocols. Sellers declaring media_buy should also include account with supported_billing.'
        ),
    ] = None
    signals: Annotated[
        Signals | None,
        Field(
            description='Signals protocol capabilities. Only present if signals is in supported_protocols.'
        ),
    ] = None
    governance: Annotated[
        Governance | None,
        Field(
            description='Governance protocol capabilities. Only present if governance is in supported_protocols. Governance agents provide property and creative data like compliance scores, brand safety ratings, sustainability metrics, and creative quality assessments.'
        ),
    ] = None
    sponsored_intelligence: Annotated[
        SponsoredIntelligence | None,
        Field(
            description='Sponsored Intelligence protocol capabilities. Only present if sponsored_intelligence is in supported_protocols. SI agents handle conversational brand experiences.'
        ),
    ] = None
    brand: Annotated[
        Brand | None,
        Field(
            description='Brand protocol capabilities. Only present if brand is in supported_protocols. Brand agents provide identity data (logos, colors, tone, assets) and optionally rights clearance for licensable content (talent, music, stock media).'
        ),
    ] = None
    creative: Annotated[
        Creative | None,
        Field(
            description='Creative protocol capabilities. Only present if creative is in supported_protocols.'
        ),
    ] = None
    oauth: Annotated[
        Oauth | None,
        Field(
            description='Introduced in AdCP 3.2. OAuth 2.0 protected-resource support for inbound transport authentication. This is a capability claim, not a requirement that every caller use OAuth: `supported: true` means the agent publishes RFC 9728 protected-resource metadata for its advertised endpoint and RFC 8414 metadata for every referenced authorization server, and opts into the universal `oauth_setup` conformance storyboard. Agents that use only static Bearer, Basic, mTLS, or RFC 9421 authentication omit this block or declare `supported: false`. Operator credential acquisition remains separately described by `account.authorization_endpoint` when applicable.'
        ),
    ] = None
    request_signing: Annotated[
        RequestSigning | None,
        Field(
            description='RFC 9421 HTTP Signatures support for incoming requests. Signing remains optional through 3.2, but every accepted 3.2 signature on a request with a body MUST cover content-digest. Request signing becomes required for spend-committing operations in 4.0. The full profile is defined in docs/building/by-layer/L1/security.mdx (Signed Requests (Transport Layer)).'
        ),
    ] = None
    webhook_signing: Annotated[
        WebhookSigning | None,
        Field(
            description='RFC 9421 webhook-signature and delivery-retry support for outbound webhook callbacks (top-level peer of request_signing). Declares which AdCP webhook-signing profile version and algorithms this agent produces on delivery, whether it supports the legacy HMAC-SHA256 fallback for receivers that have not yet adopted RFC 9421, and the maximum retry horizon receivers use to retain immutable delivery evidence. See docs/building/by-layer/L3/webhooks.mdx.'
        ),
    ] = None
    identity: Annotated[
        Identity | None,
        Field(
            description='Operator identity posture — trust-root pointer (`brand_json_url`) plus key-scoping and compromise-response controls the agent operates. `brand_json_url` is **load-bearing** for signature verification: when the agent declares any signing posture (`request_signing.supported_for`/`required_for` non-empty, `webhook_signing.supported === true`, or any `key_origins` subfield), `brand_json_url` MUST be present (storyboard-enforced in 3.x; schema-required in 4.0). Verifiers use it to bootstrap from the agent URL to the operator\'s brand.json (and from there to signing keys); see [security.mdx §Discovering an agent\'s signing keys](https://adcontextprotocol.org/docs/building/by-layer/L1/security#discovering-an-agents-signing-keys-via-brand_json_url). The remaining fields (`per_principal_key_isolation`, `key_origins`, `compromise_notification`) are advisory and receivers use them to reason about blast radius and revocation latency at onboarding. Empty-object semantics: `identity: {}` means "posture block present but no posture claimed" — schema-valid but advisory-neutral and receivers MUST treat it as equivalent to omitting the block, **except** that an agent declaring a signing posture elsewhere in the response with an empty `identity` MUST be rejected by storyboard runners as missing `brand_json_url`.'
        ),
    ] = None
    measurement_gateway: Annotated[
        MeasurementGateway | None,
        Field(
            description='Buyer-controlled task gateway between an orchestrator and measurement providers. In the first experimental tier, providers read buyer-approved cross-seller delivery through get_media_buy_delivery and return compact assertions through provide_performance_feedback, without receiving seller credentials. Orchestrators implementing this block MUST include measurement in supported_protocols and measurement.gateway in experimental_features; this gateway role does not claim the media_buy seller protocol.'
        ),
    ] = None
    measurement: Annotated[
        Measurement | None,
        Field(
            description="Experimental measurement capability block. Presence indicates this agent computes one or more quantitative metrics about ad delivery, exposure, or effect, and is willing to be discovered as a measurement vendor. Agents implementing this block MUST list `measurement.core` in experimental_features. Returns metric definitions and whether the provider produces compact performance feedback, not pricing/coverage (negotiated via `measurement_terms` on `create_media_buy`) or raw/live datasets. Per-buy vendor values remain on delivery reports; optimizer-ready projections use provide_performance_feedback. AgenticAdvertising.org crawls each measurement agent's `metrics[]` on a TTL to populate the federated cross-vendor index."
        ),
    ] = None
    compliance_testing: Annotated[
        ComplianceTesting | None,
        Field(
            description="Compliance testing capabilities. The presence of this block declares that the agent supports deterministic testing via comply_test_controller for lifecycle state machine validation. Omit the block entirely if the agent does not support compliance testing. Sellers SHOULD list every canonical controller scenario they implement so buyers and runners can distinguish full deterministic coverage from partial coverage without probing each scenario one by one; the runtime source of truth remains comply_test_controller with scenario: 'list_scenarios'."
        ),
    ] = None
    specialisms: Annotated[
        list[specialism.AdcpSpecialism] | None,
        Field(
            description="Optional — specialized compliance claims this agent supports. Values MUST be kebab-case enum IDs (e.g., 'creative-generative', 'sales-non-guaranteed'). An agent that implements a specialism's tools but omits its ID from this array will receive 'No applicable tracks found' from the compliance runner — tracks for that specialism are not evaluated even if every tool works. Omitting the field means the agent declares no specialism claims (it still passes the universal + domain-baseline storyboards implied by supported_protocols). Each specialism maps to a storyboard bundle at /compliance/{version}/specialisms/{id}/ that the AAO compliance runner executes to verify the claim. Each specialism rolls up to one of the protocols in supported_protocols — the runner rejects a specialism claim whose parent protocol is missing. Only list specialisms your agent actually implements — the AAO Verified badge enumerates which specialisms were demonstrably passed."
        ),
    ] = None
    extensions_supported: Annotated[
        list[ExtensionsSupportedItem] | None,
        Field(
            description='Extension namespaces this agent supports. Buyers can expect meaningful data in ext.{namespace} fields on responses from this agent. Extension schemas are published in the AdCP extension registry.'
        ),
    ] = None
    experimental_features: Annotated[
        list[experimental_feature_id.ExperimentalFeatureId] | None,
        Field(
            description='Experimental AdCP surfaces this agent implements. A surface is experimental when its schema carries x-status: experimental and the working group has not yet frozen it. Sellers that implement any experimental surface MUST list its feature id here. Buyers inspect this array before relying on experimental surfaces — a seller that does not list a surface is asserting it does not implement it. Experimental surfaces MAY break between any two 3.x releases with at least 6 weeks notice; the full contract is in docs/reference/experimental-status.'
        ),
    ] = None
    wholesale_feed_versioning: Annotated[
        WholesaleFeedVersioning | None,
        Field(
            description="Conditional-fetch token capabilities for get_products and get_signals. Independent of wholesale feed webhooks: an agent MAY support cheap version probes via if_wholesale_feed_version without pushing change payloads (and vice versa). When supported is true, the agent returns wholesale_feed_version on every get_products / get_signals response and honors if_wholesale_feed_version on subsequent requests. When absent or supported is false, callers MAY still send if_wholesale_feed_version — pre-3.1 agents that ignore it just return the full payload (correct, just inefficient). Pre-flight declaration here lets buyers fast-path which agents to bother caching versions for. See get_products / get_signals 'Wholesale feed versioning' sections."
        ),
    ] = None
    last_updated: Annotated[
        AwareDatetime | None,
        Field(
            description='ISO 8601 timestamp of when capabilities were last updated. Buyers can use this for cache invalidation.'
        ),
    ] = None
    errors: Annotated[
        list[error.Error] | None, Field(description='Task-specific errors and warnings')
    ] = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None
    wholesale_feed_webhooks: Annotated[
        WholesaleFeedWebhooks | None,
        Field(
            description='Per-agent wholesale product-feed and wholesale signals-feed webhook capabilities. Consumers register durable sync_accounts notification subscribers and receive actual product.*, signal.*, or wholesale_feed.bulk_change payloads without polling. Product mirrors bootstrap and repair through list_products(if_feed_version); signal mirrors use get_signals(if_wholesale_feed_version). Deprecated wholesale get_products remains the 3.x product compatibility path. Webhook emission MUST apply the same caller/account authorization and cache-scope predicate as the corresponding read.'
        ),
    ] = None

The response message of a task in the pinned bundle's task registry.

A consumer holding one can route on task state, pick up an async task_id, split envelope from payload and log uniformly, before knowing which tool answered. Which makes one generic poll-to-terminal loop possible for all 77 tasks, where today each arm has no common type at all.

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

AdcpResponse
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
ProtocolEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var account : Account | None
var adcp : Adcp
var brand : Brand | None
var compliance_testing : ComplianceTesting | None
var context : ContextObject | None
var creative : Creative | None
var errors : list[Error] | None
var experimental_features : list[ExperimentalFeatureId] | None
var ext : ExtensionObject | None
var extensions_supported : list[ExtensionsSupportedItem] | None
var governance : Governance | None
var identity : Identity | None
var last_updated : pydantic.types.AwareDatetime | None
var measurement : Measurement | None
var measurement_gateway : MeasurementGateway | None
var media_buy : MediaBuy | None
var model_config
var oauth : Oauth | None
var request_signing : RequestSigning | None
var signals : Signals | None
var specialisms : list[AdcpSpecialism] | None
var sponsored_intelligence : SponsoredIntelligence | None
var supported_protocols : list[SupportedProtocol]
var webhook_signing : WebhookSigning | None
var wholesale_feed_versioning : WholesaleFeedVersioning | None
var wholesale_feed_webhooks : WholesaleFeedWebhooks | None

Inherited members

AdcpResponse:
- get_adcp_error
- get_context
- get_message
- get_replayed
- get_status
- get_task_id
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class Governance (**data: Any)

Expand source code

class Governance(AdCPBaseModel):
    runtime_attestations: Annotated[
        RuntimeAttestations | None,
        Field(
            description='Signal-activation policy for the portable attestation support declared in adcp.attestations. Presence means check_governance accepts runtime_attestations[] for purchase_type signal_activation. The claim_types list MUST be a subset of adcp.attestations.accepted_claim_types; issuer, resolver, verifier, proof-format, and delivery allowlists remain authoritative in the shared adcp.attestations block rather than being duplicated here.'
        ),
    ] = None
    aggregation_window_days: Annotated[
        SchemaInt | 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[CreativeFeature] | None
var model_config
var property_features : list[PropertyFeature] | None
var runtime_attestations : RuntimeAttestations | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class GovernanceEnforcement (**data: Any)

Expand source code

class GovernanceEnforcement(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    tasks: Annotated[
        list[Tasks],
        Field(
            description='Task-scoped enforcement claims. The task field is a semantic uniqueness key: an agent MUST emit at most one entry per task and combine all supported modes in that entry. JSON Schema uniqueItems only rejects structurally identical objects, so producers and capability validators MUST enforce task-key uniqueness separately. Values correspond to request schemas annotated with x-governed-commitment. Online execution checks are currently defined only for media-buy tasks, whose prepared result has the PlannedDelivery contract; other roles can enforce signed intent authorization without inventing media-buy fields.',
            min_length=1,
        ),
    ]
    accepted_governance_agents: Annotated[
        accepted_governance_agents_1.AcceptedGovernanceAgents | None,
        Field(
            description='Seller-wide advisory default for governance agents this enforcing service accepts as binding counterparties. A candidate satisfying any matcher is accepted by this declaration. The per-account sync_governance response is authoritative and may apply stricter account-specific criteria. Omission means accept any, preserving legacy behavior.'
        ),
    ] = 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 accepted_governance_agents : AcceptedGovernanceAgents | None
var model_config
var tasks : list[Tasks]

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[
        SchemaInt,
        Field(
            description="How long the seller retains a canonical response or committed-outcome tombstone for an idempotency_key, measured from the successful mutation's durable commit time. The completed key record and canonical request hash MUST remain available until at least committed_at + this interval, independently of the lifecycle of any resource the request created; a UNIQUE idempotency_key column on the resource row alone does not satisfy this contract. Within this window, a replay with the same key + equivalent canonical payload returns the cached response, or COMMITTED_RESOURCE_PURGED when the mutation committed but the affected resource was independently deleted or purged before the canonical success response could be durably recorded; a replay with a different canonical payload returns IDEMPOTENCY_CONFLICT. An unresolved in-flight or reconciliation-required claim is retained regardless of this completed-entry clock. A replay past a completed entry's 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[
        SchemaInt | None,
        Field(
            description="Maximum active execution lease in seconds before the seller stops or replaces the original handler and transitions the durable idempotency claim to reconciliation-required per L1/security.mdx rule 9. Expiry does not release or evict an unresolved claim and never permits reinvocation while commit state is ambiguous. Buyer SDKs use this value to cap an individual retry wait when they see `IDEMPOTENCY_IN_FLIGHT`, rather than using the much wider `replay_ttl_seconds` ceiling; it is not a deadline after which they may mint a fresh key. 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`; validators MUST enforce this cross-field constraint at the test layer since JSON Schema cannot express field-relative bounds. A buyer that observes top-level `error.retry_after` exceeding this value MAY treat that as a seller bug for an actively executing attempt.",
            ge=1,
            le=604800,
        ),
    ] = None
    account_id_is_opaque: Annotated[
        StrictBool | 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 Idempotency1 (**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[
        StrictBool | 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 : CompromiseNotification | None
var key_origins : KeyOrigins | None
var model_config
var per_principal_key_isolation : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class IdentityUpdates (**data: Any)

Expand source code

class IdentityUpdates(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    supported: Annotated[
        Literal[True],
        Field(
            description='Discriminator. True means the seller accepts operator_identity in sync_accounts settings-update mode.'
        ),
    ]
    supported_changes: Annotated[
        list[SupportedChange],
        Field(
            description='Identity changes the seller accepts. operator_unit_name covers display-name-only reconciliation within the current operator. operator_unit covers adding, removing, or changing the stable unit id within the current operator and also implies name updates. operator covers an inter-entity operator-domain handoff and encompasses the entire replacement operator identity, including any simultaneous unit addition, removal, or change; a seller need not also advertise operator_unit for that cross-operator replacement.',
            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 : Literal[True]
var supported_changes : list[SupportedChange]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class IdentityUpdates1 (**data: Any)

Expand source code

class IdentityUpdates1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    supported: Annotated[
        Literal[False],
        Field(
            description='Discriminator. False means buyers must not submit operator_identity settings updates.'
        ),
    ]

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 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[match_type.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[MatchType]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Language (**data: Any)

Expand source code

class Language(AdCPBaseModel):
    supported: Annotated[
        StrictBool | None,
        Field(description='Whether seller supports language-preference targeting'),
    ] = None
    supported_languages: Annotated[
        list[locale_tag.LanguageTag] | None,
        Field(
            description='Exact canonical BCP 47 language ranges accepted in targeting.language. Omission means the seller makes no exhaustive language-list declaration.'
        ),
    ] = 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 supported_languages : list[LanguageTag] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class LifecycleTool (*args, **kwds)

Expand source code

class LifecycleTool(StrEnum):
    list_products = 'list_products'
    request_proposals = 'request_proposals'
    refine_proposals = 'refine_proposals'
    decline_proposals = 'decline_proposals'
    buy_products = 'buy_products'
    accept_proposal = 'accept_proposal'
    control_media_buy = 'control_media_buy'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var accept_proposal
var buy_products
var control_media_buy
var decline_proposals
var list_products
var refine_proposals
var request_proposals

class Localization (**data: Any)

Expand source code

class Localization(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    max_target_variants: Annotated[
        SchemaInt | None,
        Field(
            description='Maximum target locale variants accepted on one creative. Zero advertises source-only monolingual locale topology. Omit to inherit the protocol ceiling of 50.',
            ge=0,
            le=50,
        ),
    ] = None
    locale_matching: Annotated[
        Literal['rfc4647_lookup'],
        Field(description='The required deterministic locale-matching algorithm.'),
    ] = 'rfc4647_lookup'

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 locale_matching : Literal['rfc4647_lookup']
var max_target_variants : int | None
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class MajorVersion (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class MajorVersion(ScalarInt):
    __slots__ = ()
    _constraints = {'ge': 1}

An int generated from a JSON Schema integer root.

Validates the way SchemaInt validates an integer field: strict, so "1" and True are refused, with a float carrying no fractional part narrowed to int because JSON Schema counts it as one.

Ancestors

adcp.types._scalar.ScalarInt
adcp.types._scalar._ScalarRoot
builtins.int

class MatchingLatencyHours (**data: Any)

Expand source code

class MatchingLatencyHours(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    min: Annotated[SchemaInt | None, Field(ge=0)] = None
    max: Annotated[SchemaInt | 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):
    produces_performance_feedback: Annotated[
        StrictBool | None,
        Field(
            description="Whether this measurement agent produces compact provide_performance_feedback assertions for a buyer-controlled orchestrator gateway. In the first experimental tier the provider reads delivery through the gateway's get_media_buy_delivery task and returns assertions through its provide_performance_feedback task. The gateway decides what to forward to each seller."
        ),
    ] = False
    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[Metric]
var model_config
var produces_performance_feedback : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class MeasurementGateway (**data: Any)

Expand source code

class MeasurementGateway(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    delivery_task: Annotated[
        Literal['get_media_buy_delivery'],
        Field(
            description='Task providers call on the orchestrator gateway to read buyer-approved delivery.'
        ),
    ] = 'get_media_buy_delivery'
    feedback_task: Annotated[
        Literal['provide_performance_feedback'],
        Field(
            description='Task providers call on the orchestrator gateway to return one compact assertion.'
        ),
    ] = 'provide_performance_feedback'

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 delivery_task : Literal['get_media_buy_delivery']
var feedback_task : Literal['provide_performance_feedback']
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class MediaBuy (**data: Any)

Expand source code

class MediaBuy(AdCPBaseModel):
    anonymous_discovery: Annotated[
        StrictBool | None,
        Field(
            description='Whether this seller accepts product discovery without caller credentials. This applies to list_products and to get_products in brief or wholesale mode; it does not apply to proposal refinement or finalization, purchasing, account-scoped reads, or mutations. true means an anonymous discovery request can produce a successful response, but the response may be a public subset and may differ from results for an authenticated principal or selected account. false means these discovery calls require an authenticated principal. Absence means unspecified legacy behavior, so callers probe and handle AUTH_MISSING. A valid authenticated request is never rejected merely because credentials were supplied. true is inconsistent with account.required_for_products=true because an anonymous caller cannot select protected account context.'
        ),
    ] = None
    acceptance_policy_discovery: Annotated[
        AcceptancePolicyDiscovery | None,
        Field(
            description='Registry-backed seller acceptance-policy discovery. Presence means the seller publishes a versioned catalog; it does not claim that the seller evaluates acceptance_context during discovery. Discovery is advisory, exact task responses remain authoritative, and absent capability means support is unknown rather than unrestricted acceptance.'
        ),
    ] = None
    supported_pricing_models: Annotated[
        list[pricing_model.PricingModel] | 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]
    measurement_terms_acceptance: Annotated[
        StrictBool | None,
        Field(
            description="Whether this seller can accept the default measurement_terms it advertises on a product. A value of true means the seller can return a product carrying measurement_terms for a measurement-specific brief and accept those terms unchanged on a package for that product. This opts the seller into conformance scenarios that discover and replay the product's own terms. False or absent means acceptance is outside the seller's advertised scope, but the seller must still reject unsupported terms with TERMS_REJECTED rather than being graded on an acceptance path it did not claim."
        ),
    ] = False
    availability_horizon: Annotated[
        StrictBool | None,
        Field(
            description='Whether this seller supports flexible-window availability discovery: parsing offer_filters.availability_horizon and answering with time-dimensioned forecast points that carry availability_status. Sellers declaring true MUST apply the full window contract — half-open non-overlapping windows that partition the requested horizon (or signal gaps via incomplete[]), with availability_status computed from all booking eligibility constraints, not only competing holds. false or absent means flexible-window support is unknown: buyers SHOULD use exact start_date/end_date filtering, and sellers MAY ignore the field or reject it. Conformance storyboards gate flexible-window checks on this declaration.'
        ),
    ] = False
    lifecycle_tools: Annotated[
        list[LifecycleTool] | None,
        Field(
            description='Compact product and MediaBuy lifecycle operation names this seller supports. Added in AdCP 3.2 as task-specific contracts that form the 4.0 lifecycle foundation. Sellers may advertise any supported subset while retaining the deprecated get_products/create_media_buy/update_media_buy facades throughout 3.x. Each stateful split task has its own idempotency identity; callers MUST retry with the same tool name.',
            min_length=1,
        ),
    ] = None
    proposal_refinement: Annotated[
        ProposalRefinement | None,
        Field(
            description='Pre-flight support for typed refine_proposals revision dimensions. These declarations mean the seller can parse and mechanically validate a dimension; they never promise that the seller will commercially concede it. Absence means typed-dimension support is unknown and buyers must handle per-result partial or unable outcomes. A dimension omitted from an explicit supported_dimensions list MUST be rejected at task level with UNSUPPORTED_FEATURE before any proposal is created.'
        ),
    ] = None
    reporting_delivery_methods: Annotated[
        list[CapabilityReportingDeliveryMethod] | 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
    performance_feedback: Annotated[
        PerformanceFeedback | None,
        Field(
            description='Structured seller performance-feedback support beyond the legacy scalar contract. Presence means the seller accepts compact baseline/metric/provenance fields from a buyer orchestrator and returns a feedback_id.'
        ),
    ] = None
    offline_delivery_protocols: Annotated[
        list[cloud_storage_protocol.CloudStorageProtocol] | 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
    reporting_delivery: Annotated[
        reporting_delivery_capabilities.ReportingDeliveryCapabilities | None,
        Field(
            description='AdCP 3.2 Reliable Reporting capability. The affirmative machine answer to ‘Do you support Reliable Reporting?’ requires this block with supported: true and reliable_reporting_version: 1.0 plus media_buy.reporting_delivery in experimental_features. Core exposes seller get_reporting_status; during the published migration window, consumer_status_task separately advertises opt-in buyer-to-seller sync_reporting_status and becomes required Core only in the next eligible minor. managed_delivery and reconciled_billing identify optional tiers. This generalizes, but does not remove, the legacy reporting_delivery_methods/offline_delivery_protocols surface; those legacy fields and declarations from other protocols do not imply Reliable Reporting support.'
        ),
    ] = None
    supports_proposals: Annotated[
        StrictBool | None,
        Field(
            description='Conformance declaration that this seller supports proposals through either the compact request/refine/finalize lifecycle or the legacy get_products facade. accept_proposal, or the create_media_buy compatibility facade, consumes a finalized committed proposal_id before expires_at.'
        ),
    ] = False
    outcome_target: Annotated[
        StrictBool | None,
        Field(
            description="Whether this seller supports reverse-forecast planning: parsing criteria.outcome_target (a compact goal — a forecastable-metric delivery metric or an event-type conversion event — plus a desired volume, a cost_per target, or both) and planning against it, answering with total_budget_guidance and forecasts whose points carry the goal's key in metrics; see outcome-target.json for cost_per answers and rejections. This flag does not distinguish sellers that plan cost_per; buyers rely on the negotiated adcp_version together with features.bidding_policy. false or absent means support is unknown: buyers SHOULD express outcome goals in brief prose instead, and sellers reject a structured outcome_target on proposal requests with UNSUPPORTED_FEATURE rather than silently ignoring it (list_products ignores it for every seller)."
        ),
    ] = False
    governance_aware: Annotated[
        StrictBool | None,
        Field(
            description='Compatibility claim used by existing media-buy conformance runners. A value of true corresponds only to online governance consultation for create_media_buy, the historically graded surface. Agents use adcp.governance_enforcement for explicit task-scoped claims, including update_media_buy and cross-role signed-context enforcement.'
        ),
    ] = 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
    supported_indicator_types: Annotated[
        list[indicator_type.IndicatorType] | None,
        Field(
            description="Indicator types this seller can expose on get_media_buys media-buy/package/creative-assignment snapshots. Each type's meaning is defined by the negotiated AdCP release; indicator types do not carry independent sub-versions. This is availability, not complete upstream coverage. Poll-only sellers may declare this field without relationship_notifications. If relationship_notifications includes indicators.changed, this field is required so receivers know which durable indicator types can be repaired.",
            min_length=1,
        ),
    ] = None
    relationship_notifications: Annotated[
        RelationshipNotifications | None,
        Field(
            description='Optional durable account-level invalidations for indicator, creative-assignment, and assignment-approval changes. A seller may expose indicators only through polling and omit this block. A seller without an indicator catalog may declare creative.assignment_changed alone. get_media_buys is the complete authoritative repair read. creative.assignment_changed is independent of the optional bounded list_creatives reverse projection, so inline-only sellers can advertise approval and assignment invalidations. Presence means the seller accepts the declared subscriptions through sync_accounts notification_configs. Timestamp-only reevaluation does not fire. Poll-based upstream integrations fire when they detect a change; this declaration does not promise upstream detection latency.'
        ),
    ] = None
    features: media_buy_features.MediaBuyFeatures | None = None
    execution: Annotated[
        Execution | None, Field(description='Technical execution capabilities for media buying')
    ] = None
    audience_evidence: Annotated[
        AudienceEvidence | None,
        Field(
            description='Support for structured product audience evidence and buyer-authored evidence policy. Presence means the seller can publish Product.audience_evidence, preserve immutable snapshots through package readback, and evaluate the declared policy modes. It does not declare audience-targeting capability.'
        ),
    ] = None
    rights_attestations: Annotated[
        RightsAttestations | None,
        Field(
            description='Seller evaluation policy for portable rights-grant attestations carried on creative rights constraints. Presence requires adcp.attestations and the rights-grant claim URI in accepted_claim_types. The seller remains verifier-of-record and never treats verification_url or a buyer-authored evaluation as authorization.'
        ),
    ] = 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='Seller-wide package frequency-capping infrastructure. Presence means the seller honors targeting_overlay.frequency_cap on packages, with an independent counter per package, and MUST reject caps it cannot enforce rather than silently dropping them. Product.overlay_support is the binding per-product declaration. A cap whose single counter spans every package in a MediaBuy is advertised separately through aggregate_frequency_capping.'
        ),
    ] = None
    aggregate_frequency_capping: Annotated[
        media_buy_frequency_cap_capability.MediaBuyFrequencyCapCapability | None,
        Field(
            description='Seller-wide support for a maximum-impression cap whose single counter is shared across every package in a MediaBuy. Presence is required before a buyer sends a root frequency_cap. Products additionally declare media_buy_support.frequency_cap and any narrower constraints.'
        ),
    ] = None
    budget_capping: Annotated[
        BudgetCapping | None,
        Field(
            description='Hard daily budget-cap capabilities. Presence declares only the scopes listed in supported_scopes; sellers MUST reject a daily_budget_cap at an undeclared scope with UNSUPPORTED_FEATURE before mutation and MUST NOT silently drop or soften it. A cap is always a hard ceiling. Sellers that offer a best-effort pacing target must expose that under a separately named feature rather than interpreting daily_budget_cap as soft. Daily caps are orthogonal to pacing.'
        ),
    ] = 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. Media-buy sellers SHOULD publish primary_channels and primary_countries as their complete brief-routing scope. Buyers use publisher_domains to verify authorization via adagents.json. Omitted routing arrays mean unknown scope and MUST NOT be interpreted as global coverage."
        ),
    ] = 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 acceptance_policy_discovery : AcceptancePolicyDiscovery | None
var aggregate_frequency_capping : MediaBuyFrequencyCapCapability | None
var anonymous_discovery : bool | None
var audience_evidence : AudienceEvidence | None
var audience_targeting : AudienceTargeting | None
var availability_horizon : bool | None
var budget_capping : BudgetCapping | None
var buying_modes : list[BuyingMode] | None
var content_standards : ContentStandards | None
var conversion_tracking : ConversionTracking | None
var creative_approval_mode : CreativeApprovalMode | None
var execution : Execution | None
var features : MediaBuyFeatures | None
var frequency_capping : FrequencyCapping | None
var governance_aware : bool | None
var lifecycle_tools : list[LifecycleTool] | None
var measurement_terms_acceptance : bool | None
var model_config
var offline_delivery_protocols : list[CloudStorageProtocol] | None
var outcome_target : bool | None
var performance_feedback : PerformanceFeedback | None
var portfolio : Portfolio | None
var propagation_surfaces : list[PropagationSurface] | None
var proposal_refinement : ProposalRefinement | None
var relationship_notifications : RelationshipNotifications | None
var reporting_delivery : ReportingDeliveryCapabilities | None
var reporting_delivery_methods : list[CapabilityReportingDeliveryMethod] | None
var rights_attestations : RightsAttestations | None
var supported_indicator_types : list[IndicatorType] | None
var supported_optimization_metrics : list[SupportedOptimizationMetric] | None
var supported_pricing_models : list[PricingModel] | None
var supports_proposals : bool | None
var vendor_metric_optimization : 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[
        vendor_metric_id.VendorMetricId,
        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."
        ),
    ]
    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 via `committed_metrics[].methodology_version` (vendor scope) 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: ext_1.ExtensionObject | 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 accreditations : list[Accreditation] | None
var description : str | None
var ext : ExtensionObject | None
var methodology_url : pydantic.networks.AnyUrl | None
var methodology_version : str | None
var metric_id : VendorMetricId
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 Mode (*args, **kwds)

Expand source code

class Mode(StrEnum):
    signed_context = 'signed_context'
    online_execution_check = 'online_execution_check'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var online_execution_check
var signed_context

class MraidVersion (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class MraidVersion(ScalarStr):
    __slots__ = ()
    _constraints = {'pattern': '^[0-9]+\\.[0-9]+$'}

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class Multiplicity (**data: Any)

Expand source code

class Multiplicity(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supports_catalog_fanout: Annotated[
        StrictBool | None,
        Field(
            description='When true, build_creative accepts max_creatives (one distinct creative per catalog item).'
        ),
    ] = False
    max_creatives_limit: Annotated[
        SchemaInt | None,
        Field(description='Ceiling on max_creatives. Omitted means no advertised ceiling.', ge=1),
    ] = None
    supports_signal_fanout: Annotated[
        StrictBool | None,
        Field(
            description='Experimental (x-status: experimental) — agents setting this true MUST also list `creative.signal_fanout` in `experimental_features`; the surface MAY change between 3.x releases with notice (see docs/reference/experimental-status). When true, build_creative accepts signal_conditions[] (one distinct creative group per signal condition, keep-all). Mirrors supports_catalog_fanout.'
        ),
    ] = False
    max_signal_conditions_limit: Annotated[
        SchemaInt | None,
        Field(
            description='Ceiling on len(signal_conditions). Over-limit requests are CLAMPED (not rejected), like max_creatives_limit. Omitted means no advertised ceiling.',
            ge=1,
        ),
    ] = None
    supports_variants: Annotated[
        StrictBool | None,
        Field(
            description='When true, build_creative accepts max_variants > 1 / variant_axis (alternatives per creative).'
        ),
    ] = False
    max_variants_limit: Annotated[
        SchemaInt | None,
        Field(description='Ceiling on max_variants. Omitted means no advertised ceiling.', ge=1),
    ] = None
    variant_dimensions: Annotated[
        list[VariantDimension] | None,
        Field(description='Which variant_axis.dimension values this agent supports.'),
    ] = None
    selection_strategies: Annotated[
        list[creative_selection_strategy.CreativeSelectionStrategy] | None,
        Field(
            description='Which selection_strategy values this agent supports when sampling max_creatives < items_total. Sibling to variant_dimensions. Part of the experimental signal-fanout surface (feature id `creative.signal_fanout`).'
        ),
    ] = 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_creatives_limit : int | None
var max_signal_conditions_limit : int | None
var max_variants_limit : int | None
var model_config
var selection_strategies : list[CreativeSelectionStrategy] | None
var supports_catalog_fanout : bool | None
var supports_signal_fanout : bool | None
var supports_variants : bool | None
var variant_dimensions : list[VariantDimension] | 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[match_type.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[MatchType]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Notifications (**data: Any)

Expand source code

class Notifications(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported: Annotated[
        Literal[True],
        Field(
            description='Discriminator. True means the seller accepts the declared registration_task for capabilities.changed subscriptions.'
        ),
    ]
    registration_task: Annotated[
        RegistrationTask,
        Field(
            description='Task consumers call to manage their caller-scoped agent-level subscriber set.'
        ),
    ]
    event_types: Annotated[
        list[Literal['capabilities.changed']],
        Field(
            description='Agent-level notification types this seller can emit for capability changes. Currently only `capabilities.changed` is defined.',
            min_length=1,
        ),
    ]
    coalescence_window_seconds: Annotated[
        SchemaInt | None,
        Field(
            description='Maximum coalescence window the seller applies before firing a `capabilities.changed` webhook after a burst of related capability edits. The default recommendation is at most 300 seconds; latency-sensitive deactivations SHOULD fire sooner.',
            ge=0,
            le=86400,
        ),
    ] = 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 coalescence_window_seconds : int | None
var event_types : list[typing.Literal['capabilities.changed']]
var model_config
var registration_task : RegistrationTask
var supported : Literal[True]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Notifications1 (**data: Any)

Expand source code

class Notifications1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported: Annotated[
        Literal[False],
        Field(
            description='Discriminator. False means consumers must rely on TTL refresh, manual refresh, or registry polling for capability changes.'
        ),
    ]

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 Notifications2 (**data: Any)

Expand source code

class Notifications2(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported: Annotated[
        Literal[True],
        Field(
            description='Discriminator. True means the seller accepts account-level `notification_configs[]` registrations for account lifecycle events.'
        ),
    ]
    registration_task: Annotated[
        Literal['sync_accounts'],
        Field(description='Task buyers call to manage account-level subscriber sets.'),
    ] = 'sync_accounts'
    read_task: Annotated[
        Literal['list_accounts'],
        Field(
            description='Authoritative repair read after receiving an account lifecycle invalidation.'
        ),
    ] = 'list_accounts'
    event_types: Annotated[
        list[Literal['account.status_changed']],
        Field(
            description='Account lifecycle notification types this seller can emit. Currently only `account.status_changed` is defined.',
            min_length=1,
        ),
    ]
    supports_webhook_activity: Annotated[
        StrictBool | None,
        Field(
            description='Whether `list_accounts` can return recent delivery attempts in `accounts[].webhook_activity[]` when the buyer requests `include_webhook_activity: true`.'
        ),
    ] = 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 event_types : list[typing.Literal['account.status_changed']]
var model_config
var read_task : Literal['list_accounts']
var registration_task : Literal['sync_accounts']
var supported : Literal[True]
var supports_webhook_activity : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Notifications3 (**data: Any)

Expand source code

class Notifications3(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported: Annotated[
        Literal[False],
        Field(
            description='Discriminator. False means buyers must rely on `sync_accounts` results, `push_notification_config` for one-shot provisioning callbacks, and polling `list_accounts` for later status changes.'
        ),
    ]

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 Oauth (**data: Any)

Expand source code

class Oauth(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported: Annotated[
        StrictBool,
        Field(
            description='Whether this agent accepts OAuth access tokens and publishes the discovery metadata needed to obtain and validate them. A true value is an explicit conformance claim: the RFC 9728 protected-resource document and every RFC 8414 authorization-server document it references MUST be reachable, internally consistent, and safe for clients to follow. False or absent means the OAuth metadata storyboard is not applicable; it does not weaken the universal requirement to implement at least one authentication mechanism.'
        ),
    ]

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

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Operation (*args, **kwds)

Expand source code

class Operation(StrEnum):
    build = 'build'
    validate = 'validate'
    preview = 'preview'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var build
var preview
var validate

class Pattern (*args, **kwds)

Expand source code

class Pattern(StrEnum):
    file_transfer = 'file_transfer'
    warehouse_materialization = 'warehouse_materialization'
    dataset_share = 'dataset_share'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var dataset_share
var file_transfer
var warehouse_materialization

class PerformanceFeedback (**data: Any)

Expand source code

class PerformanceFeedback(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    reports_application_status: Annotated[
        StrictBool | None,
        Field(
            description='Whether provide_performance_feedback responses include an honest application_status of accepted, applied, or not_applied. accepted is explicitly not an application claim. Sellers that cannot determine optimizer disposition omit this claim or set it false.'
        ),
    ] = 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 model_config
var reports_application_status : bool | None

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[channels.MediaChannel] | None,
        Field(
            description="Complete list of AdCP media channels for which this sales agent accepts and can meaningfully answer product-discovery briefs. When present, this is an exhaustive brief-routing allowlist: buyers MAY skip the agent when a brief's requested channels do not intersect it. Omission means channel scope is unknown and MUST NOT be interpreted as support for every channel. This is a routing pre-filter, not a promise of current product availability."
        ),
    ] = None
    primary_countries: Annotated[
        list[PrimaryCountry] | None,
        Field(
            description="Complete list of ISO 3166-1 alpha-2 countries for which this sales agent accepts and can meaningfully answer product-discovery briefs. When present, this is an exhaustive brief-routing allowlist: buyers MAY skip the agent when a brief's requested countries do not intersect it. Omission means country scope is unknown and MUST NOT be interpreted as global coverage. This is a routing pre-filter, not a promise of current product availability and not an executable geo-targeting declaration; media_buy.execution.targeting geo capabilities and each product's overlay_support remain authoritative for targeting execution."
        ),
    ] = 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[MediaChannel] | None
var primary_countries : list[PrimaryCountry] | None
var publisher_domains : list[PublisherDomain]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Preview (**data: Any)

Expand source code

class Preview(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    routes: Annotated[
        list[Route],
        Field(
            description='Agent-local preview routes and their implementation origin. Authority is resolved from publisher placement delegation, never from this self-description.',
            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 routes : list[Route]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class PrimaryCountry (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class PrimaryCountry(ScalarStr):
    __slots__ = ()
    _constraints = {'pattern': '^[A-Z]{2}$'}

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class Principal (**data: Any)

Expand source code

class Principal(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    supported: Literal[True]
    sync_task: Literal['sync_principal'] = 'sync_principal'
    read_task: Annotated[
        Literal['get_principal'],
        Field(
            description="Side-effect-free task returning the caller's current connection configuration and version."
        ),
    ] = 'get_principal'
    supported_sections: Annotated[
        list[SupportedSection],
        Field(
            description='Connection configuration sections this seller accepts. Unsupported sections are rejected rather than silently ignored.',
            min_length=1,
        ),
    ]
    max_reporting_destinations: Annotated[
        SchemaInt | None,
        Field(
            description='Maximum caller-scoped destination bindings when reporting_destinations is supported. The task schema has a portable maximum of 64; sellers may advertise a lower operational limit.',
            ge=1,
            le=64,
        ),
    ] = None
    reporting_destination_offerings: Annotated[
        list[ReportingDestinationOffering] | None,
        Field(
            description='Objective per-pattern delivery offering, so buyers can select a compatible destination without submit-and-reject probing. A destination whose pattern, transport, access mode, format set, or verification-profile set falls outside this offering fails the sync request atomically with UNSUPPORTED_FEATURE; provider-side setup outcomes for in-offering destinations are expressed only through destination states.',
            max_length=3,
            min_length=1,
        ),
    ] = None
    suspension_interval_seconds: Annotated[
        SchemaInt | None,
        Field(
            description='Advertised upper bound, in seconds, between a committed destination suspension or revocation — or a subscriber deactivation — and the halt of new deliveries and fires.',
            ge=1,
            le=86400,
        ),
    ] = None
    caller_event_types: Annotated[
        list[notification_type.NotificationType] | None,
        Field(
            description='Notification types this seller can emit against caller-level subscribers, so buyers select from the offering instead of probing by rejection. Account-anchored entries fire with fire-time authorization scoping. When absent, only capabilities.changed is assumed. A caller-level subscriber requesting a type outside this set fails the sync request with UNSUPPORTED_FEATURE.',
            min_length=1,
        ),
    ] = None
    optimistic_concurrency: Annotated[
        StrictBool,
        Field(
            description='Whether expected_configuration_version is enforced. Sellers SHOULD support it when several services may authenticate as the same stable principal. When false, a request carrying expected_configuration_version is rejected with UNSUPPORTED_FEATURE rather than silently ignored.'
        ),
    ]

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 caller_event_types : list[NotificationType] | None
var max_reporting_destinations : int | None
var model_config
var optimistic_concurrency : bool
var read_task : Literal['get_principal']
var reporting_destination_offerings : list[ReportingDestinationOffering] | None
var supported : Literal[True]
var supported_sections : list[SupportedSection]
var suspension_interval_seconds : int | None
var sync_task : Literal['sync_principal']

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class PropagationSurface (*args, **kwds)

Expand source code

class PropagationSurface(StrEnum):
    snapshot = 'snapshot'
    webhook = 'webhook'
    out_of_band = 'out_of_band'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var out_of_band
var snapshot
var webhook

class PropertyFeature (**data: Any)

Expand source code

class PropertyFeature(AdCPBaseModel):
    feature_id: Annotated[
        str,
        Field(
            description="Unique identifier for this feature (e.g., 'consent_quality', 'coppa_certified', 'carbon_score')"
        ),
    ]
    type: Annotated[
        Type,
        Field(
            description="Data type: 'binary' for yes/no, 'quantitative' for numeric scores, 'categorical' for enum values"
        ),
    ]
    range: Annotated[
        Range | None, Field(description='For quantitative features, the valid range')
    ] = None
    categories: Annotated[
        list[str] | None, Field(description='For categorical features, the valid values')
    ] = None
    description: Annotated[
        str | None, Field(description='Human-readable description of what this feature measures')
    ] = None
    methodology_url: Annotated[
        AnyUrl | None,
        Field(
            description='URL to documentation explaining how this feature is calculated or measured. Helps buyers understand and compare methodologies across vendors.'
        ),
    ] = 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 categories : list[str] | None
var description : str | None
var feature_id : str
var methodology_url : pydantic.networks.AnyUrl | None
var model_config
var range : Range | None
var type : Type

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ProposalRefinement (**data: Any)

Expand source code

class ProposalRefinement(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported_dimensions: Annotated[
        list[SupportedDimension],
        Field(
            description='Typed revision dimensions the seller can parse and validate. An empty list authoritatively means ask-only refinement with no typed dimensions. total_budget, cpm, impressions, and flight cover the same-named constraints keys; product_changes covers product_changes; alternatives covers alternatives.count; criteria covers structured discovery criteria. Free-text ask interpretation is competence, not a capability declared here.'
        ),
    ]
    max_alternatives: Annotated[
        SchemaInt | None,
        Field(
            description='Optional maximum alternatives.count the seller accepts, up to the protocol maximum of 10. Valid only when supported_dimensions includes alternatives. Requests above this ceiling fail at task level with VALIDATION_ERROR identifying refinements[i].alternatives.count; sellers MUST NOT silently clamp the request or return alternatives_unavailable for the declared ceiling violation.',
            ge=2,
            le=10,
        ),
    ] = 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_alternatives : int | None
var model_config
var supported_dimensions : list[SupportedDimension]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ProtocolMethodsRequiredForItem (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class ProtocolMethodsRequiredForItem(ProtocolMethodsSupportedForItem):
    pass

A str generated from a JSON Schema string root.

Ancestors

ProtocolMethodsSupportedForItem
adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class ProtocolMethodsSupportedForItem (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class ProtocolMethodsSupportedForItem(ScalarStr):
    __slots__ = ()
    _constraints = {
        'max_length': 256,
        'pattern': '^(?:[a-z][A-Za-z0-9_]*(?:/[A-Za-z][A-Za-z0-9_]*)+|[A-Z][A-Za-z0-9_]*)$',
    }

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class ProtocolMethodsWarnForItem (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class ProtocolMethodsWarnForItem(ProtocolMethodsSupportedForItem):
    pass

A str generated from a JSON Schema string root.

Ancestors

ProtocolMethodsSupportedForItem
adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class PublisherDomain (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class PublisherDomain(ScalarStr):
    __slots__ = ()
    _constraints = {
        'pattern': '^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$',
    }

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

Subclasses

DataProviderDomain

class Range (**data: Any)

Expand source code

class Range(AdCPBaseModel):
    min: Annotated[StrictFloat, Field(description='Minimum value')]
    max: Annotated[StrictFloat, Field(description='Maximum value')]

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 : float
var min : float
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class RegistrationTask (*args, **kwds)

Expand source code

class RegistrationTask(StrEnum):
    sync_agent_notification_configs = 'sync_agent_notification_configs'
    sync_principal = 'sync_principal'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var sync_agent_notification_configs
var sync_principal

class RelationshipNotifications (**data: Any)

Expand source code

class RelationshipNotifications(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    supported: Annotated[
        Literal[True],
        Field(
            description='Discriminator. True means the declared invalidation event types are supported.'
        ),
    ]
    registration_task: Annotated[
        Literal['sync_accounts'],
        Field(description='Task buyers call to register account-level subscribers.'),
    ] = 'sync_accounts'
    event_types: Annotated[
        list[EventType],
        Field(
            description='Relationship invalidation events supported by this seller. indicators.changed requires supported_indicator_types but is not required merely because polling readback is available. creative.assignment_changed is independently available when the seller can detect assignment or assignment-approval changes; it does not require indicator support or list_creatives.',
            max_length=2,
            min_length=1,
        ),
    ]
    repair_tasks: Annotated[
        list[Literal['get_media_buys']],
        Field(
            description='Complete authoritative snapshot reads used after an invalidation. get_media_buys is mandatory and is the only 3.2 repair task for this contract.',
            max_length=1,
            min_length=1,
        ),
    ]
    projection_tasks: Annotated[
        list[Literal['list_creatives']] | None,
        Field(
            description='Optional bounded reverse projections of relationship-scoped indicator and approval state. list_creatives is a discovery/read convenience for creative-library sellers, not a complete repair path; declaring it also requires creative in supported_protocols. Buyers fall back to get_media_buys whenever nested assignments are truncated or a relationship must be proven absent.',
            max_length=1,
            min_length=1,
        ),
    ] = None
    supports_webhook_activity: Annotated[
        StrictBool | None,
        Field(
            description='Whether the declared repair tasks can return recent delivery attempts for these account-level invalidations when include_webhook_activity is true.'
        ),
    ] = 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 event_types : list[EventType]
var model_config
var projection_tasks : list[typing.Literal['list_creatives']] | None
var registration_task : Literal['sync_accounts']
var repair_tasks : list[typing.Literal['get_media_buys']]
var supported : Literal[True]
var supports_webhook_activity : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class RenderingOrigin (*args, **kwds)

Expand source code

class RenderingOrigin(StrEnum):
    platform_native = 'platform_native'
    agent_approximation = 'agent_approximation'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var agent_approximation
var platform_native

class ReportingDestinationOffering (**data: Any)

Expand source code

class ReportingDestinationOffering(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    pattern: Pattern
    transports: Annotated[
        list[Transport],
        Field(
            description='Provider transports the seller can deliver through for this pattern.',
            min_length=1,
        ),
    ]
    formats: Annotated[
        list[Format] | None,
        Field(
            description='Physical file formats the seller can produce. Only meaningful for file_transfer.',
            min_length=1,
        ),
    ] = None
    access_modes: Annotated[
        list[AccessMode] | None,
        Field(
            description='Dataset-share access families the seller can provision. Only meaningful for dataset_share.',
            min_length=1,
        ),
    ] = None
    verification_profiles: Annotated[
        reporting_verification_profile_set.ReportingVerificationProfileSet,
        Field(
            description='Verification profiles the seller can produce for this pattern. A destination whose accepted_verification_profiles does not intersect this set is out of offering.'
        ),
    ]

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 access_modes : list[AccessMode] | None
var formats : list[Format] | None
var model_config
var pattern : Pattern
var transports : list[Transport]
var verification_profiles : ReportingVerificationProfileSet

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class RepresentationResolution (**data: Any)

Expand source code

class RepresentationResolution(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported: Annotated[
        Literal[True],
        Field(
            description='True means the agent accepts CreativeRepresentationSet input and returns `representation_selection` or per-candidate structured rejections.'
        ),
    ]
    strategies: Annotated[
        list[representation_selection_strategy.RepresentationSelectionStrategy],
        Field(
            description='Deterministic selection strategies the seller implements after compatibility filtering. `representation_order` selects the first compatible source entry. `highest_compatible_vast` selects the highest exact VAST version from the already-intersected candidate set, with equal-version ties resolved by source array order.',
            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 strategies : list[RepresentationSelectionStrategy]
var supported : Literal[True]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class RequestSigning (**data: Any)

Expand source code

class RequestSigning(AdCPBaseModel):
    supported: Annotated[
        StrictBool,
        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. In AdCP 3.2 and later, an agent with request_signing.supported=true MUST explicitly emit 'required': every accepted signature on a request with a body covers content-digest, and a body-unbound signature is rejected with request_signature_components_incomplete. Omission retains the legacy effective default of 'either' only for a 3.0/3.1 response; 3.2 responses require this field explicitly. 'either' and 'forbidden' are deprecated legacy 3.0/3.1 postures retained only for version negotiation with pre-3.2 peers; they MUST NOT be advertised as a 3.2 signing posture and are removed in 4.0. A shared endpoint MUST select the verifier policy from trusted endpoint configuration and negotiated capabilities before dispatch, never from an unbound request-body version field."
        ),
    ] = None
    required_for: Annotated[
        list[Annotated[str, Field(pattern='^[a-z][a-z0-9_]*$')]] | None,
        Field(
            description="AdCP protocol operation names (e.g., 'create_media_buy') for which this agent rejects an unsigned request with request_signature_required unless an independently valid configured fallback authenticator succeeds. 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.). Every operation listed MUST also appear in `supported_for`; see `x-adcp-validation`.",
            validate_default=True,
        ),
    ] = []
    warn_for: Annotated[
        list[Annotated[str, Field(pattern='^[a-z][a-z0-9_]*$')]] | None,
        Field(
            description='AdCP protocol operation names for shadow-mode verification. The verifier records missing signatures and well-formed signatures that fail verification or body binding, but MUST NOT establish verified-signer identity from a failed signature; processing continues only when an independent bearer, API-key, or mTLS authenticator succeeds. A partial or malformed Signature / Signature-Input pair always hard-rejects. Used as a bridge between supported_for and required_for. Precedence: required_for > warn_for > supported_for. An operation MUST NOT appear in both warn_for and required_for; see x-adcp-validation.',
            validate_default=True,
        ),
    ] = []
    supported_for: Annotated[
        list[Annotated[str, Field(pattern='^[a-z][a-z0-9_]*$')]] | None,
        Field(
            description='AdCP protocol operation names for which this agent verifies signatures when present but does not require them. Under the 3.2 profile, a presented signature on a body-bearing request without content-digest coverage rejects even though an unsigned request may use configured fallback authentication. 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 for which this agent verifies signatures when present. Values MUST use exact, case-sensitive equality after JSON decoding: slash-path names such as 'tasks/cancel' and 'tasks/pushNotificationConfig/set' for A2A 0.3, or PascalCase names such as 'CancelTask' and 'CreateTaskPushNotificationConfig' for A2A 1.0. A dual-stack agent lists each supported wire name independently; implementations MUST NOT translate or normalize between protocol versions. The reserved MCP envelope method 'tools/call' is forbidden because its AdCP operation identity is params.name and belongs in supported_for. Under the 3.2 profile, a presented signature on a body-bearing request without content-digest coverage rejects. Disjoint from supported_for, which carries lower_snake_case AdCP operation names only.",
            validate_default=True,
        ),
    ] = []
    protocol_methods_warn_for: Annotated[
        list[ProtocolMethodsWarnForItem] | None,
        Field(
            description='Exact JSON-RPC protocol method names for shadow-mode verification, mirroring warn_for in the AdCP-operation namespace. Wire-name grammar and exact, case-sensitive matching semantics are identical to protocol_methods_supported_for. Missing signatures and well-formed signatures that fail verification or body binding are recorded but MUST NOT establish verified-signer identity; processing continues only when an independent authenticator succeeds. A partial or malformed Signature / Signature-Input pair always hard-rejects. 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='Exact JSON-RPC protocol method names for which this agent rejects an unsigned request with request_signature_required unless an independently valid configured fallback authenticator succeeds. Wire-name grammar and exact, case-sensitive matching semantics are identical to protocol_methods_supported_for. Separate namespace from required_for: this bucket binds against the JSON-RPC method field, not tools/call params.name. Every listed method 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 : CoversContentDigest | None
var model_config
var protocol_methods_required_for : list[ProtocolMethodsRequiredForItem] | None
var protocol_methods_supported_for : list[ProtocolMethodsSupportedForItem] | None
var protocol_methods_warn_for : list[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 RequiredForItem (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class RequiredForItem(ScalarStr):
    __slots__ = ()
    _constraints = {'pattern': '^[a-z][a-z0-9_]*$'}

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

Subclasses

SupportedForItem
WarnForItem

class Requirement (*args, **kwds)

Expand source code

class Requirement(StrEnum):
    optional = 'optional'
    required = 'required'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var optional
var required

class ResourceType (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class ResourceType(ScalarStr):
    __slots__ = ()
    _constraints = {'max_length': 100, 'min_length': 1, 'pattern': '^[a-z][a-z0-9_.-]{0,99}$'}

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class RightsAttestations (**data: Any)

Expand source code

class RightsAttestations(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    requirement: Annotated[
        Requirement,
        Field(
            description='required means every applicable rights constraint needs at least one current verified attestation evaluation before the creative is eligible to serve. optional permits independent legacy contractual policy, but unattested constraints remain machine-unverified and verification_url is never a downgrade path.'
        ),
    ]

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 requirement : Requirement

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Route (**data: Any)

Expand source code

class Route(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    capability_id: Annotated[
        str,
        Field(
            description='Agent-local creative.supported_formats[].capability_id accepted by preview_creative.',
            pattern='^[a-zA-Z0-9_-]+$',
        ),
    ]
    rendering_origin: Annotated[
        RenderingOrigin,
        Field(
            description="Informational implementation origin. platform_native means the route uses the serving platform's preview machinery; agent_approximation means the agent renders an approximation. Neither value grants authority without a publisher preview_provider delegation."
        ),
    ]

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 capability_id : str
var model_config
var rendering_origin : RenderingOrigin

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class RuntimeAttestations (**data: Any)

Expand source code

class RuntimeAttestations(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    signal_activation: SignalActivation

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 signal_activation : SignalActivation

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class SignalActivation (**data: Any)

Expand source code

class SignalActivation(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    requirement: Annotated[
        Requirement,
        Field(
            description='Whether an activate_signal activation check may omit runtime_attestations. When required, missing evidence fails an activation check. Deactivation and privacy-removal checks never require signal-quality evidence and remain available without it.'
        ),
    ]
    claim_types: Annotated[
        list[AnyUrl],
        Field(
            description='Signal-quality claim identifiers accepted for this governed action. Values are open absolute URIs and MUST be a subset of adcp.attestations.accepted_claim_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 claim_types : list[pydantic.networks.AnyUrl]
var model_config
var requirement : Requirement

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Signals (**data: Any)

Expand source code

class Signals(AdCPBaseModel):
    anonymous_discovery: Annotated[
        StrictBool | None,
        Field(
            description='Whether this agent accepts get_signals discovery without caller credentials in brief or wholesale mode. true means an anonymous discovery request can produce a successful response, but the response may be a public subset and may differ from results for an authenticated principal or selected account. false means get_signals requires an authenticated principal. Absence means unspecified legacy behavior, so callers probe and handle AUTH_MISSING. A valid authenticated request is never rejected merely because credentials were supplied.'
        ),
    ] = None
    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[
        Features | 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 anonymous_discovery : bool | None
var data_provider_domains : list[DataProviderDomain] | None
var discovery_modes : list[DiscoveryMode] | None
var features : Features | None
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class SponsoredIntelligence (**data: Any)

Expand source code

class SponsoredIntelligence(AdCPBaseModel):
    endpoint: Annotated[Endpoint, Field(description='SI agent endpoint configuration')]
    capabilities: Annotated[
        si_capabilities.SiCapabilities,
        Field(description='Modalities, components, and commerce 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 : SiCapabilities
var endpoint : Endpoint
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class SupportedChange (*args, **kwds)

Expand source code

class SupportedChange(StrEnum):
    operator_unit_name = 'operator_unit_name'
    operator_unit = 'operator_unit'
    operator = 'operator'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var operator
var operator_unit
var operator_unit_name

class SupportedDimension (*args, **kwds)

Expand source code

class SupportedDimension(StrEnum):
    total_budget = 'total_budget'
    cpm = 'cpm'
    impressions = 'impressions'
    flight = 'flight'
    product_changes = 'product_changes'
    alternatives = 'alternatives'
    criteria = 'criteria'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var alternatives
var cpm
var criteria
var flight
var impressions
var product_changes
var total_budget

class SupportedForItem (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class SupportedForItem(RequiredForItem):
    pass

A str generated from a JSON Schema string root.

Ancestors

RequiredForItem
adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class SupportedFormat (**data: Any)

Expand source code

class SupportedFormat(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    capability_id: Annotated[
        str | None,
        Field(
            description="Stable identifier for this format capability within the creative agent (e.g., 'audio_narration_30s'). The value MUST be unique across this agent's supported_formats catalog. Route the advertised operation with this ID: build_creative.target_capability_id(s) for build, preview_creative.target_capability_id for preview, or validate_input targets[] kind capability for validate. Capability IDs are agent-local routes and do not appear on portable manifests or products.",
            pattern='^[a-zA-Z0-9_-]+$',
        ),
    ] = None
    format: Annotated[
        creative_operation_format_declaration.CreativeOperationFormatDeclaration,
        Field(
            description='Format declaration on which this agent can perform the listed operations. Creative-agent capability self-description has no seller production authority, so tracker_execution_contract and tracker_execution_contract_digest are forbidden.'
        ),
    ]
    operations: Annotated[
        list[Operation] | None,
        Field(
            description='Creative operations this capability supports. `build` means the agent can produce a conforming manifest via build_creative; `validate` means it can evaluate inputs against the declaration; `preview` means it can render a preview. New 3.2 producers MUST emit this field so buyers and registries can distinguish producers, validators, and renderers without probing tasks. Consumers interpret omission from a legacy 3.x entry as `["build"]`.',
            min_length=1,
        ),
    ] = [Operation.build]

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 capability_id : str | None
var format : CreativeOperationFormatDeclaration
var model_config
var operations : list[Operation] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class SupportedIdentifierType (*args, **kwds)

Expand source code

class SupportedIdentifierType(StrEnum):
    hashed_email = 'hashed_email'
    hashed_phone = 'hashed_phone'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var hashed_email
var hashed_phone

class SupportedOptimizationMetric (*args, **kwds)

Expand source code

class SupportedOptimizationMetric(StrEnum):
    clicks = 'clicks'
    views = 'views'
    completed_views = 'completed_views'
    viewed_seconds = 'viewed_seconds'
    viewable_rate = 'viewable_rate'
    attention_seconds = 'attention_seconds'
    attention_score = 'attention_score'
    engagements = 'engagements'
    follows = 'follows'
    saves = 'saves'
    profile_visits = 'profile_visits'
    reach = 'reach'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var attention_score
var attention_seconds
var clicks
var completed_views
var engagements
var follows
var profile_visits
var reach
var saves
var viewable_rate
var viewed_seconds
var views

class SupportedPresenceMode (*args, **kwds)

Expand source code

class SupportedPresenceMode(StrEnum):
    required = 'required'
    when_available = 'when_available'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var required
var when_available

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 SupportedRequirementMode (*args, **kwds)

Expand source code

class SupportedRequirementMode(StrEnum):
    required = 'required'
    preferred = 'preferred'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var preferred
var required

class SupportedScope (*args, **kwds)

Expand source code

class SupportedScope(StrEnum):
    media_buy = 'media_buy'
    package = 'package'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var media_buy
var package

class SupportedSection (*args, **kwds)

Expand source code

class SupportedSection(StrEnum):
    notification_configs = 'notification_configs'
    reporting_destinations = 'reporting_destinations'
    declarations = 'declarations'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var declarations
var notification_configs
var reporting_destinations

class SupportedTarget (*args, **kwds)

Expand source code

class SupportedTarget(StrEnum):
    cost_per = 'cost_per'
    threshold_rate = 'threshold_rate'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var cost_per
var threshold_rate

class SupportedTarget1 (*args, **kwds)

Expand source code

class SupportedTarget1(StrEnum):
    cost_per = 'cost_per'
    per_ad_spend = 'per_ad_spend'
    maximize_value = 'maximize_value'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var cost_per
var maximize_value
var per_ad_spend

class SupportedVersion (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class SupportedVersion(ScalarStr):
    __slots__ = ()
    _constraints = {
        'pattern': '^(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)(?:-[a-zA-Z0-9](?:[a-zA-Z0-9.-]*[a-zA-Z0-9])?)?$',
    }

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class Targeting (**data: Any)

Expand source code

class Targeting(AdCPBaseModel):
    geo_countries: Annotated[
        StrictBool | None,
        Field(description='Country-level targeting using ISO 3166-1 alpha-2 codes'),
    ] = None
    geo_regions: Annotated[
        StrictBool | geo_region_support.GeographicRegionSupport | None,
        Field(
            description='ISO 3166-2 subdivision inclusion targeting. A legacy boolean is a coarse seller-wide declaration. Structured country/value entries are individually supported within the response scope, but do not promise joint composability or availability through the same execution route or account. Only Product.overlay_support supplies the binding set of executable targeting permissions for a configured Product.'
        ),
    ] = None
    geo_regions_exclude: Annotated[
        StrictBool | geo_region_support.GeographicRegionSupport | None,
        Field(
            description='ISO 3166-2 subdivision exclusion targeting, declared independently from inclusion. Structured country/value entries are individually supported within the response scope, but do not promise joint composability or availability through the same execution route or account. Only Product.overlay_support supplies the binding set of executable targeting permissions for a configured Product; absence means buyers cannot infer exclusion support from geo_regions alone.'
        ),
    ] = None
    geo_metros: Annotated[
        GeoMetros | None,
        Field(
            description='Metro area targeting. Properties indicate which classification systems are supported.'
        ),
    ] = None
    geo_postal_areas: Annotated[
        postal_area_support.PostalAreaSupport | None,
        Field(
            description='Postal area targeting. Prefer the native country-keyed map where each ISO 3166-1 alpha-2 country lists supported country-local postal systems. Deprecated legacy country-fused postal-system boolean aliases may be emitted alongside native country keys during migration.'
        ),
    ] = None
    geo_places: Annotated[
        dict[
            geo_place_system.GeographicPlaceIdentifierSystem,
            geo_place_support.GeographicPlaceSystemSupport,
        ]
        | None,
        Field(
            description='Place targeting support keyed by collision-safe identifier system. Each system declares exact country-to-place-type combinations, accepted catalog versions, and a machine-readable resolver. Sellers MUST reject unsupported systems, country/type pairs, versions, and identifiers rather than silently dropping them.',
            min_length=1,
        ),
    ] = None
    age_restriction: Annotated[
        AgeRestriction | None,
        Field(description='Age restriction capabilities for compliance (alcohol, gambling)'),
    ] = None
    demographics: Annotated[
        Demographics | None,
        Field(
            description='Seller-wide discovery rollup for canonical demographic targeting. supported=true means at least one product implements the demographic targeting contract; it does not authorize demographic targeting on every product. Buyers MUST inspect Product.demographic_targeting for exact execution modes, bounds, intervals, and unknown-age behavior.'
        ),
    ] = None
    language: Annotated[
        StrictBool | Language | None,
        Field(
            description="Language-preference targeting support. A legacy boolean is a coarse declaration. The structured form can enumerate the exact canonical BCP 47 targeting ranges the seller accepts. Buyers MUST treat supported_languages as exact selectable values: a declared 'fr' does not by itself authorize a request for 'fr-CA'. Sellers MUST reject unsupported requested values rather than silently widening or dropping them."
        ),
    ] = 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
    placement_selection: Annotated[
        StrictBool | None,
        Field(
            description='When true, seller-wide rollup indicating at least one product supports targeting_overlay.placement_selection. False or absence makes no product-level promise. Product.overlay_support and Product.placements remain authoritative for a selected product.'
        ),
    ] = None
    property_list: Annotated[
        StrictBool | None,
        Field(
            description='When true, seller-wide rollup indicating at least one product supports targeting_overlay.property_list inclusion targeting. False or absence makes no product-level promise. Product.overlay_support is authoritative.'
        ),
    ] = None
    property_list_exclude: Annotated[
        StrictBool | None,
        Field(
            description='When true, seller-wide rollup indicating at least one product supports targeting_overlay.property_list_exclude targeting. False or absence makes no product-level promise. Product.overlay_support is authoritative.'
        ),
    ] = None
    collection_list: Annotated[
        StrictBool | None,
        Field(
            description='When true, seller-wide rollup indicating at least one product supports targeting_overlay.collection_list inclusion targeting. False or absence makes no product-level promise. Product.overlay_support is authoritative.'
        ),
    ] = None
    collection_list_exclude: Annotated[
        StrictBool | None,
        Field(
            description='When true, seller-wide rollup indicating at least one product supports targeting_overlay.collection_list_exclude targeting. False or absence makes no product-level promise. Product.overlay_support is authoritative.'
        ),
    ] = 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 : AgeRestriction | None
var collection_list : bool | None
var collection_list_exclude : bool | None
var demographics : Demographics | None
var geo_countries : bool | None
var geo_metros : GeoMetros | None
var geo_places : dict[GeographicPlaceIdentifierSystem1 | GeographicPlaceIdentifierSystem2, GeographicPlaceSystemSupport] | None
var geo_postal_areas : PostalAreaSupport | None
var geo_proximity : GeoProximity | None
var geo_regions : bool | GeographicRegionSupport | None
var geo_regions_exclude : bool | GeographicRegionSupport | None
var keyword_targets : KeywordTargets | None
var language : bool | Language | None
var model_config
var negative_keywords : NegativeKeywords | None
var placement_selection : bool | None
var property_list : bool | None
var property_list_exclude : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

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

Expand source code

class Tasks(
    RootModel[Tasks1 | Tasks2 | Tasks3 | Tasks4 | Tasks5 | Tasks6 | Tasks7 | Tasks8 | Tasks9]
):
    root: Annotated[
        Tasks1 | Tasks2 | Tasks3 | Tasks4 | Tasks5 | Tasks6 | Tasks7 | Tasks8 | Tasks9,
        Field(discriminator='task'),
    ]
    def __getattr__(self, name: str) -> Any:
        """Proxy attribute access to the wrapped type."""
        if name.startswith('_'):
            raise AttributeError(name)
        return getattr(self.root, name)

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[Union[Tasks1, Tasks2, Tasks3, Tasks4, Tasks5, Tasks6, Tasks7, Tasks8, Tasks9]]
pydantic.root_model.RootModel
pydantic.main.BaseModel
typing.Generic

Class variables

var model_config
var root : Tasks1 | Tasks2 | Tasks3 | Tasks4 | Tasks5 | Tasks6 | Tasks7 | Tasks8 | Tasks9

class Tasks1 (**data: Any)

Expand source code

class Tasks1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    task: Literal['create_media_buy'] = 'create_media_buy'
    modes: Annotated[list[Mode], Field(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 modes : list[Mode]
var task : Literal['create_media_buy']

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Tasks2 (**data: Any)

Expand source code

class Tasks2(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    task: Literal['update_media_buy'] = 'update_media_buy'
    modes: Annotated[list[Mode], Field(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 modes : list[Mode]
var task : Literal['update_media_buy']

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Tasks3 (**data: Any)

Expand source code

class Tasks3(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    task: Literal['buy_products'] = 'buy_products'
    modes: Annotated[list[Mode], Field(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 modes : list[Mode]
var task : Literal['buy_products']

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Tasks4 (**data: Any)

Expand source code

class Tasks4(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    task: Literal['accept_proposal'] = 'accept_proposal'
    modes: Annotated[list[Mode], Field(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 modes : list[Mode]
var task : Literal['accept_proposal']

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Tasks5 (**data: Any)

Expand source code

class Tasks5(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    task: Literal['control_media_buy'] = 'control_media_buy'
    modes: Annotated[list[Mode], Field(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 modes : list[Mode]
var task : Literal['control_media_buy']

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Tasks6 (**data: Any)

Expand source code

class Tasks6(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    task: Literal['build_creative'] = 'build_creative'
    modes: Annotated[list[Literal['signed_context']], Field(max_length=1, 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 modes : list[typing.Literal['signed_context']]
var task : Literal['build_creative']

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Tasks7 (**data: Any)

Expand source code

class Tasks7(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    task: Literal['activate_signal'] = 'activate_signal'
    modes: Annotated[list[Literal['signed_context']], Field(max_length=1, 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 modes : list[typing.Literal['signed_context']]
var task : Literal['activate_signal']

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Tasks8 (**data: Any)

Expand source code

class Tasks8(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    task: Literal['acquire_rights'] = 'acquire_rights'
    modes: Annotated[list[Literal['signed_context']], Field(max_length=1, 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 modes : list[typing.Literal['signed_context']]
var task : Literal['acquire_rights']

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Tasks9 (**data: Any)

Expand source code

class Tasks9(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    task: Literal['update_rights'] = 'update_rights'
    modes: Annotated[list[Literal['signed_context']], Field(max_length=1, 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 modes : list[typing.Literal['signed_context']]
var task : Literal['update_rights']

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Transport (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class Transport(ScalarStr):
    __slots__ = ()
    _constraints = {'max_length': 64, 'min_length': 1, 'pattern': '^[a-z][a-z0-9_.-]*$'}

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

Subclasses

AccessMode

class Transport1 (**data: Any)

Expand source code

class Transport1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    type: Annotated[Type6, 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 : Type6
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[property_type.PropertyType] | 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[PropertyType] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Type (*args, **kwds)

Expand source code

class Type(StrEnum):
    binary = 'binary'
    quantitative = 'quantitative'
    categorical = 'categorical'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var binary
var categorical
var quantitative

class Type6 (*args, **kwds)

Expand source code

class Type6(StrEnum):
    mcp = 'mcp'
    a2a = 'a2a'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var a2a
var mcp

class VariantDimension (*args, **kwds)

Expand source code

class VariantDimension(StrEnum):
    voice = 'voice'
    theme = 'theme'
    best_of_n = 'best_of_n'
    transformer_config = 'transformer_config'
    custom = 'custom'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var best_of_n
var custom
var theme
var transformer_config
var voice

class VastValidation (*args, **kwds)

Expand source code

class VastValidation(StrEnum):
    structural = 'structural'
    document = 'document'
    wrapper = 'wrapper'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var document
var structural
var wrapper

class VendorMetricOptimization (**data: Any)

Expand source code

class VendorMetricOptimization(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported_targets: Annotated[
        list[SupportedTarget] | None,
        Field(
            description='Target kinds this seller can support for vendor_metric optimization goals on at least one product. Values match optimization_goals[].target.kind for kind: vendor_metric. A target-less vendor_metric goal maximizes the metric within budget and does not require a target-kind declaration.',
            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 model_config
var supported_targets : list[SupportedTarget] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class WarnForItem (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class WarnForItem(RequiredForItem):
    pass

A str generated from a JSON Schema string root.

Ancestors

RequiredForItem
adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class WebhookSigning (**data: Any)

Expand source code

class WebhookSigning(AdCPBaseModel):
    supported: Annotated[
        StrictBool,
        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, `media_buy.relationship_notifications.supported` is true, `wholesale_feed_webhooks.supported` is true, `adcp.capability_changes.notifications.supported` is true, or `account.notifications.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[
        StrictBool | None,
        Field(
            deprecated=True,
            description='Whether this agent will fall back to HMAC-SHA256 on the legacy push_notification_config.authentication, accounts[].notification_configs[].authentication, sync_principal.configuration.notification_configs[].authentication, or sync_agent_notification_configs.notification_configs[].authentication paths for receivers that have not adopted RFC 9421. Deprecated; removed in AdCP 4.0.',
        ),
    ] = False
    delivery_retry_horizon_seconds: Annotated[
        SchemaInt | None,
        Field(
            description='Maximum elapsed time from the first delivery attempt during which this agent may retry the same webhook delivery. The publisher retains the immutable delivery-key-to-RFC-8785-JCS-payload binding and sufficient delivery state for at least this interval, and MUST NOT retry that key afterward. Receivers retain the matching payload binding and terminal publication proof for at least max(86400, this value) seconds in AdCP 3.x. Retries do not extend the horizon. A webhook-emitting AdCP 3.2 agent MUST populate this additive field; it remains schema-optional so existing 3.x capability documents stay valid. Minimum 86400 (24h), maximum 604800 (7d).',
            ge=86400,
            le=604800,
        ),
    ] = 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 algorithms : list[Algorithm] | None
var delivery_retry_horizon_seconds : int | 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

class WholesaleFeedVersioning (**data: Any)

Expand source code

class WholesaleFeedVersioning(AdCPBaseModel):
    supported: Annotated[
        StrictBool,
        Field(
            description='Whether the agent returns wholesale_feed_version on responses and honors if_wholesale_feed_version on requests. When absent, treated as false; buyers MAY still probe (the field-presence detection path) but cannot pre-flight-decide.'
        ),
    ]
    pricing_version_separate: Annotated[
        StrictBool | None,
        Field(
            description="Whether the agent tracks pricing_version independently of wholesale_feed_version. When true, the agent returns both tokens and honors if_pricing_version separately — useful for rate-card sweeps that don't change product and signal metadata. When false or absent, the agent collapses both into wholesale_feed_version; callers SHOULD NOT send if_pricing_version (it will be ignored and may produce INVALID_REQUEST when sent without if_wholesale_feed_version per the dependencies rule)."
        ),
    ] = None
    cache_scope_account: Annotated[
        StrictBool | None,
        Field(
            description="Whether the agent ever returns cache_scope: 'account' (i.e., publishes per-account overlays distinct from the public rate card). When true, buyers MUST be prepared to maintain account-overlay caches alongside the public layer. When false or absent, all responses are cache_scope: 'public' regardless of whether account was provided — the agent's rate card is universal. Confidentiality note: declaring true advertises that the agent runs custom-pricing deals (low-grade market-posture signal); agents preferring not to disclose this MAY omit the field and let consumers detect-on-call via cache_scope on response."
        ),
    ] = 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 cache_scope_account : bool | None
var model_config
var pricing_version_separate : bool | None
var supported : bool

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class WholesaleFeedWebhooks (**data: Any)

Expand source code

class WholesaleFeedWebhooks(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    supported: Annotated[
        StrictBool,
        Field(
            description='Whether this agent can push wholesale feed change payloads through account-level sync_accounts.accounts[].notification_configs[]. When false or absent, consumers fall back to wholesale polling, optionally with if_wholesale_feed_version probes.'
        ),
    ]
    event_types: Annotated[
        list[EventType3] | None,
        Field(
            description='Wholesale feed webhook event types this agent can emit. Sales agents emit product.* events and MUST expose list_products or the deprecated 3.x wholesale get_products compatibility path. Signals agents emit signal.* events and MUST support wholesale get_signals. wholesale_feed.bulk_change requires at least one corresponding repair path.',
            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_types : list[EventType3] | None
var model_config
var supported : bool

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary