@adcp/sdk 5.25.1 → 6.1.0

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

@@ -0,0 +1,24 @@
+# Sandbox routing
+
+When a buyer sends `account: { id: '...', sandbox: true }`, route the call to your platform's test/staging environment instead of production. The buyer wants to validate against your real surface without touching prod.
+
+```ts
+accounts: {
+  resolve: async (ref) => {
+    if (ref?.sandbox === true) {
+      return { id: ref.id, operator: 'mypub-sandbox', ctx_metadata: { env: 'staging' } };
+    }
+    return { id: ref?.id ?? 'pub_main', operator: 'mypub', ctx_metadata: { env: 'production' } };
+  },
+  ...
+}
+
+createMediaBuy: async (req, ctx) => {
+  const target = ctx.account.ctx_metadata.env === 'staging' ? this.gamSandbox : this.gam;
+  return await target.createOrder(req);
+}
+```
+
+There is no separate "dry-run" mode — sandbox subsumes "validate against real platform without writing to production." Tool-specific `dry_run` flags on `sync_catalogs` / `sync_creatives` are wire fields you receive and honor; they are NOT a framework-level mode.
+
+See `REFERENCE.md` for the full sandbox section.

package/skills/build-decisioning-platform/advanced/STATE-MACHINE.md

@@ -0,0 +1,52 @@
+# Media buy state machine
+
+The wire spec defines a closed status enum; transitions are constrained. Sales agents that get state wrong fail compliance.
+
+## States and transitions
+
+```
+pending_creatives  → buyer hasn't pushed creatives yet
+       ↓
+pending_start      → creatives synced + approved; awaiting campaign start_time
+       ↓
+active             → delivering
+       ↓
+paused             → buyer or operator paused (resumable)
+       ↓
+completed          → end_time passed naturally
+       ↓
+canceled           → terminated before end_time
+
+rejected           → never accepted (compliance / governance fail at create time)
+```
+
+## Rules
+
+1. **`createMediaBuy` returns `pending_creatives`** unless creatives were synced in the same request batch (rare). Returning `active` immediately is wrong — the buyer hasn't synced anything yet.
+2. **`syncCreatives` doesn't change media-buy status itself.** Operator approval flow / start_time tick advances it. Use `publishStatusChange(...)` to emit the transition.
+3. **Transition events are spec-aligned**: `pending_creatives` → `pending_start` happens when ALL packages have at least one approved creative. `pending_start` → `active` happens when `start_time` is reached.
+4. **`paused` and `active` are reversible.** `canceled`, `completed`, `rejected` are terminal.
+5. **Illegal transitions throw `InvalidStateError`.** Buyer trying to update a `completed` buy → throw, don't silently accept.
+
+## Pattern: emit transitions via the bus
+
+```ts
+import { publishStatusChange } from '@adcp/sdk/server';
+
+// When all packages have approved creatives:
+publishStatusChange({
+  account_id: ctx.account.id,
+  resource_type: 'media_buy',
+  resource_id: mediaBuyId,
+  status: 'pending_start',
+  occurred_at: new Date().toISOString(),
+});
+```
+
+Buyers subscribed via push_notification_config or MCP Resources see the transition.
+
+## Where to track state
+
+If your platform has the source of truth (GAM order status), read it on every `getMediaBuyDelivery` / `getMediaBuy` and project via `StatusMappers`. If your SDK is the source, use `ctx.ctxMetadata` to stash the current state per buy and update on every mutation.
+
+See `REFERENCE.md` for the full status mapper section.

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

@@ -0,0 +1,269 @@
+---
+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.
+---
+
+# Build a Signals Decisioning Platform (v6.0 preview)
+
+You're building a **signals data provider** that fits one of two AdCP specialisms:
+
+- `signal-marketplace` — third-party data brokers serving curated signals (LiveRamp, Oracle Data Cloud, third-party DMPs)
+- `signal-owned` — first-party data providers serving their own signals (publisher first-party data, retailer customer-graph)
+
+Both share the same `SignalsPlatform` interface. Pick the specialism that matches your relationship to the data; the implementation shape is identical.
+
+## When this skill applies
+
+- User wants a signals platform on the **v6.0 DecisioningPlatform** surface (preview, pre-GA)
+- Specialism: `signal-marketplace` OR `signal-owned`
+- SDK package: `@adcp/sdk` v5.18+ with the `decisioning` preview surface
+
+**Wrong skill if:**
+
+- User wants v5.x handler-style API → `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:
+
+- **`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', ... })`.
+
+Both throw `AdcpError` for buyer-fixable rejection.
+
+### Minimal worked example — DataMatrix marketplace
+
+```ts
+import {
+  AdcpError,
+  createAdcpServerFromPlatform,
+  publishStatusChange,
+  type DecisioningPlatform,
+  type SignalsPlatform,
+  type AccountStore,
+} from '@adcp/sdk/server';
+import type {
+  GetSignalsRequest,
+  GetSignalsResponse,
+  ActivateSignalRequest,
+  ActivateSignalSuccess,
+  AccountReference,
+} from '@adcp/sdk/types';
+import { serve } from '@adcp/sdk/server';
+
+interface DataMatrixConfig {
+  /** Match-rate floor — signals below this rate to a destination are filtered out. */
+  minMatchRate: number;
+}
+interface DataMatrixMeta {
+  workspace_id: string;
+}
+
+class DataMatrixPlatform implements DecisioningPlatform<DataMatrixConfig, DataMatrixMeta> {
+  capabilities = {
+    specialisms: ['signal-marketplace'] as const,
+    creative_agents: [],
+    channels: [] as const,
+    pricingModels: ['cpm'] as const,
+    config: { minMatchRate: 0.15 } satisfies DataMatrixConfig,
+  };
+
+  accounts: AccountStore<DataMatrixMeta> = {
+    resolve: async (ref: AccountReference) => {
+      const id = 'account_id' in ref ? ref.account_id : 'dm_default';
+      return {
+        id,
+        name: 'DataMatrix default',
+        status: 'active',
+        operator: 'datamatrix.example.com',
+        metadata: { workspace_id: `ws_${id}` },
+        authInfo: { kind: 'api_key' },
+      };
+    },
+  };
+
+  signals: SignalsPlatform<DataMatrixMeta> = {
+    getSignals: async (_req: GetSignalsRequest): Promise<GetSignalsResponse> => {
+      return {
+        signals: [
+          {
+            signal_id: { source: 'agent', agent_url: 'https://datamatrix.example/signals', id: 'in_market_auto' },
+            signal_agent_segment_id: 'dm_seg_auto_001',
+            name: 'In-Market: Auto Buyers',
+            description: 'Active automotive shoppers within 90-day purchase window',
+            value_type: 'binary',
+            signal_type: 'marketplace',
+            data_provider: 'DataMatrix',
+            coverage_percentage: 18.5,
+            deployments: [],
+            pricing_options: [{ pricing_option_id: 'po_cpm_4', model: 'cpm', cpm: 4.0, currency: 'USD' }],
+          },
+        ],
+      };
+    },
+
+    activateSignal: async (req: ActivateSignalRequest): Promise<ActivateSignalSuccess> => {
+      if (!req.destinations.length) {
+        throw new AdcpError('INVALID_REQUEST', {
+          recovery: 'correctable',
+          message: 'destinations must be non-empty',
+          field: 'destinations',
+        });
+      }
+      // Sync ack: return deployments in `pending` state. Identity-graph
+      // match runs in background; publishStatusChange fires when each
+      // destination reaches activating / deployed / failed.
+      const deployments = req.destinations.map(d => ({
+        type: 'platform' as const,
+        platform: 'platform' in d ? d.platform : 'unknown',
+        account_id: 'account_id' in d ? d.account_id : undefined,
+        is_live: false,
+      }));
+
+      // Schedule background activation for each destination
+      const accountId = req.account && 'account_id' in req.account ? req.account.account_id : 'dm_default';
+      for (const dep of deployments) {
+        setTimeout(() => {
+          publishStatusChange({
+            account_id: accountId,
+            resource_type: 'signal',
+            resource_id: req.signal_agent_segment_id,
+            payload: { platform: dep.platform, status: 'deployed', is_live: true },
+          });
+        }, 100).unref?.();
+      }
+
+      return { deployments };
+    },
+  };
+}
+
+const platform = new DataMatrixPlatform();
+const server = createAdcpServerFromPlatform(platform, {
+  name: 'datamatrix',
+  version: '1.0.0',
+  validation: { requests: 'strict', responses: 'strict' },
+});
+serve(() => server, { publicUrl: 'https://datamatrix.example.com' });
+```
+
+## Sync ack with async lifecycle
+
+`activateSignal` is **always sync at the wire level** — `ActivateSignalResponse` has no `Submitted` arm. For platforms with slow identity-graph matches (5-30 min) or destination provisioning (hours), the canonical pattern is:
+
+1. Return `ActivateSignalSuccess` immediately with each deployment row in `pending` state
+2. Run the activation pipeline in background
+3. Emit `publishStatusChange({ resource_type: 'signal', ... })` for each deployment as it reaches `activating` / `deployed` / `failed`
+
+Buyers subscribe via the resource-update channel to track activation progress.
+
+## Errors — `throw new AdcpError(...)`
+
+Common codes for signals:
+
+| Code                   | When                                                                                          |
+| ---------------------- | --------------------------------------------------------------------------------------------- |
+| `'SIGNAL_NOT_FOUND'`   | unknown `signal_agent_segment_id`                                                             |
+| `'POLICY_VIOLATION'`   | buyer lacks rights to activate this data                                                      |
+| `'INVALID_REQUEST'`    | missing destinations, unrecognized destination shape, missing pricing_option_id when required |
+| `'AUDIENCE_TOO_SMALL'` | activated audience falls below match-rate floor                                               |
+| `'RATE_LIMITED'`       | upstream identity-graph throttled                                                             |
+
+```ts
+activateSignal: async req => {
+  if (!signalCatalog.has(req.signal_agent_segment_id)) {
+    throw new AdcpError('SIGNAL_NOT_FOUND', {
+      recovery: 'terminal',
+      message: `Unknown signal: ${req.signal_agent_segment_id}`,
+      field: 'signal_agent_segment_id',
+    });
+  }
+  // ... happy path
+};
+```
+
+## Idempotency — the framework dedupes; you thread the key downstream
+
+Same pattern as creative-template — see [`build-decisioning-creative-template/SKILL.md`](../build-decisioning-creative-template/SKILL.md) § Idempotency. Pass `req.idempotency_key` into your upstream identity-graph / destination-provisioning API so dedup is end-to-end.
+
+## Capabilities
+
+```ts
+capabilities = {
+  specialisms: ['signal-marketplace'] as const, // or 'signal-owned'
+  creative_agents: [], // not used by signals
+  channels: [] as const, // not used by signals
+  pricingModels: ['cpm'] as const, // signals are typically CPM uplift
+  config: {
+    /* your platform-specific config */
+  } satisfies YourConfig,
+};
+```
+
+## Testing your platform
+
+```ts
+import { createAdcpServerFromPlatform } from '@adcp/sdk/server';
+
+const platform = new DataMatrixPlatform();
+const server = createAdcpServerFromPlatform(platform, {
+  name: 'dm-test',
+  version: '0.0.1',
+  validation: { requests: 'off', responses: 'off' },
+});
+
+const result = await server.dispatchTestRequest({
+  method: 'tools/call',
+  params: {
+    name: 'get_signals',
+    arguments: {
+      filters: { catalog_types: ['third_party'], industries: ['automotive'] },
+      account: { account_id: 'test_acc' },
+    },
+  },
+});
+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.
+
+❌ **Don't write `as any` / `as never` in adopter code.** The wire types are typed; discriminators on `SignalID` (`source: 'catalog' | 'agent'`) and `Destination` (`type: 'platform' | ...`) narrow without casts.
+
+## Reference: imports cheat sheet
+
+```ts
+// From @adcp/sdk/server
+import {
+  AdcpError,
+  AccountNotFoundError,
+  createAdcpServerFromPlatform,
+  publishStatusChange,
+  type DecisioningPlatform,
+  type AccountStore,
+  type Account,
+  type SignalsPlatform,
+  type RequestContext,
+  type ErrorCode,
+  type AdcpStructuredError,
+} from '@adcp/sdk/server';
+
+// From @adcp/sdk/types — wire schemas (auto-generated)
+import type {
+  GetSignalsRequest,
+  GetSignalsResponse,
+  ActivateSignalRequest,
+  ActivateSignalSuccess,
+  AccountReference,
+} from '@adcp/sdk/types';
+
+// From @adcp/sdk/server — HTTP serving
+import { serve } from '@adcp/sdk/server';
+```

package/skills/build-generative-seller-agent/SKILL.md

@@ -37,7 +37,7 @@ A generative seller inherits every sales specialism it supports (usually `sales-
 
 Every production seller — generative or otherwise — must wire these regardless of specialism. See `skills/build-seller-agent/SKILL.md` for the full treatment; minimum viable pointers:
 
-- **`idempotency_key`** on every mutating request (`create_media_buy`, `sync_creatives`, `build_creative`, `sync_catalogs`). Wire `createIdempotencyStore({ backend, ttlSeconds })` into `createAdcpServer({ idempotency })` — framework handles replay.
+- **`idempotency_key`** on every mutating request (`create_media_buy`, `sync_creatives`, `build_creative`, `sync_catalogs`). Pass `createIdempotencyStore({ backend, ttlSeconds })` to `createAdcpServerFromPlatform(platform, { idempotency })` — framework handles replay.
 - **Authentication** (`serve({ authenticate: verifyApiKey(...)/verifyBearer(...) })`). A non-authenticated agent fails the `security_baseline` universal storyboard.
 - **Signature-header transparency**: even if you don't claim `signed-requests`, don't reject requests that carry `Signature-Input`/`Signature` headers.
 
@@ -82,7 +82,7 @@ Brands should be registered dynamically through `sync_accounts` — when a buyer
 >
 > **Cross-cutting pitfalls matrix runs keep catching:**
 >
-> - **Declare `capabilities: { specialisms: ['creative-generative'] }` on `createAdcpServer`.** The value is `string[]` of enum ids (not `[{id, version}]`). Agents that don't declare their specialism fail the grader with "No applicable tracks found" even if every tool works — tracks are gated on the specialism claim.
+> - **Declare `capabilities.specialisms: ['creative-generative'] as const` on the `DecisioningPlatform` you pass to `createAdcpServerFromPlatform`.** The value is `string[]` of enum ids (not `[{id, version}]`). Agents that don't declare their specialism fail the grader with "No applicable tracks found" even if every tool works — tracks are gated on the specialism claim.
 > - `build_creative` response is `{ creative_manifest: { format_id, assets } }` — NOT `{ creative_id, status, quality, preview_url }`. Those are `sync_creatives` fields; don't leak them in.
 > - Each asset in `creative_manifest.assets` requires an `asset_type` discriminator — use the typed factories (`imageAsset({...})`, `videoAsset({...})`, `htmlAsset({...})`, `urlAsset({...})`) instead of writing the literal; discriminator is injected for you.
 > - `preview_creative` renders have the same pattern: use `urlRender({...})` / `htmlRender({...})` / `bothRender({...})` — they inject `output_format` and enforce the matching `preview_url` / `preview_html` at the type level.
@@ -94,7 +94,7 @@ Brands should be registered dynamically through `sync_accounts` — when a buyer
 
 Everything from the standard seller skill applies. The delta is in `list_creative_formats` and `sync_creatives`.
 
-**`get_adcp_capabilities`** — auto-generated by `createAdcpServer` from registered handlers. Do not implement manually.
+**`get_adcp_capabilities`** — auto-generated by `createAdcpServerFromPlatform` from the typed `DecisioningPlatform` you provide. Do not implement manually.
 
 **`sync_accounts`** — `SyncAccountsRequestSchema.shape`
 
@@ -314,7 +314,7 @@ deliveryResponse({
 
 ### Context and Ext Passthrough
 
-`createAdcpServer` auto-echoes the request's `context` into every response — **do not set `context` yourself in your handler return values.** The framework injects it post-handler only when the field isn't already present.
+The framework auto-echoes the request's `context` into every response — **do not set `context` yourself in your handler return values.** It's injected post-handler only when the field isn't already present.
 
 **Crucial:** `context` is schema-typed as an object. If your handler hand-sets a string or narrative description, validation fails with `/context: must be object` and the framework does not overwrite. Leave the field out entirely.
 
@@ -351,8 +351,9 @@ Validate with: `adcp storyboard run <agent> deterministic_testing --json`
 
 | SDK piece                               | Usage                                                                   |
 | --------------------------------------- | ----------------------------------------------------------------------- |
-| `createAdcpServer(config)`              | Create server with domain-grouped handlers, auto-generated capabilities |
-| `serve(() => createAdcpServer(config))` | Start HTTP server on `:3001/mcp`                                        |
+| `createAdcpServerFromPlatform(platform, opts)` | Create server from a typed `DecisioningPlatform` — compile-time specialism enforcement, auto-generated capabilities, ctx_metadata round-trip |
+| `createAdcpServer(config)` *(legacy)*          | v5 handler-bag entry. Mid-migration / escape-hatch only; reach via `@adcp/sdk/server/legacy/v5`                                              |
+| `serve(() => createAdcpServerFromPlatform(platform, opts))` | Start HTTP server on `:3001/mcp`                                                                       |
 | `ctx.store`                             | State persistence — `get/put/patch/delete/list` domain objects          |
 | `adcpError(code, { message })`          | Structured error                                                        |
 | `registerTestController(server, store)` | Add `comply_test_controller` for deterministic testing                  |
@@ -361,7 +362,7 @@ Response builders (`productsResponse`, `mediaBuyResponse`, `syncCreativesRespons
 
 `get_adcp_capabilities` is auto-generated from registered handlers. Do not register it manually.
 
-Import: `import { createAdcpServer, serve, adcpError } from '@adcp/sdk';`
+Import: `import { createAdcpServerFromPlatform, serve, adcpError } from '@adcp/sdk/server';`
 
 ## Setup
 
@@ -391,7 +392,7 @@ Minimal `tsconfig.json`:
 ## Implementation
 
 1. Single `.ts` file — all tools in one file
-2. Use `createAdcpServer` with `mediaBuy` and `creative` domain groups
+2. Use `createAdcpServerFromPlatform` with `sales` and `creative` typed sub-platforms on a `DecisioningPlatform` class
 3. Handlers return raw data objects — the framework auto-applies response builders
 4. `get_adcp_capabilities` is auto-generated from registered handlers — do not register it manually
 5. Use `ctx.store` for state persistence (accounts, media buys, creatives)
@@ -401,8 +402,17 @@ Creative tools (`listCreativeFormats`, `syncCreatives`, `buildCreative`, `listCr
 
 ```typescript
 import { randomUUID } from 'node:crypto';
-import { createAdcpServer, serve, adcpError } from '@adcp/sdk';
-import { createIdempotencyStore, memoryBackend } from '@adcp/sdk/server';
+import {
+  createAdcpServerFromPlatform,
+  serve,
+  adcpError,
+  createIdempotencyStore,
+  memoryBackend,
+  type DecisioningPlatform,
+  type SalesPlatform,
+  type CreativeBuilderPlatform,
+  type AccountStore,
+} from '@adcp/sdk/server';
 
 // Idempotency — required for v3. Generative creation is expensive and
 // non-deterministic, so caching successful responses per key is critical:
@@ -412,51 +422,76 @@ const idempotency = createIdempotencyStore({
   ttlSeconds: 86400, // 24 hours (spec bounds: 1h–7d)
 });
 
+class MyGenerativeSeller implements DecisioningPlatform {
+  capabilities = {
+    specialisms: ['sales-non-guaranteed', 'creative-generative'] as const,
+    creative_agents: [{ agent_url: 'https://example.com/creative/mcp' }],
+    pricingModels: ['cpm'] as const,
+    channels: ['display'] as const,
+    config: {},
+  };
+
+  accounts: AccountStore = {
+    resolve: async ref => ({
+      id: 'account_id' in ref ? ref.account_id : 'gen_acc_1',
+      operator: 'me',
+      ctx_metadata: {},
+    }),
+    upsert: async () => ({ ok: true, items: [] }),
+    list: async () => ({ items: [], nextCursor: null }),
+  };
+
+  sales: SalesPlatform = {
+    getProducts: async (req, ctx) => ({ products: PRODUCTS, sandbox: true }),
+    createMediaBuy: async (req, ctx) => {
+      const buy = {
+        media_buy_id: `mb_${randomUUID()}`,
+        status: 'pending_creatives' as const,
+        packages:
+          req.packages?.map(p => ({
+            package_id: `pkg_${randomUUID()}`,
+            product_id: p.product_id,
+            pricing_option_id: p.pricing_option_id,
+            budget: p.budget,
+          })) ?? [],
+      };
+      await ctx.store.put('media_buys', buy.media_buy_id, buy);
+      return buy;
+    },
+    updateMediaBuy: async (id, patch, ctx) => ({ media_buy_id: id, status: 'active' }),
+    getMediaBuys: async () => ({ media_buys: [] }),
+    getMediaBuyDelivery: async () => ({ deliveries: [] }),
+    listCreativeFormats: async () => ({ formats: FORMATS }),
+    // syncCreatives: generative formats take a `brief`; standard formats
+    // carry assets. Check format_id to decide processing. Framework
+    // idempotency ensures a retry of the same (key, payload) replays the
+    // prior response instead of re-running generation.
+    syncCreatives: async (creatives, ctx) =>
+      creatives.map(c => ({
+        creative_id: (c as { creative_id?: string }).creative_id ?? `cr_${randomUUID()}`,
+        action: 'created' as const,
+      })),
+  };
+
+  creative: CreativeBuilderPlatform = {
+    buildCreative: async (req, ctx) => {
+      // Generative path — read brief, call your model, return assets.
+      // Framework auto-stores the build for refine/lookup via ctx_metadata.
+      return { creative_manifest: { /* generated assets */ } };
+    },
+    previewCreative: async (req, ctx) => {
+      return { preview_url: '...' };
+    },
+  };
+}
+
+const platform = new MyGenerativeSeller();
+
 serve(() =>
-  createAdcpServer({
+  createAdcpServerFromPlatform(platform, {
     name: 'My Generative Seller',
     version: '1.0.0',
     idempotency,
-
-    // Principal scoping. MUST never return undefined — or every mutating
-    // request rejects as SERVICE_UNAVAILABLE.
-    resolveSessionKey: () => 'default-principal',
-
-    mediaBuy: {
-      getProducts: async (params, ctx) => ({ products: PRODUCTS, sandbox: true }),
-      createMediaBuy: async (params, ctx) => {
-        const buy = {
-          media_buy_id: `mb_${randomUUID()}`,
-          status: 'pending_creatives' as const,
-          packages:
-            params.packages?.map(p => ({
-              package_id: `pkg_${randomUUID()}`,
-              product_id: p.product_id,
-              pricing_option_id: p.pricing_option_id,
-              budget: p.budget,
-            })) ?? [],
-        };
-        await ctx.store.put('media_buys', buy.media_buy_id, buy);
-        return buy;
-      },
-      // ... updateMediaBuy, getMediaBuys, getMediaBuyDelivery
-    },
-
-    creative: {
-      listCreativeFormats: async () => ({ formats: FORMATS }),
-      syncCreatives: async (params, ctx) => {
-        // Generative formats take a `brief`; standard formats carry assets.
-        // Check the format_id to decide processing. Framework idempotency
-        // ensures a retry of the same (key, payload) replays the prior
-        // response instead of re-running generation.
-        const results = params.creatives.map(c => ({
-          creative_id: c.creative_id ?? `cr_${randomUUID()}`,
-          action: 'created' as const,
-        }));
-        return { creatives: results };
-      },
-      // ... buildCreative, listCreatives, getCreativeDelivery
-    },
   })
 );
 ```
@@ -564,8 +599,9 @@ Common failure decoder:
 | Ignore brand domain on brief sync                        | Validate brand, reject if unresolvable                                                                                                                   |
 | Same handler for brief and standard creatives            | Check format_id to decide processing path                                                                                                                |
 | format_ids in products don't match list_creative_formats | Buyers echo format_ids from products into sync_creatives — if your validation rejects your own format_ids, the buyer can't fulfill creative requirements |
-| Manually registering `get_adcp_capabilities`             | Auto-generated by `createAdcpServer` — do not register it                                                                                                |
-| Using `server.tool()` instead of domain groups           | Use `createAdcpServer({ mediaBuy: {...}, creative: {...} })`                                                                                             |
+| Manually registering `get_adcp_capabilities`             | Auto-generated by `createAdcpServerFromPlatform` from your typed `DecisioningPlatform` — do not register it                                              |
+| Using `server.tool()` instead of typed sub-platforms     | Implement `sales: SalesPlatform` + `creative: CreativeBuilderPlatform` on a `DecisioningPlatform` class                                                  |
+| Calling `createAdcpServer` directly in new code          | Reach for `createAdcpServerFromPlatform`; `createAdcpServer` lives at `@adcp/sdk/server/legacy/v5` for mid-migration / escape-hatch only                 |
 | `sandbox: false` on mock data                            | Buyers may treat mock data as real                                                                                                                       |
 | Dropping `context` from responses                        | Echo `args.context` back unchanged in every response — buyers use it for correlation                                                                     |