@adcp/sdk 6.13.2 → 6.14.0

package/dist/lib/version.js

@@ -11,11 +11,11 @@ exports.parseAdcpMajorVersion = parseAdcpMajorVersion;
 /**
  * AdCP SDK library version
  */
-exports.LIBRARY_VERSION = '6.13.2';
+exports.LIBRARY_VERSION = '6.14.0';
 /**
  * AdCP specification version this library is built for
  */
-exports.ADCP_VERSION = '3.0.6';
+exports.ADCP_VERSION = '3.0.7';
 /**
  * AdCP major version sent with every request (adcp_major_version field).
  * Sellers validate this against their supported versions and return
@@ -38,15 +38,16 @@ exports.COMPATIBLE_ADCP_VERSIONS = [
     '3.0.4',
     '3.0.5',
     '3.0.6',
+    '3.0.7',
 ];
 /**
  * Full version information
  */
 exports.VERSION_INFO = {
-    library: '6.13.2',
-    adcp: '3.0.6',
+    library: '6.14.0',
+    adcp: '3.0.7',
     compatibleVersions: exports.COMPATIBLE_ADCP_VERSIONS,
-    generatedAt: '2026-05-08T10:37:20.162Z',
+    generatedAt: '2026-05-08T13:17:43.198Z',
 };
 /**
  * Get the AdCP specification version this library is built for

package/dist/lib/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/lib/version.ts"],"names":[],"mappings":";AAAA,gCAAgC;AAChC,iDAAiD;;;AA4DjD,wCAEC;AAKD,8CAEC;AAKD,4CAEC;AAKD,sDAEC;AAWD,sDAKC;AAjGD;;GAEG;AACU,QAAA,eAAe,GAAG,QAAQ,CAAC;AAExC;;GAEG;AACU,QAAA,YAAY,GAAG,OAAO,CAAC;AAEpC;;;;GAIG;AACU,QAAA,kBAAkB,GAAG,CAAC,CAAC;AAEpC;;GAEG;AACU,QAAA,wBAAwB,GAAG;IACtC,MAAM;IACN,MAAM;IACN,IAAI;IACJ,cAAc;IACd,cAAc;IACd,OAAO;IACP,OAAO;IACP,OAAO;IACP,OAAO;IACP,OAAO;IACP,OAAO;IACP,OAAO;CACC,CAAC;AAYX;;GAEG;AACU,QAAA,YAAY,GAAG;IAC1B,OAAO,EAAE,QAAQ;IACjB,IAAI,EAAE,OAAO;IACb,kBAAkB,EAAE,gCAAwB;IAC5C,WAAW,EAAE,0BAA0B;CAC/B,CAAC;AAEX;;GAEG;AACH,SAAgB,cAAc;IAC5B,OAAO,oBAAY,CAAC;AACtB,CAAC;AAED;;GAEG;AACH,SAAgB,iBAAiB;IAC/B,OAAO,uBAAe,CAAC;AACzB,CAAC;AAED;;GAEG;AACH,SAAgB,gBAAgB,CAAC,WAAmB;IAClD,OAAQ,gCAA8C,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AAC/E,CAAC;AAED;;GAEG;AACH,SAAgB,qBAAqB;IACnC,OAAO,gCAAwB,CAAC;AAClC,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,qBAAqB,CAAC,OAAe;IACnD,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAC/B,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;IACxE,MAAM,KAAK,GAAG,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IAC3D,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC;AAC9C,CAAC"}
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/lib/version.ts"],"names":[],"mappings":";AAAA,gCAAgC;AAChC,iDAAiD;;;AA6DjD,wCAEC;AAKD,8CAEC;AAKD,4CAEC;AAKD,sDAEC;AAWD,sDAKC;AAlGD;;GAEG;AACU,QAAA,eAAe,GAAG,QAAQ,CAAC;AAExC;;GAEG;AACU,QAAA,YAAY,GAAG,OAAO,CAAC;AAEpC;;;;GAIG;AACU,QAAA,kBAAkB,GAAG,CAAC,CAAC;AAEpC;;GAEG;AACU,QAAA,wBAAwB,GAAG;IACtC,MAAM;IACN,MAAM;IACN,IAAI;IACJ,cAAc;IACd,cAAc;IACd,OAAO;IACP,OAAO;IACP,OAAO;IACP,OAAO;IACP,OAAO;IACP,OAAO;IACP,OAAO;IACP,OAAO;CACC,CAAC;AAYX;;GAEG;AACU,QAAA,YAAY,GAAG;IAC1B,OAAO,EAAE,QAAQ;IACjB,IAAI,EAAE,OAAO;IACb,kBAAkB,EAAE,gCAAwB;IAC5C,WAAW,EAAE,0BAA0B;CAC/B,CAAC;AAEX;;GAEG;AACH,SAAgB,cAAc;IAC5B,OAAO,oBAAY,CAAC;AACtB,CAAC;AAED;;GAEG;AACH,SAAgB,iBAAiB;IAC/B,OAAO,uBAAe,CAAC;AACzB,CAAC;AAED;;GAEG;AACH,SAAgB,gBAAgB,CAAC,WAAmB;IAClD,OAAQ,gCAA8C,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AAC/E,CAAC;AAED;;GAEG;AACH,SAAgB,qBAAqB;IACnC,OAAO,gCAAwB,CAAC;AAClC,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,qBAAqB,CAAC,OAAe;IACnD,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAC/B,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;IACxE,MAAM,KAAK,GAAG,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IAC3D,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC;AAC9C,CAAC"}

package/docs/guides/BUILD-AN-AGENT.md

@@ -12,38 +12,28 @@ We'll build a **signals agent** that serves audience segments via the `get_signa
 - `@adcp/sdk` installed (`npm install @adcp/sdk`)
 - `@modelcontextprotocol/sdk` (installed as a dependency of `@adcp/sdk`)
 
-## Two paths
-
-`@adcp/sdk` exposes two server entry points. Pick based on the agent
-shape:
-
-- **`createAdcpServerFromPlatform`** — **recommended for new agents.**
-  You declare a typed `DecisioningPlatform` (per-specialism interfaces:
-  `SalesCorePlatform` + `SalesIngestionPlatform`, `CreativeBuilderPlatform`,
-  `AudiencePlatform`, `SignalsPlatform`, `CampaignGovernancePlatform`,
-  `BrandRightsPlatform`, etc.) and the framework wires capability
-  projection, idempotency, RFC 9421 signing, async tasks, status
-  normalization, lifecycle state, multi-tenant routing, and webhook
-  auto-emit on sync mutations. Compile-time enforcement via
-  `RequiredPlatformsFor<S>` catches missing methods before runtime.
-  6.7 `definePlatform` / `defineSalesCorePlatform` / etc. helpers let
-  you write inline platform literals without `req: unknown` casts.
-- **`createAdcpServer`** — the lower-level handler-bag API. Still
-  fully supported (it's the substrate `createAdcpServerFromPlatform`
-  calls into) but lives at `@adcp/sdk/server/legacy/v5` in 6.x.
-  Reach for it only when mid-migration from a v5 codebase, when you
-  need a custom-shaped tool the platform interface doesn't yet model,
-  or when you've decided to own the whole handler bag yourself. The
-  appendix at the bottom of this guide covers it.
+## The server entry point
+
+`@adcp/sdk` exposes `createAdcpServerFromPlatform` as the server entry
+point. You declare a typed `DecisioningPlatform` (per-specialism
+interfaces: `SalesCorePlatform` + `SalesIngestionPlatform`,
+`CreativeBuilderPlatform`, `AudiencePlatform`, `SignalsPlatform`,
+`CampaignGovernancePlatform`, `BrandRightsPlatform`, etc.) and the
+framework wires capability projection, idempotency, RFC 9421 signing,
+async tasks, status normalization, lifecycle state, multi-tenant
+routing, and webhook auto-emit on sync mutations. Compile-time
+enforcement via `RequiredPlatformsFor<S>` catches missing methods
+before runtime. The `definePlatform` / `defineSalesCorePlatform` /
+sibling helpers let you write inline platform literals without
+`req: unknown` casts.
 
 For multi-specialism production agents (sales + creative + governance +
-brand-rights), see `docs/migration-5.x-to-6.x.md` and
-`docs/migration-6.6-to-6.7.md`. The `examples/hello_*` family is the
-copy-paste starting point for each specialism.
+brand-rights), the `examples/hello_*` family is the copy-paste
+starting point for each specialism.
 
 ## Quick Start
 
-A minimal signals agent using `createAdcpServerFromPlatform` + the v6
+A minimal signals agent using `createAdcpServerFromPlatform` + the
 `definePlatform` / `defineSignalsPlatform` identity helpers:
 
 ```typescript
@@ -288,7 +278,7 @@ import { AdcpError } from '@adcp/sdk/server';
 throw new AdcpError('CUSTOM_CODE', { recovery: 'terminal', message: '...', details: { foo: 'bar' } });
 ```
 
-All surface as `isError: true` on the wire and skip response-schema validation. The lower-level `adcpError(code, ...)` *return value* form is a v5-substrate pattern; in 6.x, prefer throwing the typed class.
+All surface as `isError: true` on the wire and skip response-schema validation. Prefer throwing the typed class.
 
 **7 domain groups:**
 
@@ -541,7 +531,7 @@ See [SIGNING-GUIDE.md](./SIGNING-GUIDE.md) for the full walkthrough: key generat
 
 ### createTaskCapableServer (Low-Level)
 
-For advanced cases where you need direct control over MCP tool registration, schema wiring, and response formatting. `createAdcpServer` (the legacy v5 substrate) uses this internally; `createAdcpServerFromPlatform` calls into `createAdcpServer`.
+For advanced cases where you need direct control over MCP tool registration, schema wiring, and response formatting. `createAdcpServerFromPlatform` calls into this internally.
 
 ```typescript
 import { createTaskCapableServer, taskToolResponse, GetSignalsRequestSchema } from '@adcp/sdk';
@@ -585,13 +575,12 @@ return wrapEnvelope(
 
 ### Response Builders
 
-With `createAdcpServerFromPlatform` (and the legacy `createAdcpServer` substrate), response builders are applied automatically — return raw data and the framework wraps it. If you need manual control (e.g., with `createTaskCapableServer`), builders are available:
+With `createAdcpServerFromPlatform`, response builders are applied automatically — return raw data and the framework wraps it. If you need manual control (e.g., with `createTaskCapableServer`), builders are available:
 
 ```typescript
 import { productsResponse, mediaBuyResponse, deliveryResponse, taskToolResponse } from '@adcp/sdk';
-// For error envelopes, throw a typed error class (recipe #6 in the 6.6→6.7 migration doc)
-// — `AuthRequiredError`, `PermissionDeniedError`, `RateLimitedError`, etc. — instead of
-// returning the legacy `adcpError(code, ...)` envelope from the v5 substrate.
+// For error envelopes, throw a typed error class — `AuthRequiredError`,
+// `PermissionDeniedError`, `RateLimitedError`, etc. — from `@adcp/sdk/server`.
 ```
 
 ### Task Statuses (Server-Side Contract)
@@ -606,7 +595,7 @@ When your agent receives a tool call, it returns one of these statuses. The buye
 | `input_required` | Need clarification from buyer | Fires buyer's `InputHandler` callback with the question |
 | `deferred` | Requires human decision | Returns a token; human resumes later via `result.deferred.resume()` |
 
-With `createAdcpServerFromPlatform` (or the legacy `createAdcpServer`), synchronous handlers return raw data and the framework sets `completed` automatically. With `createTaskCapableServer`, use `taskToolResponse()` explicitly.
+With `createAdcpServerFromPlatform`, synchronous handlers return raw data and the framework sets `completed` automatically. With `createTaskCapableServer`, use `taskToolResponse()` explicitly.
 
 For async tools that need background processing, use `registerAdcpTaskTool()`:
 
@@ -649,7 +638,7 @@ throw new ServiceUnavailableError({ retryAfterSeconds: 30 });
 throw new PermissionDeniedError('account_access', { message: 'Contact support' });
 ```
 
-For codes without a typed wrapper, `throw new AdcpError('CUSTOM_CODE', { recovery, message })` is the raw escape hatch. v5 adopters who used `return adcpError('CODE', '...')` (the return-value form) keep working under the legacy substrate, but v6 adopters should throw.
+For codes without a typed wrapper, `throw new AdcpError('CUSTOM_CODE', { recovery, message })` is the raw escape hatch.
 
 > **Heads-up for buyer-agent authors**: four codes are spec-`correctable` but operator-semantically human-escalate — don't auto-mutate-and-retry on `POLICY_VIOLATION`, `COMPLIANCE_UNSATISFIED`, `GOVERNANCE_DENIED`, or `AUTH_REQUIRED`. Surface to the user. (`AUTH_REQUIRED` conflates missing-creds with revoked-creds; until [adcontextprotocol/adcp#3730](https://github.com/adcontextprotocol/adcp/issues/3730) splits these, treat as escalate.) See `skills/call-adcp-agent/SKILL.md` for the full callout.
 
@@ -778,7 +767,7 @@ See [`examples/signals-agent.ts`](../../examples/signals-agent.ts) for a complet
 See [`examples/error-compliant-server.ts`](../../examples/error-compliant-server.ts) for a media buy agent demonstrating:
 
 - Multiple tools (`get_products`, `create_media_buy`, `get_media_buy_delivery`)
-- Structured error handling (the example uses the v5 `adcpError(...)` return-value form; v6 adopters throw the typed error classes from `@adcp/sdk/server` — `AuthRequiredError`, `RateLimitedError`, etc. — see § "Returning errors from handlers")
+- Structured error handling (throw the typed error classes from `@adcp/sdk/server` — `AuthRequiredError`, `RateLimitedError`, etc. — see § "Returning errors from handlers")
 - Rate limiting
 - Business logic validation
 

package/docs/llms.txt

@@ -1,7 +1,7 @@
 # Ad Context Protocol (AdCP)
 
-> Generated at: 2026-05-03
-> Library: @adcp/sdk v6.8.0
+> Generated at: 2026-05-08
+> Library: @adcp/sdk v6.11.0
 > AdCP major version: 3
 > Canonical URL: https://adcontextprotocol.github.io/adcp-client/llms.txt
 > Note: the `Library` stamp reflects the package.json version at doc-generation time. The narrative below describes the surface that lands on the next-published minor — including any 6.7 helpers documented here ahead of the release tag.
@@ -1188,12 +1188,12 @@ Run compliance tests with `adcp test <agent> <scenario>`. 24 built-in scenarios:
 
 ### Seeding fixtures for compliance (seller-side)
 
-Group A storyboards seed fixtures via `comply_test_controller.seed_product` (and the other `seed_*` scenarios) before calling the spec tool. Two SDK helpers bridge this to `createAdcpServer`:
+Group A storyboards seed fixtures via `comply_test_controller.seed_product` (and the other `seed_*` scenarios) before calling the spec tool. Two SDK helpers bridge this:
 
 - **`mergeSeedProduct`** (plus `mergeSeedPricingOption`, `mergeSeedCreative`, `mergeSeedPlan`, `mergeSeedMediaBuy`): permissive merge of a sparse storyboard fixture onto the seller's baseline defaults. `undefined`/`null` keep base; arrays replace by default; well-known id-keyed lists (`pricing_options`, `publisher_properties`, `packages`, `assets`, plan `findings`) overlay by id so seeding one entry doesn't drop the rest.
 - **`bridgeFromTestControllerStore(store, productDefaults)`**: wires a `Map<string, unknown>` seed store into `get_products` responses automatically. Sandbox requests merge seeded + handler products (seeded wins collisions); production traffic (no sandbox marker, or a resolved non-sandbox account) skips the bridge.
 
-Wire on `createAdcpServer({ testController: bridgeFromTestControllerStore(store, baseline) })`. See `skills/build-seller-agent/SKILL.md` for the full pattern alongside `createComplyController`.
+Wire on `createAdcpServerFromPlatform(platform, { testController: bridgeFromTestControllerStore(store, baseline) })`. See `skills/build-seller-agent/SKILL.md` for the full pattern alongside `createComplyController`.
 
 ### Anti-façade upstream-traffic recording (`@adcp/sdk/upstream-recorder`)
 

package/examples/hello_seller_adapter_proposal_mode.ts

@@ -529,6 +529,13 @@ const platform: DecisioningPlatform<unknown, NetworkMeta> = {
     channels: ['olv', 'ctv', 'display'],
     pricingModels: ['cpm'],
     config: undefined,
+    // Declare the comply_test_controller surface so the conformance runner
+    // grades missing scenarios as `not_applicable` rather than `failed`. The
+    // framework auto-derives the `scenarios` list from the `complyTest`
+    // adapter set wired below.
+    compliance_testing: {
+      scenarios: ['force_media_buy_status', 'simulate_delivery'],
+    },
   },
   accounts,
   proposalManager,
@@ -544,6 +551,21 @@ const proposalStore = new InMemoryProposalStore<GAMLikeRecipe>();
 const stateStore = new InMemoryStateStore();
 const mediaBuyStore = createMediaBuyStore({ store: stateStore });
 
+// ─── TEST-ONLY: in-memory state for comply_test_controller adapters ─────
+// DELETE THESE MAPS BEFORE DEPLOYING (or scope per-tenant if you keep the
+// controller wired in a sandbox tenant). Module-scope shared maps leak
+// state across accounts — that's fine for a worked example whose only
+// caller is the conformance harness, but unacceptable in production.
+// SWAP: scope by `account.id` (or your tenant key) and persist via the
+// same data layer your production handlers read from. The controller
+// and production tools should share one source of truth for state.
+const seededMediaBuys = new Map<string, { status: string; revision: number }>();
+const simulatedDelivery = new Map<
+  string,
+  { impressions: number; clicks: number; reported_spend: { amount: number; currency: string } }
+>();
+// ─── /TEST-ONLY ──────────────────────────────────────────────────────────
+
 serve(
   ({ taskStore }) =>
     createAdcpServerFromPlatform(platform, {
@@ -559,6 +581,55 @@ serve(
         const acct = ctx.account as Account<NetworkMeta> | undefined;
         return acct?.id ?? 'anonymous';
       },
+      // ─── TEST-ONLY: comply_test_controller wiring ──────────────────────
+      // DELETE THIS BLOCK BEFORE DEPLOYING. The conformance runner uses
+      // `comply_test_controller` to seed media-buy fixtures and force
+      // state transitions across cascade scenarios in the broader
+      // `sales_proposal_mode` storyboard suite (delivery_reporting,
+      // invalid_transitions, pending_creatives_to_start). The
+      // `proposal_finalize` storyboard itself doesn't invoke the
+      // controller, but the surface is wired here for parity with the
+      // other reference seller adapters.
+      //
+      // No `sandboxGate` here — the framework gate inside
+      // `createAdcpServerFromPlatform` admits via the resolved account's
+      // `mode === 'sandbox'`. Production refs flow through the live path
+      // with the field unset (default `'live'`), so the framework gate
+      // refuses dispatch for them.
+      complyTest: {
+        seed: {
+          media_buy: ({ media_buy_id, fixture }) => {
+            const existing = seededMediaBuys.get(media_buy_id);
+            const status = typeof fixture['status'] === 'string' ? (fixture['status'] as string) : 'pending_creatives';
+            seededMediaBuys.set(media_buy_id, { status, revision: existing?.revision ?? 0 });
+          },
+        },
+        force: {
+          media_buy_status: ({ media_buy_id, status, rejection_reason }) => {
+            const buy = seededMediaBuys.get(media_buy_id);
+            const previous = buy?.status ?? 'pending_creatives';
+            seededMediaBuys.set(media_buy_id, { status, revision: (buy?.revision ?? 0) + 1 });
+            void rejection_reason;
+            return { success: true, previous_state: previous, current_state: status };
+          },
+        },
+        simulate: {
+          delivery: ({ media_buy_id, impressions, clicks, reported_spend }) => {
+            const prev = simulatedDelivery.get(media_buy_id) ?? {
+              impressions: 0,
+              clicks: 0,
+              reported_spend: { amount: 0, currency: 'USD' },
+            };
+            simulatedDelivery.set(media_buy_id, {
+              impressions: prev.impressions + (impressions ?? 0),
+              clicks: prev.clicks + (clicks ?? 0),
+              reported_spend: reported_spend ?? prev.reported_spend,
+            });
+            return { success: true, simulated: { media_buy_id, impressions, clicks, reported_spend } };
+          },
+        },
+      },
+      // ─── /TEST-ONLY ──────────────────────────────────────────────────
     }),
   {
     port: PORT,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adcp/sdk",
-  "version": "6.13.2",
+  "version": "6.14.0",
   "description": "AdCP SDK — client, server, and compliance harnesses for the AdContext Protocol (MCP + A2A)",
   "workspaces": [
     ".",
@@ -361,5 +361,5 @@
     },
     "minimatch": "^10.2.1"
   },
-  "adcp_version": "3.0.6"
+  "adcp_version": "3.0.7"
 }

package/skills/build-decisioning-creative-template/SKILL.md

@@ -1,28 +1,28 @@
 ---
 name: build-decisioning-creative-template
-description: Build an AdCP v6.0 creative-template decisioning platform — a stateless creative transform service (TTS, watermarking, format conversion, template fill). Use when the user wants the v6.0 DecisioningPlatform shape; for the lower-level handler-bag API, use `build-creative-agent` instead.
+description: Build an AdCP creative-template decisioning platform — a stateless creative transform service (TTS, watermarking, format conversion, template fill). Use when the user wants the typed `DecisioningPlatform` shape; for fork-an-adapter starting points, see `build-creative-agent`.
 ---
 
-# Build a Creative-Template Decisioning Platform (v6.0)
+# Build a Creative-Template Decisioning Platform
 
 You're building a **stateless creative transform** service that fits the AdCP `creative-template` specialism: take an input creative manifest + format spec, produce an output creative manifest. No library, no review queue, no persisting state. Examples: TTS audio synthesis, image watermarking, video format conversion, template-based ad generation.
 
 ## When this skill applies
 
-- User wants a creative-template service on the **v6.0 DecisioningPlatform** surface
+- User wants a creative-template service against the typed `DecisioningPlatform` surface
 - Specialism: `creative-template` (stateless transform; not `creative-ad-server` which is stateful, not `creative-generative` which is brief-driven — though `creative-template` and `creative-generative` share the same `CreativeBuilderPlatform` interface; pick the specialism ID that matches your behavior)
-- SDK package: `@adcp/sdk` 6.0+
+- SDK package: `@adcp/sdk`
 
 **Wrong skill if:**
 
-- User wants the lower-level handler-bag API → `skills/build-creative-agent/`
+- User wants to fork a worked adapter → `skills/build-creative-agent/`
 - User wants stateful creative library/ad-server → `skills/build-creative-agent/` § creative-ad-server
 - User wants brief-to-creative generation → same skill as this one (Builder covers both); declare `'creative-generative'` instead of `'creative-template'`
 - User wants to sell media inventory → `skills/build-seller-agent/`
 
 ## The whole shape (read this first)
 
-A v6.0 creative-template platform is a **single class** implementing `DecisioningPlatform` with a `creative` field of type `CreativeBuilderPlatform`. The framework dispatches each tool call to the right method. (`CreativeTemplatePlatform` and `CreativeGenerativePlatform` are deprecated aliases of `CreativeBuilderPlatform` for source compat.)
+A creative-template platform is a **single class** implementing `DecisioningPlatform` with a `creative` field of type `CreativeBuilderPlatform`. The framework dispatches each tool call to the right method. (`CreativeTemplatePlatform` and `CreativeGenerativePlatform` are deprecated aliases of `CreativeBuilderPlatform` for source compat.)
 
 ### Key fact: `CreativeManifest.assets` is a **keyed map**, not an array
 
@@ -406,7 +406,7 @@ serve(() => server, {
 - Wraps each method with `AdcpError`-catch + `submitted`-envelope projection for HITL
 - Returns a `DecisioningAdcpServer` (extends `AdcpServer`) with `getTaskState(taskId)` + `awaitTask(taskId)` for HITL inspection
 
-`serve()` is unchanged from v5.x; it accepts the server and binds HTTP transport for both MCP and A2A.
+`serve()` accepts the server and binds HTTP transport for both MCP and A2A.
 
 ## Capabilities — declare what you support
 
@@ -486,9 +486,7 @@ For HITL platforms, `server.awaitTask(taskId)` settles the background promise; `
 
 ## What NOT to do
 
-❌ **Don't import from `@adcp/sdk/server` for the platform shape.** That's the v5.x handler-style API. Use `@adcp/sdk/server` for v6.0.
-
-❌ **Don't use `ctx.runAsync(...)` or `ctx.startTask(...)`.** Those were in earlier preview drops; they're gone in v2.1. The async story is dual-method (`xxx` vs `xxxTask`), period.
+❌ **Don't use `ctx.runAsync(...)` or `ctx.startTask(...)`.** The async story is dual-method (`xxx` vs `xxxTask`), period.
 
 ❌ **Don't define both `buildCreative` and `buildCreativeTask`.** `validatePlatform()` will throw with a clear diagnostic. Pick one.
 

package/skills/build-decisioning-platform/SKILL.md

@@ -48,7 +48,7 @@ For other agent shapes:
 - **Brand-rights agent:** swap for `BrandRightsPlatform`
 - **Multi-tenant host:** add `createTenantRegistry`
 
-The full export list is in `@adcp/sdk/server`. Many surfaces are marked `@deprecated` (legacy v5 response builders, old MCP task helpers) — your IDE will strikethrough them. Trust the strikethrough.
+The full export list is in `@adcp/sdk/server`. Surfaces marked `@deprecated` will strikethrough in your IDE. Trust the strikethrough — pick from the typed-error catalog above instead.
 
 ## When you need...
 

package/skills/build-decisioning-platform/advanced/REFERENCE.md

@@ -5,13 +5,9 @@ description: Use when building an AdCP seller, creative, or audience agent again
 
 # Build a Decisioning Platform (v6.0)
 
-> **Status: GA.** v6.0 ships under `@adcp/sdk/server` —
-> `createAdcpServerFromPlatform` + `DecisioningPlatform`. The lower-level
-> `createAdcpServer({ mediaBuy: { ... } })` API remains fully supported
-> as the substrate this framework calls into; reach for it when you need
-> fine control over individual handlers or have custom-shaped tools the
-> platform interface doesn't yet model. The handler-bag skill is at
-> `skills/build-seller-agent/`.
+> **Status: GA.** Ships under `@adcp/sdk/server` —
+> `createAdcpServerFromPlatform` + `DecisioningPlatform`. The handler-bag
+> skill (forking a worked adapter) lives at `skills/build-seller-agent/`.
 
 ## Overview
 
@@ -102,7 +98,7 @@ const platform = {
 const server = createAdcpServerFromPlatform(platform, {
   name: 'My Ad Network',
   version: '1.0.0',
-  // Plus standard createAdcpServer options: idempotency, signedRequests,
+  // Plus standard server options: idempotency, signedRequests,
   // webhooks, validation, etc.
 });
 

package/skills/build-decisioning-signal-marketplace/SKILL.md

@@ -1,9 +1,9 @@
 ---
 name: build-decisioning-signal-marketplace
-description: Build an AdCP v6.0 (preview) signal-marketplace OR signal-owned decisioning platform — a data provider serving audience signals to buyers. Use ONLY when the user explicitly wants the v6.0 DecisioningPlatform shape; for v5.x handler-style signals agents, use `build-signals-agent` instead.
+description: Build an AdCP signal-marketplace OR signal-owned decisioning platform — a data provider serving audience signals to buyers. Use when the user wants the typed `DecisioningPlatform` shape; for fork-an-adapter starting points, see `build-signals-agent`.
 ---
 
-# Build a Signals Decisioning Platform (v6.0 preview)
+# Build a Signals Decisioning Platform
 
 You're building a **signals data provider** that fits one of two AdCP specialisms:
 
@@ -14,19 +14,19 @@ Both share the same `SignalsPlatform` interface. Pick the specialism that matche
 
 ## When this skill applies
 
-- User wants a signals platform on the **v6.0 DecisioningPlatform** surface (preview, pre-GA)
+- User wants a signals platform on the typed `DecisioningPlatform` surface
 - Specialism: `signal-marketplace` OR `signal-owned`
-- SDK package: `@adcp/sdk` v5.18+ with the `decisioning` preview surface
+- SDK package: `@adcp/sdk`
 
 **Wrong skill if:**
 
-- User wants v5.x handler-style API → `skills/build-signals-agent/`
+- User wants to fork a worked adapter → `skills/build-signals-agent/`
 - User wants creative transforms → `skills/build-decisioning-creative-template/`
 - User wants to sell media inventory → `skills/build-seller-agent/`
 
 ## The whole shape (read this first)
 
-A v6.0 signals platform implements two methods:
+A signals platform implements two methods:
 
 - **`getSignals(req, ctx) → Promise<GetSignalsResponse>`** — sync catalog discovery. Buyer sends filters; you return the matching signals. No async envelope.
 - **`activateSignal(req, ctx) → Promise<ActivateSignalSuccess>`** — sync ack with async lifecycle. Provision the signal onto destination platforms (Snap, Meta, TikTok, etc.); return immediately with `deployments[]` rows in current state (`pending` is valid). Each deployment's eventual `activating` / `deployed` / `failed` flows via `publishStatusChange({ resource_type: 'signal', ... })`.
@@ -229,8 +229,6 @@ console.log(result.structuredContent);
 
 ## What NOT to do
 
-❌ **Don't import from `@adcp/sdk/server` for the platform shape.** Use `@adcp/sdk/server` for v6.0.
-
 ❌ **Don't try to make activateSignal HITL.** The wire response has no `Submitted` arm. Sync ack + `publishStatusChange` is the correct pattern.
 
 ❌ **Don't return error envelopes manually.** Throw `AdcpError`; the framework projects to wire shape.

package/skills/build-seller-agent/deployment.md

@@ -8,7 +8,7 @@ Companion to [`SKILL.md`](./SKILL.md). Read this only when you need deployment s
 
 - **Mounting under an existing Express app** (especially alongside OAuth 2.1 Authorization Server routes like `mcpAuthRouter({ provider })`) — use `createExpressAdapter`.
 - **Stdio transport** — for CLI / desktop / local-subprocess agents.
-- **Hand-rolled HTTP** — when even `createExpressAdapter` doesn't fit; `createAdcpServer().connect(transport)` is the raw escape hatch.
+- **Hand-rolled HTTP** — when even `createExpressAdapter` doesn't fit; `createAdcpServerFromPlatform(...).connect(transport)` is the raw escape hatch.
 
 ### Multi-host HTTP
 
@@ -16,16 +16,23 @@ Pass functions for `publicUrl` and `protectedResource`, branch on `ctx.host` in
 
 ```typescript
 import { UnknownHostError, hostname } from '@adcp/sdk';
-import { verifyBearer } from '@adcp/sdk/server';
-import { serve, createAdcpServer } from '@adcp/sdk/server/legacy/v5';
-
-// Host → adapter config. Whatever shape suits your deployment (DB, env, static).
-// Cache the CONFIG (not the AdcpServer). serve() still instantiates the
-// server per request today, but a config Map keeps the expensive part
-// (handler bundle, idempotency store, DB pool) at module scope.
-const adapters = new Map<string, { name: string; handlers: MediaBuyHandlers }>([
-  ['snap.agentic-adapters.scope3.com', { name: 'Snap seller', handlers: snapHandlers }],
-  ['meta.agentic-adapters.scope3.com', { name: 'Meta seller', handlers: metaHandlers }],
+import {
+  createAdcpServerFromPlatform,
+  serve,
+  verifyBearer,
+  type DecisioningPlatform,
+} from '@adcp/sdk/server';
+
+declare const snapPlatform: DecisioningPlatform;
+declare const metaPlatform: DecisioningPlatform;
+
+// Host → platform. Whatever shape suits your deployment (DB, env, static).
+// Cache the PLATFORM (not the AdcpServer). serve() still instantiates the
+// server per request today, but a platform Map keeps the expensive part
+// (platform handlers, idempotency store, DB pool) at module scope.
+const adapters = new Map<string, { name: string; platform: DecisioningPlatform }>([
+  ['snap.agentic-adapters.scope3.com', { name: 'Snap seller', platform: snapPlatform }],
+  ['meta.agentic-adapters.scope3.com', { name: 'Meta seller', platform: metaPlatform }],
   // ... one entry per hostname you front
 ]);
 
@@ -40,11 +47,9 @@ serve(
     // UnknownHostError → 404 (generic body, routing table stays off the wire).
     // Any other thrown error still surfaces as 500.
     if (!cfg) throw new UnknownHostError(`No adapter configured for ${ctx.host}`);
-    return createAdcpServer({
+    return createAdcpServerFromPlatform(cfg.platform, {
       name: cfg.name,
       version: '1.0.0',
-      resolveAccount: async (ref, { authInfo }) => lookupAccount(ctx.host, ref, authInfo),
-      mediaBuy: cfg.handlers,
     });
   },
   {
@@ -77,9 +82,9 @@ Each unique host runs its resolver once and the result is cached. Every host adv
 
 **Unknown hosts: throw `UnknownHostError` from the factory.** `serve()` catches it and responds 404 with a generic body (the routing table never crosses the wire). Throwing any other `Error` stays as a 500 so unrelated bugs remain loud.
 
-**Factory runs per request.** `serve()` calls the factory on every incoming request (to avoid cross-request state bleed). By default it closes the returned server at the end of each request — so caching the `AdcpServer` from one call to the next is unsafe without opt-in. Keep the default-path factory cheap: look up a pre-built adapter config from a module-scoped `Map`, and let `createAdcpServer(...)` build a fresh wrapper from that config on every call.
+**Factory runs per request.** `serve()` calls the factory on every incoming request (to avoid cross-request state bleed). By default it closes the returned server at the end of each request — so caching the `AdcpServer` from one call to the next is unsafe without opt-in. Keep the default-path factory cheap: look up a pre-built platform from a module-scoped `Map`, and let `createAdcpServerFromPlatform(...)` build a fresh wrapper from that platform on every call.
 
-**Pass `reuseAgent: true` to cache `AdcpServer` instances per host.** When the tool-registration cost inside `createAdcpServer(...)` is a measurable part of request latency (common in multi-host deployments with many tools per host), flip the flag and cache the returned server in the factory:
+**Pass `reuseAgent: true` to cache `AdcpServer` instances per host.** When the tool-registration cost inside `createAdcpServerFromPlatform(...)` is a measurable part of request latency (common in multi-host deployments with many tools per host), flip the flag and cache the returned server in the factory:
 
 ```typescript
 const agents = new Map<string, AdcpServer>();
@@ -89,11 +94,9 @@ serve(
     if (!agent) {
       const cfg = adapters.get(ctx.host);
       if (!cfg) throw new UnknownHostError(`No adapter for ${ctx.host}`);
-      agent = createAdcpServer({
+      agent = createAdcpServerFromPlatform(cfg.platform, {
         name: cfg.name,
         version: '1.0.0',
-        resolveAccount: cfg.resolveAccount,
-        mediaBuy: cfg.handlers,
       });
       agents.set(ctx.host, agent);
     }
@@ -117,18 +120,19 @@ When your agent is _both_ an OAuth 2.1 AS (issues tokens) and a protected resour
 
 ```typescript
 import express from 'express';
-import { createExpressAdapter, verifyBearer, anyOf, verifyApiKey } from '@adcp/sdk/server';
-import { createAdcpServer } from '@adcp/sdk/server/legacy/v5';
+import {
+  createAdcpServerFromPlatform,
+  createExpressAdapter,
+  verifyBearer,
+  anyOf,
+  verifyApiKey,
+} from '@adcp/sdk/server';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { mcpAuthRouter } from '@modelcontextprotocol/sdk/server/auth/router.js';
 
-const agent = createAdcpServer({
+const agent = createAdcpServerFromPlatform(snapPlatform, {
   name: 'Snap seller',
   version: '1.0.0',
-  resolveAccount: async (ref, { authInfo }) => lookupAccount(ref, authInfo),
-  mediaBuy: {
-    /* ... */
-  },
 });
 
 const adapter = createExpressAdapter({
@@ -192,7 +196,7 @@ The shape when one Node process fronts N hostnames AND each hostname is also its
 ```typescript
 import express from 'express';
 import {
-  createAdcpServer,
+  createAdcpServerFromPlatform,
   createExpressAdapter,
   verifyBearer,
   resolveHost,
@@ -218,11 +222,9 @@ const app = express();
 // AS routes, and the MCP endpoint.
 const routersByHost = new Map<string, express.Router>();
 for (const [host, cfg] of adapters) {
-  const agent = createAdcpServer({
+  const agent = createAdcpServerFromPlatform(cfg.platform, {
     name: cfg.name,
     version: '1.0.0',
-    resolveAccount: async (ref, { authInfo }) => cfg.lookupAccount(ref, authInfo),
-    mediaBuy: cfg.handlers,
   });
 
   const adapter = createExpressAdapter({
@@ -390,15 +392,11 @@ You own: the `mcpAuthRouter` wiring (provider-specific), the per-request `transp
 
 ```typescript
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { createAdcpServer } from '@adcp/sdk/server/legacy/v5';
+import { createAdcpServerFromPlatform } from '@adcp/sdk/server';
 
-const server = createAdcpServer({
+const server = createAdcpServerFromPlatform(localSellerPlatform, {
   name: 'Local Seller',
   version: '1.0.0',
-  resolveAccount: async ref => lookupAccount(ref),
-  mediaBuy: {
-    /* ... */
-  },
 });
 
 await server.connect(new StdioServerTransport());

package/skills/build-seller-agent/specialisms/audience-sync.md

@@ -13,8 +13,19 @@ Required tools: `sync_audiences` and `list_accounts`. `sync_audiences` is overlo
 There is no separate `delete_audience` tool — deletion rides on `sync_audiences`.
 
 ```typescript
-createAdcpServer({
+import {
+  createAdcpServerFromPlatform,
+  definePlatform,
+  defineAudiencePlatform,
+} from '@adcp/sdk/server';
+
+const platform = definePlatform({
+  capabilities: {
+    specialisms: ['audience-sync', 'sales-non-guaranteed'] as const,
+    pricingModels: ['cpm'] as const,
+  },
   accounts: {
+    resolve: async (ref, ctx) => /* lookup */ null,
     syncAccounts: /* baseline */,
     listAccounts: async (params, ctx) => {
       const { items } = await ctx.store.list('accounts');
@@ -22,7 +33,7 @@ createAdcpServer({
       return { accounts: brandFilter ? items.filter((a) => a.brand.domain === brandFilter) : items };
     },
   },
-  eventTracking: {
+  audiences: defineAudiencePlatform({
     syncAudiences: async (params, ctx) => {
       // Discovery mode — no audiences in request
       if (!params.audiences?.length) {
@@ -52,7 +63,12 @@ createAdcpServer({
         })),
       };
     },
-  },
+  }),
+});
+
+const server = createAdcpServerFromPlatform(platform, {
+  name: 'Audience-sync seller',
+  version: '1.0.0',
 });
 ```