@adcp/sdk 5.25.1 → 6.1.0

package/dist/lib/server/decisioning/runtime/validate-platform.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Runtime validation that a `DecisioningPlatform` impl matches its
+ * `capabilities.specialisms[]` declaration.
+ *
+ * Compile-time, `RequiredPlatformsFor<S>` enforces this in TypeScript adopter
+ * code. Untyped JS callers, downstream packages with relaxed `tsconfig`, and
+ * Python-port adopters running this through bindings need a runtime gate.
+ *
+ * Mirrors the v1.0 specialism × interface mapping in
+ * `src/lib/server/decisioning/platform.ts`.
+ *
+ * @public
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformConfigError = void 0;
+exports.validatePlatform = validatePlatform;
+const SPECIALISM_REQUIREMENTS = {
+    // All sales-* specialisms share the SalesPlatform interface. Adopters
+    // implement `sales` once; the specialism enum picks which buyer-side
+    // storyboard the agent is validated against. Wired here per the AdCP 3.0
+    // GA enum; preview specialisms (sales-streaming-tv, sales-exchange,
+    // sales-retail-media) get added when they land in `AdCPSpecialism`.
+    'sales-non-guaranteed': ['sales'],
+    'sales-guaranteed': ['sales'],
+    'sales-broadcast-tv': ['sales'],
+    'sales-social': ['sales'],
+    'sales-catalog-driven': ['sales'],
+    'sales-proposal-mode': ['sales'],
+    // Creative specialisms share the CreativeXxxPlatform field name; adopters
+    // pick the right archetype (template / generative / ad-server) at
+    // construction time.
+    'creative-template': ['creative'],
+    'creative-generative': ['creative'],
+    'creative-ad-server': ['creative'],
+    // Audience sync is a single specialism with a single platform interface.
+    'audience-sync': ['audiences'],
+    // Signal specialisms — both share the SignalsPlatform interface.
+    // Marketplace = third-party data brokers; owned = first-party providers.
+    'signal-marketplace': ['signals'],
+    'signal-owned': ['signals'],
+    // Campaign governance — today's two specialisms share one platform
+    // interface; consolidates to `campaign-governance` when adcp#3329 lands.
+    'governance-spend-authority': ['campaignGovernance'],
+    'governance-delivery-monitor': ['campaignGovernance'],
+    // Property + collection list publishing.
+    'property-lists': ['propertyLists'],
+    'collection-lists': ['collectionLists'],
+    // Content standards — brand-safety / policy compliance enforcement.
+    'content-standards': ['contentStandards'],
+    // Brand-rights — identity discovery + licensing for branded inventory.
+    // 3 of 5 wire tools wire through `brandRights`; the other 2
+    // (`update_rights`, `creative_approval`) await AdcpToolMap landing
+    // and stay on the merge-seam path until then.
+    'brand-rights': ['brandRights'],
+};
+class PlatformConfigError extends Error {
+    name = 'PlatformConfigError';
+    constructor(message) {
+        super(message);
+    }
+}
+exports.PlatformConfigError = PlatformConfigError;
+// Note on HITL tools: the v6 unified shape collapses sync/HITL into a
+// single method per tool whose return type is `Success | TaskHandoff<Success>`.
+// Adopters branch in the body and call `ctx.handoffToTask(fn)` to defer
+// to a background task. The framework detects the handoff marker at the
+// dispatch seam — there's no exactly-one validation needed because the
+// shape is the same regardless of which path the adopter takes.
+//
+// This applies to `create_media_buy` and `sync_creatives` today (the 2
+// spec-listed tools whose per-tool response oneOf includes the Submitted
+// arm). When adcontextprotocol/adcp#3392 lands, the same shape extends
+// to `update_media_buy`, `build_creative`, `sync_catalogs`, `get_products`.
+function validatePlatform(platform) {
+    const claimed = platform.capabilities?.specialisms ?? [];
+    const errors = [];
+    // 1. Specialism declarations match required interfaces
+    for (const specialism of claimed) {
+        const required = SPECIALISM_REQUIREMENTS[specialism];
+        if (!required)
+            continue; // forward-compat for unknown specialisms
+        for (const field of required) {
+            if (platform[field] == null) {
+                errors.push(`capabilities.specialisms claims '${specialism}'; platform.${String(field)} is missing`);
+            }
+        }
+    }
+    if (errors.length > 0) {
+        throw new PlatformConfigError(`DecisioningPlatform configuration is incomplete:\n  - ${errors.join('\n  - ')}`);
+    }
+}
+//# sourceMappingURL=validate-platform.js.map

package/dist/lib/server/decisioning/runtime/validate-platform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-platform.js","sourceRoot":"","sources":["../../../../../src/lib/server/decisioning/runtime/validate-platform.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;AAgEH,4CAkBC;AA7ED,MAAM,uBAAuB,GAA8E;IACzG,sEAAsE;IACtE,qEAAqE;IACrE,yEAAyE;IACzE,oEAAoE;IACpE,oEAAoE;IACpE,sBAAsB,EAAE,CAAC,OAAO,CAAC;IACjC,kBAAkB,EAAE,CAAC,OAAO,CAAC;IAC7B,oBAAoB,EAAE,CAAC,OAAO,CAAC;IAC/B,cAAc,EAAE,CAAC,OAAO,CAAC;IACzB,sBAAsB,EAAE,CAAC,OAAO,CAAC;IACjC,qBAAqB,EAAE,CAAC,OAAO,CAAC;IAChC,0EAA0E;IAC1E,kEAAkE;IAClE,qBAAqB;IACrB,mBAAmB,EAAE,CAAC,UAAU,CAAC;IACjC,qBAAqB,EAAE,CAAC,UAAU,CAAC;IACnC,oBAAoB,EAAE,CAAC,UAAU,CAAC;IAClC,yEAAyE;IACzE,eAAe,EAAE,CAAC,WAAW,CAAC;IAC9B,iEAAiE;IACjE,yEAAyE;IACzE,oBAAoB,EAAE,CAAC,SAAS,CAAC;IACjC,cAAc,EAAE,CAAC,SAAS,CAAC;IAC3B,mEAAmE;IACnE,yEAAyE;IACzE,4BAA4B,EAAE,CAAC,oBAAoB,CAAC;IACpD,6BAA6B,EAAE,CAAC,oBAAoB,CAAC;IACrD,yCAAyC;IACzC,gBAAgB,EAAE,CAAC,eAAe,CAAC;IACnC,kBAAkB,EAAE,CAAC,iBAAiB,CAAC;IACvC,oEAAoE;IACpE,mBAAmB,EAAE,CAAC,kBAAkB,CAAC;IACzC,uEAAuE;IACvE,4DAA4D;IAC5D,mEAAmE;IACnE,8CAA8C;IAC9C,cAAc,EAAE,CAAC,aAAa,CAAC;CAChC,CAAC;AAEF,MAAa,mBAAoB,SAAQ,KAAK;IACnC,IAAI,GAAG,qBAA8B,CAAC;IAC/C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;CACF;AALD,kDAKC;AAED,sEAAsE;AACtE,gFAAgF;AAChF,wEAAwE;AACxE,wEAAwE;AACxE,uEAAuE;AACvE,gEAAgE;AAChE,EAAE;AACF,uEAAuE;AACvE,yEAAyE;AACzE,uEAAuE;AACvE,4EAA4E;AAE5E,SAAgB,gBAAgB,CAAC,QAA6B;IAC5D,MAAM,OAAO,GAAG,QAAQ,CAAC,YAAY,EAAE,WAAW,IAAI,EAAE,CAAC;IACzD,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,uDAAuD;IACvD,KAAK,MAAM,UAAU,IAAI,OAAO,EAAE,CAAC;QACjC,MAAM,QAAQ,GAAG,uBAAuB,CAAC,UAAU,CAAC,CAAC;QACrD,IAAI,CAAC,QAAQ;YAAE,SAAS,CAAC,yCAAyC;QAClE,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;YAC7B,IAAI,QAAQ,CAAC,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC;gBAC5B,MAAM,CAAC,IAAI,CAAC,oCAAoC,UAAU,eAAe,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;YACvG,CAAC;QACH,CAAC;IACH,CAAC;IAED,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,mBAAmB,CAAC,yDAAyD,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAClH,CAAC;AACH,CAAC"}

package/dist/lib/server/decisioning/specialisms/audiences.d.ts

@@ -0,0 +1,72 @@
+/**
+ * AudiencePlatform — cross-cutting audience-sync specialism (v1.0).
+ *
+ * Used standalone (LiveRamp, Oracle Data Cloud, Salesforce CDP) or
+ * composed with sales-social (Snap/Meta/TikTok). Framework owns
+ * cross-platform threading; platform answers "given this audience, what
+ * happened on my system?"
+ *
+ * Status: Preview / 6.0. Not yet wired into the framework.
+ *
+ * @public
+ */
+import type { Account } from '../account';
+import type { RequestContext } from '../context';
+import type { SyncAudiencesRequest, SyncAudiencesSuccess } from '../../../types/tools.generated';
+type Ctx<TCtxMeta> = RequestContext<Account<TCtxMeta>>;
+/**
+ * The wire schema doesn't export a top-level `Audience` type; the shape lives
+ * inline on `SyncAudiencesRequest.audiences[]`. Extract it here so platform
+ * implementations have a name to type against.
+ */
+export type Audience = NonNullable<SyncAudiencesRequest['audiences']>[number];
+/**
+ * Wire success-row shape for `sync_audiences`. Returning the array of these
+ * rows from `syncAudiences` is what adopters write — the framework wraps
+ * with `{ audiences: [...] }` to form `SyncAudiencesSuccess`.
+ *
+ * `action` enum is the wire spec's: `'created' | 'updated' | 'unchanged' |
+ * 'deleted' | 'failed'`. Note: `'rejected'` is NOT a valid wire action
+ * value — use `'failed'` for buyer-rejected audiences.
+ */
+export type SyncAudiencesRow = SyncAudiencesSuccess['audiences'][number];
+export type AudienceStatus = NonNullable<SyncAudiencesRow['status']>;
+export interface AudiencePlatform<TCtxMeta = Record<string, unknown>> {
+    /**
+     * Push audiences to the platform. Framework handles batching, idempotency,
+     * cross-tenant scoping. Platform handles match-rate computation and
+     * activation lifecycle.
+     *
+     * Sync acknowledgment with status changes via `publishStatusChange`:
+     * return per-audience result rows immediately (`pending` / `matching` are
+     * valid sync outcomes). The match-rate computation and activation
+     * pipeline run in the background — the platform calls
+     * `publishStatusChange({ resource_type: 'audience', ... })` from its
+     * webhook handler / job queue / cron when each audience reaches a
+     * terminal state.
+     *
+     * Throw `new AdcpError(...)` for buyer-fixable rejection
+     * (`AUDIENCE_TOO_SMALL`, etc.).
+     */
+    syncAudiences(audiences: Audience[], ctx: Ctx<TCtxMeta>): Promise<SyncAudiencesRow[]>;
+    /**
+     * Batch-poll current status for one or more audiences. Sync — this is a
+     * state-read, not a mutating operation. Useful for buyer-side polling
+     * outside the framework's task envelope (e.g., querying long-lived
+     * audiences) and for adapter code that needs to check N audiences at
+     * once.
+     *
+     * Returns a `Map<audience_id, AudienceStatus>`. Audiences not found are
+     * omitted from the map (callers handle missing keys); throw
+     * `AdcpError('REFERENCE_NOT_FOUND')` only when the entire batch is
+     * unresolvable for the tenant.
+     *
+     * Single-audience polling is `pollAudienceStatuses([id], ctx).then(m =>
+     * m.get(id))`. The batch shape composes with upstream identity-graph
+     * APIs that natively return per-audience-id arrays — adopters do NOT
+     * need to wrap a single-id lookup over an N-call loop.
+     */
+    pollAudienceStatuses(audienceIds: readonly string[], ctx: Ctx<TCtxMeta>): Promise<Map<string, AudienceStatus>>;
+}
+export {};
+//# sourceMappingURL=audiences.d.ts.map

package/dist/lib/server/decisioning/specialisms/audiences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audiences.d.ts","sourceRoot":"","sources":["../../../../../src/lib/server/decisioning/specialisms/audiences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAEjG,KAAK,GAAG,CAAC,QAAQ,IAAI,cAAc,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;AAEvD;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG,WAAW,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9E;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzE,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAAC;AAErE,MAAM,WAAW,gBAAgB,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAClE;;;;;;;;;;;;;;;OAeG;IACH,aAAa,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAEtF;;;;;;;;;;;;;;;;OAgBG;IACH,oBAAoB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC;CAChH"}

package/dist/lib/server/decisioning/specialisms/audiences.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * AudiencePlatform — cross-cutting audience-sync specialism (v1.0).
+ *
+ * Used standalone (LiveRamp, Oracle Data Cloud, Salesforce CDP) or
+ * composed with sales-social (Snap/Meta/TikTok). Framework owns
+ * cross-platform threading; platform answers "given this audience, what
+ * happened on my system?"
+ *
+ * Status: Preview / 6.0. Not yet wired into the framework.
+ *
+ * @public
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=audiences.js.map

package/dist/lib/server/decisioning/specialisms/audiences.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audiences.js","sourceRoot":"","sources":["../../../../../src/lib/server/decisioning/specialisms/audiences.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG"}

package/dist/lib/server/decisioning/specialisms/brand-rights.d.ts

@@ -0,0 +1,92 @@
+/**
+ * BrandRightsPlatform — `brand-rights` specialism (v1.0).
+ *
+ * Brand-rights agents handle identity discovery + licensing for branded
+ * inventory — covers IP holders (sports leagues, movie studios), CTV
+ * brand-rights desks, and brand-licensing marketplaces. Adopters
+ * implement the three wire tools the spec ships with stable schemas
+ * AND framework dispatch infrastructure (in `AdcpToolMap`):
+ *
+ *   - `get_brand_identity` — sync read; brand catalog + identity record
+ *   - `get_rights` — sync read; rights matching a brand + use query
+ *   - `acquire_rights` — buyer commits to an offering. Async outcomes
+ *     are delivered via the buyer-supplied `push_notification_config`
+ *     webhook (NOT a polling tool — the spec doesn't define one for
+ *     this surface).
+ *
+ * The two other surfaces in this domain (`update_rights`,
+ * `creative_approval`) are spec-published but not yet in `AdcpToolMap`;
+ * adopters wire them via the merge seam (`opts.brandRights.*`) until
+ * they land in v6.1.
+ *
+ * Status: Preview / 6.0.
+ *
+ * @public
+ */
+import type { Account } from '../account';
+import type { RequestContext } from '../context';
+import type { GetBrandIdentityRequest, GetBrandIdentitySuccess, GetRightsRequest, GetRightsSuccess, AcquireRightsRequest, AcquireRightsAcquired, AcquireRightsPendingApproval, AcquireRightsRejected } from '../../../types/core.generated';
+type Ctx<TCtxMeta> = RequestContext<Account<TCtxMeta>>;
+export interface BrandRightsPlatform<TCtxMeta = Record<string, unknown>> {
+    /**
+     * Read brand identity record — `brand_id`, `house`, localized `names`,
+     * optional logos / industries / `keller_type`. Sync; no async ceremony.
+     * Throw `AdcpError('REFERENCE_NOT_FOUND')` when the brand reference
+     * doesn't resolve to an identity the platform tracks.
+     */
+    getBrandIdentity(req: GetBrandIdentityRequest, ctx: Ctx<TCtxMeta>): Promise<GetBrandIdentitySuccess>;
+    /**
+     * List rights matching a brand + use query. Sync read; framework
+     * wraps the response in the wire envelope. Returning an empty
+     * `rights` array is valid (= "no rights available for the requested
+     * terms"); throw `AdcpError` only for buyer-fixable rejection (e.g.,
+     * unsupported jurisdiction).
+     *
+     * Note: the wire field is `rights`, NOT `offerings`. Adopters who
+     * named their internal model `offerings` translate at this seam.
+     */
+    getRights(req: GetRightsRequest, ctx: Ctx<TCtxMeta>): Promise<GetRightsSuccess>;
+    /**
+     * Acquire rights — buyer commits to an offering. Four wire-spec arms:
+     *
+     *   - `AcquireRightsAcquired` — rights granted immediately. Carries
+     *     `rights_id`, `status: 'acquired'`, `brand_id`, `terms`,
+     *     `generation_credentials` (scoped per-LLM-provider keys), and
+     *     `rights_constraint` so the buyer can plumb the grant directly
+     *     into creative generation.
+     *   - `AcquireRightsPendingApproval` — clearance pending counter-
+     *     signature, legal review, or rights-holder approval. Carries
+     *     `rights_id`, `status: 'pending_approval'`, `brand_id`, plus
+     *     optional `detail` and `estimated_response_time` (e.g., '48h').
+     *     **Async delivery is webhook-only** — the buyer's
+     *     `push_notification_config.url` receives the eventual
+     *     `Acquired` or `Rejected` outcome. The spec does NOT define
+     *     a polling tool for `acquire_rights`; do not reach for
+     *     `tasks_get` here.
+     *   - `AcquireRightsRejected` — terminal rejection. Carries
+     *     `rights_id`, `status: 'rejected'`, `brand_id`, `reason`,
+     *     and optional `suggestions[]` for buyer remediation.
+     *
+     * The wire spec also defines a fourth `AcquireRightsError` arm
+     * (multi-error `{ errors: Error[] }`) for batch-style failures.
+     * Adopters who need that shape throw
+     * `AdcpError('INVALID_REQUEST', { details: { errors: [...] } })`
+     * — the framework projects to the same wire envelope. The platform
+     * interface accepts only the 3 success-arm shapes by design;
+     * `AdcpError` is the canonical multi-error path here, matching
+     * `SalesPlatform.createMediaBuy` preflight.
+     *
+     * Throw `AdcpError` only for buyer-fixable REQUEST rejection
+     * (`INVALID_REQUEST`, `BUDGET_TOO_LOW`). For spec-defined GRANT
+     * rejection (rights unavailable in jurisdiction, talent dispute
+     * pending) return the `AcquireRightsRejected` arm so the buyer sees
+     * the structured wire response with `reason` + `suggestions`.
+     *
+     * Pre-flight (catalog availability, agency authorization) MUST run
+     * sync regardless of arm — invalid requests reject before allocating
+     * any state.
+     */
+    acquireRights(req: AcquireRightsRequest, ctx: Ctx<TCtxMeta>): Promise<AcquireRightsAcquired | AcquireRightsPendingApproval | AcquireRightsRejected>;
+}
+export {};
+//# sourceMappingURL=brand-rights.d.ts.map

package/dist/lib/server/decisioning/specialisms/brand-rights.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brand-rights.d.ts","sourceRoot":"","sources":["../../../../../src/lib/server/decisioning/specialisms/brand-rights.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAMjD,OAAO,KAAK,EACV,uBAAuB,EACvB,uBAAuB,EACvB,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,4BAA4B,EAC5B,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AAEvC,KAAK,GAAG,CAAC,QAAQ,IAAI,cAAc,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;AAEvD,MAAM,WAAW,mBAAmB,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACrE;;;;;OAKG;IACH,gBAAgB,CAAC,GAAG,EAAE,uBAAuB,EAAE,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAErG;;;;;;;;;OASG;IACH,SAAS,CAAC,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAEhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACH,aAAa,CACX,GAAG,EAAE,oBAAoB,EACzB,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GACjB,OAAO,CAAC,qBAAqB,GAAG,4BAA4B,GAAG,qBAAqB,CAAC,CAAC;CAC1F"}

package/dist/lib/server/decisioning/specialisms/brand-rights.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * BrandRightsPlatform — `brand-rights` specialism (v1.0).
+ *
+ * Brand-rights agents handle identity discovery + licensing for branded
+ * inventory — covers IP holders (sports leagues, movie studios), CTV
+ * brand-rights desks, and brand-licensing marketplaces. Adopters
+ * implement the three wire tools the spec ships with stable schemas
+ * AND framework dispatch infrastructure (in `AdcpToolMap`):
+ *
+ *   - `get_brand_identity` — sync read; brand catalog + identity record
+ *   - `get_rights` — sync read; rights matching a brand + use query
+ *   - `acquire_rights` — buyer commits to an offering. Async outcomes
+ *     are delivered via the buyer-supplied `push_notification_config`
+ *     webhook (NOT a polling tool — the spec doesn't define one for
+ *     this surface).
+ *
+ * The two other surfaces in this domain (`update_rights`,
+ * `creative_approval`) are spec-published but not yet in `AdcpToolMap`;
+ * adopters wire them via the merge seam (`opts.brandRights.*`) until
+ * they land in v6.1.
+ *
+ * Status: Preview / 6.0.
+ *
+ * @public
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=brand-rights.js.map

package/dist/lib/server/decisioning/specialisms/brand-rights.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brand-rights.js","sourceRoot":"","sources":["../../../../../src/lib/server/decisioning/specialisms/brand-rights.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG"}

package/dist/lib/server/decisioning/specialisms/campaign-governance.d.ts

@@ -0,0 +1,67 @@
+/**
+ * CampaignGovernancePlatform — runtime governance decisioning for advertiser
+ * campaigns (v6.0).
+ *
+ * Today's AdCP 3.0 GA enum splits this role across two specialism values:
+ *
+ *   - `governance-spend-authority` — agent gates spending decisions
+ *   - `governance-delivery-monitor` — agent monitors delivery actuals
+ *
+ * Both describe one role (a governance agent that makes runtime decisions
+ * for advertiser campaigns), differing only by capability. This single
+ * interface covers both. When `adcontextprotocol/adcp#3329` lands and the
+ * spec consolidates to `campaign-governance`, we rename the type without
+ * shape changes.
+ *
+ * Shape: a decision API. The agent inspects a proposed action (or running
+ * delivery) and returns `approved`, `denied`, or `conditions` (approved-if).
+ * Status changes (plan moving from `pending_approval` → `active` → `closed`)
+ * flow via `publishStatusChange({ resource_type: 'plan', ... })`.
+ *
+ * Sync at the wire level — `CheckGovernanceResponse` has no `Submitted`
+ * arm. Slow approval pipelines (operator review) return current state
+ * (e.g., `pending`) and emit status changes when the human decision lands.
+ *
+ * Status: Preview / 6.0.
+ *
+ * @public
+ */
+import type { Account } from '../account';
+import type { RequestContext } from '../context';
+import type { CheckGovernanceRequest, CheckGovernanceResponse, SyncPlansRequest, SyncPlansResponse, ReportPlanOutcomeRequest, ReportPlanOutcomeResponse, GetPlanAuditLogsRequest, GetPlanAuditLogsResponse } from '../../../types/tools.generated';
+type Ctx<TCtxMeta> = RequestContext<Account<TCtxMeta>>;
+export interface CampaignGovernancePlatform<TCtxMeta = Record<string, unknown>> {
+    /**
+     * Runtime governance decision. Buyer (or seller, on the seller's behalf)
+     * sends a proposed action; the agent inspects it against the plan and
+     * returns approved / denied / conditions.
+     *
+     * The `phase` field discriminates the context: `'intent'` (pre-action),
+     * `'delivery'` (running campaign with actuals), `'reconciliation'`
+     * (post-flight). The agent's logic varies by phase.
+     *
+     * Throw `AdcpError` for buyer-fixable rejection
+     * (`'PLAN_NOT_FOUND'`, `'INVALID_REQUEST'`, etc.). Use the response
+     * `status: 'denied'` for governance decisions that ARE the answer
+     * (the plan exists and the agent is rejecting the action).
+     */
+    checkGovernance(req: CheckGovernanceRequest, ctx: Ctx<TCtxMeta>): Promise<CheckGovernanceResponse>;
+    /**
+     * Plan CRUD. Buyers sync their campaign plans into the governance
+     * agent so the agent can maintain spend authority + delivery context.
+     */
+    syncPlans(req: SyncPlansRequest, ctx: Ctx<TCtxMeta>): Promise<SyncPlansResponse>;
+    /**
+     * Outcome reporting. Sellers report what actually happened (impressions
+     * delivered, spend incurred, status transitions) so the agent can
+     * calibrate future decisions.
+     */
+    reportPlanOutcome(req: ReportPlanOutcomeRequest, ctx: Ctx<TCtxMeta>): Promise<ReportPlanOutcomeResponse>;
+    /**
+     * Audit log read. Returns the chronological history of governance
+     * decisions + outcome reports for a plan.
+     */
+    getPlanAuditLogs(req: GetPlanAuditLogsRequest, ctx: Ctx<TCtxMeta>): Promise<GetPlanAuditLogsResponse>;
+}
+export {};
+//# sourceMappingURL=campaign-governance.d.ts.map

package/dist/lib/server/decisioning/specialisms/campaign-governance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"campaign-governance.d.ts","sourceRoot":"","sources":["../../../../../src/lib/server/decisioning/specialisms/campaign-governance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EACV,sBAAsB,EACtB,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACxB,yBAAyB,EACzB,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,gCAAgC,CAAC;AAExC,KAAK,GAAG,CAAC,QAAQ,IAAI,cAAc,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;AAEvD,MAAM,WAAW,0BAA0B,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC5E;;;;;;;;;;;;;OAaG;IACH,eAAe,CAAC,GAAG,EAAE,sBAAsB,EAAE,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAEnG;;;OAGG;IACH,SAAS,CAAC,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAEjF;;;;OAIG;IACH,iBAAiB,CAAC,GAAG,EAAE,wBAAwB,EAAE,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAAC;IAEzG;;;OAGG;IACH,gBAAgB,CAAC,GAAG,EAAE,uBAAuB,EAAE,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;CACvG"}

package/dist/lib/server/decisioning/specialisms/campaign-governance.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * CampaignGovernancePlatform — runtime governance decisioning for advertiser
+ * campaigns (v6.0).
+ *
+ * Today's AdCP 3.0 GA enum splits this role across two specialism values:
+ *
+ *   - `governance-spend-authority` — agent gates spending decisions
+ *   - `governance-delivery-monitor` — agent monitors delivery actuals
+ *
+ * Both describe one role (a governance agent that makes runtime decisions
+ * for advertiser campaigns), differing only by capability. This single
+ * interface covers both. When `adcontextprotocol/adcp#3329` lands and the
+ * spec consolidates to `campaign-governance`, we rename the type without
+ * shape changes.
+ *
+ * Shape: a decision API. The agent inspects a proposed action (or running
+ * delivery) and returns `approved`, `denied`, or `conditions` (approved-if).
+ * Status changes (plan moving from `pending_approval` → `active` → `closed`)
+ * flow via `publishStatusChange({ resource_type: 'plan', ... })`.
+ *
+ * Sync at the wire level — `CheckGovernanceResponse` has no `Submitted`
+ * arm. Slow approval pipelines (operator review) return current state
+ * (e.g., `pending`) and emit status changes when the human decision lands.
+ *
+ * Status: Preview / 6.0.
+ *
+ * @public
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=campaign-governance.js.map

package/dist/lib/server/decisioning/specialisms/campaign-governance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"campaign-governance.js","sourceRoot":"","sources":["../../../../../src/lib/server/decisioning/specialisms/campaign-governance.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG"}

package/dist/lib/server/decisioning/specialisms/content-standards.d.ts

@@ -0,0 +1,78 @@
+/**
+ * ContentStandardsPlatform — `content-standards` specialism (v6.0).
+ *
+ * Content standards enforcement: brand safety policies, content adjacency
+ * rules, and per-creative compliance verification. Adopters who claim
+ * `content-standards` in `capabilities.specialisms[]` implement this
+ * interface; the framework wires the 6 wire tools that make up the
+ * content-standards surface.
+ *
+ * Two adopter shapes:
+ *
+ *   - **Standalone content-standards agent** (Innovid-style): runs apart
+ *     from a sales agent; buyers call `list_content_standards` /
+ *     `get_content_standards` / `validate_content_delivery` directly.
+ *   - **Composed within a seller** (governance overlay): seller imports
+ *     content-standards into its agent surface, calls `calibrate_content`
+ *     internally during creative review, and surfaces violations through
+ *     `sync_creatives` review state.
+ *
+ * Both shapes use the same interface; difference is whether the platform
+ * field is populated alongside `sales` or as the only specialism.
+ *
+ * The two analyzer methods (`getMediaBuyArtifacts`, `getCreativeFeatures`)
+ * are listed under the same surface in the framework's `GovernanceHandlers`
+ * because they're content-feature reads adopters typically expose alongside
+ * the policy CRUD. Optional — adopters who don't run analyzer pipelines
+ * leave them undefined.
+ *
+ * Status: Preview / 6.0.
+ *
+ * @public
+ */
+import type { Account } from '../account';
+import type { RequestContext } from '../context';
+import type { ListContentStandardsRequest, ListContentStandardsResponse, GetContentStandardsRequest, GetContentStandardsResponse, CreateContentStandardsRequest, CreateContentStandardsResponse, UpdateContentStandardsRequest, UpdateContentStandardsResponse, CalibrateContentRequest, CalibrateContentResponse, ValidateContentDeliveryRequest, ValidateContentDeliveryResponse, GetMediaBuyArtifactsRequest, GetMediaBuyArtifactsResponse, GetCreativeFeaturesRequest, GetCreativeFeaturesResponse } from '../../../types/tools.generated';
+type Ctx<TCtxMeta> = RequestContext<Account<TCtxMeta>>;
+export interface ContentStandardsPlatform<TCtxMeta = Record<string, unknown>> {
+    /** Discover content standards published by this agent. */
+    listContentStandards(req: ListContentStandardsRequest, ctx: Ctx<TCtxMeta>): Promise<ListContentStandardsResponse>;
+    /** Read a single content standard by id. */
+    getContentStandards(req: GetContentStandardsRequest, ctx: Ctx<TCtxMeta>): Promise<GetContentStandardsResponse>;
+    /**
+     * Create a new content standard. Adopter validates the policy schema
+     * and returns the persisted record. Idempotent on the buyer's
+     * `idempotency_key`.
+     */
+    createContentStandards(req: CreateContentStandardsRequest, ctx: Ctx<TCtxMeta>): Promise<CreateContentStandardsResponse>;
+    /** Update an existing content standard. */
+    updateContentStandards(req: UpdateContentStandardsRequest, ctx: Ctx<TCtxMeta>): Promise<UpdateContentStandardsResponse>;
+    /**
+     * Calibrate content against the published standards. Returns the
+     * standard's current calibration profile + any flags raised against
+     * the submitted content.
+     */
+    calibrateContent(req: CalibrateContentRequest, ctx: Ctx<TCtxMeta>): Promise<CalibrateContentResponse>;
+    /**
+     * Validate that a delivered media-buy / creative meets the buyer's
+     * declared content-standards. Sellers call this post-flight to confirm
+     * adjacency and policy conformance before issuing a
+     * `validate_content_delivery_artifact` to a governance agent.
+     */
+    validateContentDelivery(req: ValidateContentDeliveryRequest, ctx: Ctx<TCtxMeta>): Promise<ValidateContentDeliveryResponse>;
+    /**
+     * Read content artifacts produced during a media buy's flight (creative
+     * proofs, ad-server tags, completed log captures). Optional — adopters
+     * who don't expose artifact archival omit. Required by governance
+     * receivers running adjacency validation.
+     */
+    getMediaBuyArtifacts?(req: GetMediaBuyArtifactsRequest, ctx: Ctx<TCtxMeta>): Promise<GetMediaBuyArtifactsResponse>;
+    /**
+     * Read per-creative analyzed features (object detection, scene
+     * classification, transcript) the agent extracted during calibration.
+     * Optional — adopters without analyzer pipelines omit.
+     */
+    getCreativeFeatures?(req: GetCreativeFeaturesRequest, ctx: Ctx<TCtxMeta>): Promise<GetCreativeFeaturesResponse>;
+}
+export {};
+//# sourceMappingURL=content-standards.d.ts.map

package/dist/lib/server/decisioning/specialisms/content-standards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-standards.d.ts","sourceRoot":"","sources":["../../../../../src/lib/server/decisioning/specialisms/content-standards.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EACV,2BAA2B,EAC3B,4BAA4B,EAC5B,0BAA0B,EAC1B,2BAA2B,EAC3B,6BAA6B,EAC7B,8BAA8B,EAC9B,6BAA6B,EAC7B,8BAA8B,EAC9B,uBAAuB,EACvB,wBAAwB,EACxB,8BAA8B,EAC9B,+BAA+B,EAC/B,2BAA2B,EAC3B,4BAA4B,EAC5B,0BAA0B,EAC1B,2BAA2B,EAC5B,MAAM,gCAAgC,CAAC;AAExC,KAAK,GAAG,CAAC,QAAQ,IAAI,cAAc,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;AAEvD,MAAM,WAAW,wBAAwB,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC1E,0DAA0D;IAC1D,oBAAoB,CAAC,GAAG,EAAE,2BAA2B,EAAE,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAAC;IAElH,4CAA4C;IAC5C,mBAAmB,CAAC,GAAG,EAAE,0BAA0B,EAAE,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAC;IAE/G;;;;OAIG;IACH,sBAAsB,CACpB,GAAG,EAAE,6BAA6B,EAClC,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GACjB,OAAO,CAAC,8BAA8B,CAAC,CAAC;IAE3C,2CAA2C;IAC3C,sBAAsB,CACpB,GAAG,EAAE,6BAA6B,EAClC,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GACjB,OAAO,CAAC,8BAA8B,CAAC,CAAC;IAE3C;;;;OAIG;IACH,gBAAgB,CAAC,GAAG,EAAE,uBAAuB,EAAE,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAEtG;;;;;OAKG;IACH,uBAAuB,CACrB,GAAG,EAAE,8BAA8B,EACnC,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GACjB,OAAO,CAAC,+BAA+B,CAAC,CAAC;IAE5C;;;;;OAKG;IACH,oBAAoB,CAAC,CAAC,GAAG,EAAE,2BAA2B,EAAE,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAAC;IAEnH;;;;OAIG;IACH,mBAAmB,CAAC,CAAC,GAAG,EAAE,0BAA0B,EAAE,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAC;CACjH"}

package/dist/lib/server/decisioning/specialisms/content-standards.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * ContentStandardsPlatform — `content-standards` specialism (v6.0).
+ *
+ * Content standards enforcement: brand safety policies, content adjacency
+ * rules, and per-creative compliance verification. Adopters who claim
+ * `content-standards` in `capabilities.specialisms[]` implement this
+ * interface; the framework wires the 6 wire tools that make up the
+ * content-standards surface.
+ *
+ * Two adopter shapes:
+ *
+ *   - **Standalone content-standards agent** (Innovid-style): runs apart
+ *     from a sales agent; buyers call `list_content_standards` /
+ *     `get_content_standards` / `validate_content_delivery` directly.
+ *   - **Composed within a seller** (governance overlay): seller imports
+ *     content-standards into its agent surface, calls `calibrate_content`
+ *     internally during creative review, and surfaces violations through
+ *     `sync_creatives` review state.
+ *
+ * Both shapes use the same interface; difference is whether the platform
+ * field is populated alongside `sales` or as the only specialism.
+ *
+ * The two analyzer methods (`getMediaBuyArtifacts`, `getCreativeFeatures`)
+ * are listed under the same surface in the framework's `GovernanceHandlers`
+ * because they're content-feature reads adopters typically expose alongside
+ * the policy CRUD. Optional — adopters who don't run analyzer pipelines
+ * leave them undefined.
+ *
+ * Status: Preview / 6.0.
+ *
+ * @public
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=content-standards.js.map

package/dist/lib/server/decisioning/specialisms/content-standards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-standards.js","sourceRoot":"","sources":["../../../../../src/lib/server/decisioning/specialisms/content-standards.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG"}

package/dist/lib/server/decisioning/specialisms/creative-ad-server.d.ts

@@ -0,0 +1,81 @@
+/**
+ * CreativeAdServerPlatform — third creative archetype (v6.0).
+ *
+ * Stateful creative library + per-creative pricing + tag generation. The
+ * canonical shape for creative-ad-server adopters: Innovid, Flashtalking,
+ * GAM-creative, CMP-style platforms.
+ *
+ * Distinct from `CreativeTemplatePlatform` (stateless transform) and
+ * `CreativeGenerativePlatform` (brief-driven generation):
+ *
+ *   - **Stateful** — adopter persists creatives in a library; `syncCreatives`
+ *     pushes assets in, `listCreatives` reads them back, `buildCreative`
+ *     either looks up an existing creative by id OR pushes a new one
+ *   - **Pricing per creative** — vendor pricing options on each creative;
+ *     `pricing_option_id` selected at activation, billed via `report_usage`
+ *   - **Tag generation** — `buildCreative` returns ad-server tags (VAST,
+ *     placement-specific tracking pixels, macro-substituted creative HTML)
+ *     when invoked with `media_buy_id` + `package_id` context
+ *   - **Per-creative delivery reports** — `get_creative_delivery` returns
+ *     pacing data per creative across the library
+ *
+ * Status: Preview / 6.0.
+ *
+ * @public
+ */
+import type { Account } from '../account';
+import type { RequestContext } from '../context';
+import type { TaskHandoff } from '../async-outcome';
+import type { BuildCreativeRequest, CreativeManifest, PreviewCreativeRequest, PreviewCreativeResponse, ListCreativesRequest, ListCreativesResponse, GetCreativeDeliveryRequest, GetCreativeDeliveryResponse, CreativeAsset, BuildCreativeSuccess, BuildCreativeMultiSuccess } from '../../../types/tools.generated';
+import type { SyncCreativesRow } from './sales';
+type Creative = CreativeAsset;
+type Ctx<TCtxMeta> = RequestContext<Account<TCtxMeta>>;
+export interface CreativeAdServerPlatform<TCtxMeta = Record<string, unknown>> {
+    /**
+     * Build / retrieve creative tags. Two invocation modes per the spec:
+     *
+     *   - **Library lookup**: `req.creative_id` references an existing
+     *     creative; return the manifest with tag fields populated
+     *     (`vast_tag`, click trackers, etc.). When `req.media_buy_id` +
+     *     `req.package_id` are also set, generate placement-specific tags
+     *     with macro substitution baked in.
+     *   - **Inline build**: `req.creative_manifest` is provided directly;
+     *     transform / wrap it (similar to template archetype but with
+     *     ad-server side effects: register the creative in the library,
+     *     generate the tag, etc.).
+     *
+     * Spec defines a Submitted arm via `async-response-data.json` but the
+     * per-tool `build-creative-response.json` `oneOf` doesn't include it,
+     * so codegen produces a `BuildCreativeResponse` without Submitted —
+     * a SPEC inconsistency, tracked as adcontextprotocol/adcp#3392. Until
+     * that lands, slow tag-generation pipelines await in-request; status
+     * changes flow via `publishStatusChange`.
+     */
+    buildCreative(req: BuildCreativeRequest, ctx: Ctx<TCtxMeta>): Promise<CreativeManifest | CreativeManifest[] | BuildCreativeSuccess | BuildCreativeMultiSuccess>;
+    /** Preview-only variant — sandbox URL or inline HTML, expires. Always sync. */
+    previewCreative(req: PreviewCreativeRequest, ctx: Ctx<TCtxMeta>): Promise<PreviewCreativeResponse>;
+    /**
+     * Push creatives. Return per-creative result rows (sync fast path) OR
+     * `ctx.handoffToTask(fn)` to promote to a background task (HITL —
+     * brand-suitability, S&P review). `action: 'created'` for new entries,
+     * `'updated'` for replacements, `'unchanged'` when matching. Optional
+     * `status: 'pending_review'` for sync-arm rows awaiting manual review.
+     */
+    syncCreatives?(creatives: Creative[], ctx: Ctx<TCtxMeta>): Promise<SyncCreativesRow[] | TaskHandoff<SyncCreativesRow[]>>;
+    /**
+     * Read creatives from the library. Filters + pagination. When
+     * `req.include_assignments`, include the buyer's package-assignment
+     * graph. When `req.include_pricing`, include vendor pricing options
+     * on each creative.
+     */
+    listCreatives(req: ListCreativesRequest, ctx: Ctx<TCtxMeta>): Promise<ListCreativesResponse>;
+    /**
+     * Per-creative delivery actuals (impressions, spend, pacing). Sync —
+     * report-running platforms with manual report cycles return the
+     * latest cached actuals and emit `delivery_report` status changes
+     * via `publishStatusChange` when fresh reports are available.
+     */
+    getCreativeDelivery(filter: GetCreativeDeliveryRequest, ctx: Ctx<TCtxMeta>): Promise<GetCreativeDeliveryResponse>;
+}
+export {};
+//# sourceMappingURL=creative-ad-server.d.ts.map