@adcp/sdk 16.4.0 → 16.6.0

package/dist/lib/core/SingleAgentClient.mjs

@@ -3,6 +3,9 @@ import { dirname as __adcpDirname } from "node:path";
 import { createRequire as __adcpCreateRequire } from "node:module";
 const __dirname = __adcpDirname(__adcpFileURLToPath(import.meta.url));
 const require2 = __adcpCreateRequire(import.meta.url);
+import { shouldReuseMCPConnection, withMCPConnectionPolicy } from "../protocols/mcp-connection-policy.mjs";
+import { withMCPConnectionScope } from "../protocols/mcp-scope.mjs";
+import { hasUnsignedCapabilityBootstrap } from "../signing/protocol-methods.mjs";
 import { normalizeGetProductsResponse } from "../utils/pricing-adapter.mjs";
 import { normalizeMediaBuyResponse } from "../utils/creative-adapter.mjs";
 import { normalizeFormatsResponse } from "../utils/format-renders.mjs";
@@ -21,6 +24,16 @@ import {
 import { randomUUID, scryptSync } from "node:crypto";
 const SKIP_PRODUCT_CACHE = /* @__PURE__ */ Symbol("adcp.skipProductCache");
 const SKIP_ACCOUNT_REGISTRY_OBSERVATION = /* @__PURE__ */ Symbol("adcp.skipAccountRegistryObservation");
+const NONTERMINAL_TASK_RESULT_STATUSES = /* @__PURE__ */ new Set([
+  "submitted",
+  "working",
+  "input-required",
+  "auth-required",
+  "deferred"
+]);
+function isNonterminalTaskResult(result) {
+  return result !== null && typeof result === "object" && "success" in result && result.success === true && "status" in result && typeof result.status === "string" && NONTERMINAL_TASK_RESULT_STATUSES.has(result.status);
+}
 import { accountKeySites, naturalAccountKey, reducedFields, valueAt, withReducedKeyAt } from "./account-reduction.mjs";
 import { ADCP_ENVELOPE_FIELDS } from "../types/adcp.mjs";
 import { parseAdcpMajorVersion, toReleasePrecisionVersion } from "../version.mjs";
@@ -71,6 +84,7 @@ import { getSignedRequestRejection } from "../protocols/signedRequestRejection.m
 import { withAmbientIdentityHeaders } from "../protocols/mcp-call-context.mjs";
 import { ProtocolClient, normalizeTransportOptions } from "../protocols/index.mjs";
 import {
+  AgentRateLimitedError,
   AuthenticationCredentialsRejectedError,
   AuthenticationRequiredError,
   ConfigurationError,
@@ -172,6 +186,7 @@ import {
   selectListedAccount
 } from "./account-resolution.mjs";
 import { normalizeRequestParams } from "../utils/request-normalizer.mjs";
+import { getCreativeDeliveryDiagnostics } from "../v2/projection/legacy-metadata.mjs";
 import { globalAsyncLocalStorage } from "../utils/global-async-local-storage.mjs";
 import { validateUserAgent } from "../utils/validate-user-agent.mjs";
 import { resolveWebhookUrl, selectWebhookTemplate } from "./webhook-url.mjs";
@@ -733,10 +748,7 @@ const STANDARD_ADCP_TASK_NAMES = /* @__PURE__ */ new Set([
   "list_transformers",
   "preview_creative",
   "build_creative",
-  // These standard protocol tools still carry legacy creative `format_id`
-  // identity through artifacts, manifests, standards, or rights constraints.
-  // They are available only through explicitly named *Legacy APIs until a
-  // lossless canonical projection exists.
+  // Wire-level creative and content tools also have typed primary methods.
   "list_content_standards",
   "get_content_standards",
   "create_content_standards",
@@ -1020,7 +1032,19 @@ class SingleAgentClient {
       adcpVersion: this.resolvedAdcpVersion,
       ...config.wireAdcpVersion !== void 0 && { wireAdcpVersion: config.wireAdcpVersion },
       ...config.versionEnvelope !== void 0 && { versionEnvelope: config.versionEnvelope },
-      transport: config.transport
+      transport: config.transport,
+      resolveTaskStatusTool: async (pollAgent, options) => {
+        const client = pollAgent.id === this.normalizedAgent.id ? this : new SingleAgentClient(pollAgent, {
+          adcpVersion: this.resolvedAdcpVersion,
+          wireAdcpVersion: this.config.wireAdcpVersion,
+          versionEnvelope: this.config.versionEnvelope,
+          userAgent: this.config.userAgent,
+          discoveryCache: this.config.discoveryCache,
+          onTransportActivity: this.config.onTransportActivity,
+          transport: options.transport
+        });
+        return await client.advertisesTool("get_task_status", options) ? "get_task_status" : pollAgent.protocol === "mcp" ? "tasks_get" : "tasks/get";
+      }
     });
     if (config.handlers) {
       this.asyncHandler = new AsyncHandler(config.handlers);
@@ -1828,8 +1852,18 @@ class SingleAgentClient {
     const agent = this.normalizedAgent.protocol === "a2a" ? await this.ensureCanonicalUrlResolved(snapshot) : await this.ensureEndpointDiscovered(snapshot);
     return this.executor.trackTask(agent, snapshot);
   }
-  /** Poll through the same discovered/canonical protocol endpoint used for dispatch. @internal */
-  async getTaskStatus(taskId, transport, signal, wireOptions) {
+  async getTaskStatus(taskIdOrParams, transportOrHandler, signalOrOptions, wireOptions) {
+    if (typeof taskIdOrParams !== "string") {
+      return this.executeTaskUnprojected(
+        "get_task_status",
+        taskIdOrParams,
+        transportOrHandler,
+        signalOrOptions
+      );
+    }
+    const taskId = taskIdOrParams;
+    const transport = transportOrHandler;
+    const signal = signalOrOptions;
     const transportSnapshot = transport === void 0 ? void 0 : { ...transport };
     const options = { transport: transportSnapshot, signal };
     const agent = this.normalizedAgent.protocol === "a2a" ? await this.ensureCanonicalUrlResolved(options) : await this.ensureEndpointDiscovered(options);
@@ -2045,6 +2079,12 @@ class SingleAgentClient {
    * Also computes the canonical base URL by stripping /mcp suffix.
    */
   async ensureEndpointDiscovered(options) {
+    return withMCPConnectionPolicy(
+      normalizeTransportOptions(options?.transport ?? this.config.transport),
+      () => this.ensureEndpointDiscoveredWithConnectionPolicy(options)
+    );
+  }
+  async ensureEndpointDiscoveredWithConnectionPolicy(options) {
     throwIfAborted(options?.signal);
     if (this.config._reuseConfiguredDiscovery?.()) this.synchronizeCapabilityEvidenceAuthorizationScope();
     const needsDiscovery = this.normalizedAgent._needsDiscovery;
@@ -2296,12 +2336,21 @@ class SingleAgentClient {
    * - A validated MCP protected-resource metadata chain yields NeedsAuthorizationError
    * - Otherwise AuthenticationRequiredError carries the advertised challenge
    *
+   * Rate limiting (429, or 503 with Retry-After) stops probing at that URL and
+   * throws AgentRateLimitedError carrying the status and Retry-After.
+   *
    * Note: This is async and called lazily on first agent interaction
    */
   async discoverMCPEndpoint(providedUri, options) {
+    return withMCPConnectionPolicy(
+      normalizeTransportOptions(options?.transport ?? this.config.transport),
+      () => this.discoverMCPEndpointWithConnectionPolicy(providedUri, options)
+    );
+  }
+  async discoverMCPEndpointWithConnectionPolicy(providedUri, options) {
     throwIfAborted(options?.signal);
-    const { connectMCPWithFallback } = await import("../protocols/mcp.mjs");
-    const { probeModernMCPConnection } = await import("../protocols/mcp-modern.mjs");
+    const { connectMCPWithFallback, withScopedLegacyConnection } = await import("../protocols/mcp.mjs");
+    const { probeModernMCPConnection, retryAfterOf } = await import("../protocols/mcp-modern.mjs");
     const transport = normalizeTransportOptions(options?.transport ?? this.config.transport);
     const usesScopedFetch = this.usesScopedDiscoveryTransport(options);
     const endpointEpoch = this.discoveryEpochSnapshot(options);
@@ -2331,19 +2380,35 @@ class SingleAgentClient {
           }
           return { success: true };
         }
-        const client = await connectMCPWithFallback(
-          new URL(url),
-          authHeaders,
-          [],
-          "endpoint discovery",
-          transport?.trustedFetchFn,
+        const shared = await withScopedLegacyConnection(
           {
+            agentUrl: url,
+            authToken,
+            customHeaders: agentHeaders,
+            authProvider,
             signal: options?.signal,
             requestTimeoutMs: transport?.requestTimeoutMs,
+            fetchFn: transport?.trustedFetchFn,
             allowPrivateIp: transport?.allowPrivateIp
-          }
+          },
+          "endpoint discovery",
+          async () => void 0
         );
-        await client.close();
+        if (!shared) {
+          const client = await connectMCPWithFallback(
+            new URL(url),
+            authHeaders,
+            [],
+            "endpoint discovery",
+            transport?.trustedFetchFn,
+            {
+              signal: options?.signal,
+              requestTimeoutMs: transport?.requestTimeoutMs,
+              allowPrivateIp: transport?.allowPrivateIp
+            }
+          );
+          await client.close();
+        }
         if (mayRetain()) {
           this.discoveredMcpEra = "legacy";
           this.discoveredMcpEraAt = Date.now();
@@ -2360,7 +2425,8 @@ class SingleAgentClient {
         }
         const errObj = error;
         const status = errObj?.status || errObj?.response?.status || errObj?.cause?.status;
-        return { success: false, status, error };
+        const retryAfter = retryAfterOf(error);
+        return { success: false, status, ...retryAfter !== void 0 && { retryAfter }, error };
       }
     };
     const urlsToTry = [];
@@ -2383,6 +2449,9 @@ class SingleAgentClient {
         firstWorkingUrl = url;
         break;
       }
+      if (result.status === 429 || result.status === 503 && result.retryAfter !== void 0) {
+        throw new AgentRateLimitedError(url, result.status, result.retryAfter, result.error);
+      }
       if (result.status === 401) {
         got401 = true;
         first401Error ??= result.error;
@@ -2659,6 +2728,24 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
         };
       }
     }
+    let artifactPayloadValidator;
+    if (registration?.deliveryKind === "artifact") {
+      try {
+        const loader = require2("../validation/schema-loader");
+        artifactPayloadValidator = loader.getSchemaValidatorByRef(
+          "content-standards/artifact-webhook-payload.json",
+          this.resolvedAdcpVersion
+        );
+        if (!artifactPayloadValidator) throw new ConfigurationError("Bundled artifact webhook schema is unavailable.");
+      } catch (cause) {
+        return {
+          ok: false,
+          code: "webhook_verification_unavailable",
+          message: "Artifact webhook schema configuration is unavailable.",
+          cause
+        };
+      }
+    }
     if (registration?.mode === "rfc9421") {
       const { verifyWebBotAuth, selectSignatureProfile, WebBotAuthError, WebBotAuthUnavailableError } = loadWebBotAuth();
       const requestMethod = options.requestMethod;
@@ -2833,7 +2920,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       const isReport = registration.deliveryKind === "reporting";
       const payload = isReport ? body.result : body;
       const schemaRef = isReport ? "media-buy/media-buy-delivery-webhook-result.json" : "content-standards/artifact-webhook-payload.json";
-      const validator = loader.getSchemaValidatorByRef(schemaRef, this.resolvedAdcpVersion);
+      const validator = isReport ? loader.getSchemaValidatorByRef(schemaRef, this.resolvedAdcpVersion) : artifactPayloadValidator;
       const envelopeValidator = isReport ? loader.getSchemaValidatorByRef("core/mcp-webhook-payload.json", this.resolvedAdcpVersion) : void 0;
       if (!validator || !validator(payload) || isReport && (!envelopeValidator || !envelopeValidator(body) || body.task_type !== "media_buy_delivery"))
         return {
@@ -3595,17 +3682,32 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       timestamp
     }).ok;
   }
-  /**
-   * Execute task and call appropriate handler on completion
-   *
-   * Adapts requests for maintained AdCP 3 releases and normalizes product responses.
-   */
+  /** One task owns discovery and dispatch sessions unless the caller already owns reuse. */
+  withConnectionScope(options, run, preserveSessionOnResult) {
+    const transport = normalizeTransportOptions(options?.transport ?? this.config.transport);
+    return withMCPConnectionPolicy(
+      transport,
+      () => shouldReuseMCPConnection(transport?.trustedFetchFn !== void 0) ? run() : withMCPConnectionScope(run, {
+        signal: options?.signal,
+        preserveOnInterruption: true,
+        preserveSessionOnResult
+      })
+    );
+  }
+  withTaskConnectionScope(options, run) {
+    return withTaskDeadline(
+      options,
+      (effective) => this.withConnectionScope(effective, () => run(effective), isNonterminalTaskResult)
+    );
+  }
+  /** Execute a task, adapt maintained AdCP 3 releases, and call the completion handler. */
   async executeAndHandle(taskType, handlerName, params, inputHandler, options, transformCompletedResponse, legacyFormatConverter, canonicalRequest, projectionCatalogs) {
+    const projectionDrifts = getCreativeDeliveryDiagnostics(params);
     const requestParamsSnapshot = structuredClone(params);
     const canonicalRequestSnapshot = canonicalRequest === void 0 ? void 0 : structuredClone(canonicalRequest);
     const deferredProjectionCatalogs = projectionCatalogs ? structuredClone(projectionCatalogs) : void 0;
     const taskOptionsSnapshot = snapshotTaskOptions(options);
-    return withTaskDeadline(
+    return this.withTaskConnectionScope(
       taskOptionsSnapshot,
       (effectiveOptions) => this.executeAndHandleWithinDeadline(
         taskType,
@@ -3616,11 +3718,12 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
         transformCompletedResponse,
         legacyFormatConverter,
         canonicalRequestSnapshot,
-        deferredProjectionCatalogs
+        deferredProjectionCatalogs,
+        projectionDrifts
       )
     );
   }
-  async executeAndHandleWithinDeadline(taskType, handlerName, params, inputHandler, options, transformCompletedResponse, legacyFormatConverter, canonicalRequest, projectionCatalogs) {
+  async executeAndHandleWithinDeadline(taskType, handlerName, params, inputHandler, options, transformCompletedResponse, legacyFormatConverter, canonicalRequest, projectionCatalogs, projectionDrifts = []) {
     throwIfAborted(options?.signal);
     const canonicalCreativeInvocation = CANONICAL_CREATIVE_ACTIVITY_TASKS.has(taskType) || canonicalRequest !== void 0;
     params = await this.applyAccountPolicy(taskType, params, options);
@@ -3696,7 +3799,15 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     if (negotiatedRelease?.downgraded && !options?.skipIdempotencyAutoInject && !options?.skipAccountValidation && !options?.skipRequestValidation) {
       this.executor.validateRequest(taskType, adaptedParams, inputSchemaStripLogs, negotiatedRelease.version);
     }
-    const adaptationLogs = [...adaptDriftLogs];
+    const adaptationLogs = [
+      ...projectionDrifts.map((drift) => ({
+        ...drift,
+        taskName: taskType,
+        clientVersion: this.resolvedAdcpVersion,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })),
+      ...adaptDriftLogs
+    ];
     if (webhookDriftLog) adaptationLogs.push(webhookDriftLog);
     const canonicalInputHandler = this.canonicalCreativeInputHandler(
       taskType,
@@ -4805,8 +4916,15 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * stamps it on the version envelope and validates the response against it.
    */
   withNegotiatedRelease(options, negotiated) {
-    if (!negotiated?.downgraded) return options;
-    return { ...options ?? {}, wireAdcpVersion: negotiated.version, negotiatedAdcpVersion: negotiated.version };
+    if (!negotiated) return options;
+    return {
+      ...options ?? {},
+      selectedAdcpVersion: negotiated.version,
+      ...negotiated.downgraded && {
+        wireAdcpVersion: negotiated.version,
+        negotiatedAdcpVersion: negotiated.version
+      }
+    };
   }
   /**
    * Refuse a tool the negotiated release does not define (a 3.2-only task
@@ -5075,8 +5193,9 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     const adapterKey = resolveAdapterKey(this.resolvedAdcpVersion, perCallCapabilities ?? this.cachedCapabilities);
     if (adapterKey) {
       const versionAdapter = getVersionAdapter(adapterKey, taskType);
-      if (versionAdapter?.adaptRequest) {
-        const result = versionAdapter.adaptRequest(adapted);
+      const adaptRequest = negotiated ? versionAdapter?.adaptRequest : versionAdapter?.adaptUnnegotiatedRequest ?? versionAdapter?.adaptRequest;
+      if (adaptRequest) {
+        const result = adaptRequest(adapted);
         adapted = result.params;
         if (result.drift) {
           driftLogs.push({
@@ -5138,7 +5257,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       legacyFormatConverter,
       projectionCatalogs ?? this.config.projectionCatalogs
     );
-    return withTaskDeadline(snapshotTaskOptions(taskOptions), async (effectiveOptions) => {
+    return this.withTaskConnectionScope(snapshotTaskOptions(taskOptions), async (effectiveOptions) => {
       this.assertRequestSupportedByConfiguredVersion("get_products", params, effectiveOptions);
       let request = await this.applyAccountPolicy("get_products", params, effectiveOptions);
       const legacyAccountId = request.account_id;
@@ -5177,7 +5296,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
         request = { ...request, buying_mode: "wholesale" };
       }
       const account = canonicalAccountRoutingSnapshot(accountReference);
-      const cache = !effectiveOptions.skipRequestValidation && !effectiveOptions.preserveGovernedPayload && !inputHandler && !request.push_notification_config && !this.config.webhookUrlTemplate && !this.config.handlers?.onGetProductsStatusChange ? this.config.productCache : void 0;
+      const cache = !effectiveOptions.skipRequestValidation && !this.usesScopedDiscoveryTransport(effectiveOptions) && !effectiveOptions.preserveGovernedPayload && !inputHandler && !request.push_notification_config && !this.config.webhookUrlTemplate && !this.config.handlers?.onGetProductsStatusChange ? this.config.productCache : void 0;
       const cacheScope = cache ? JSON.stringify([
         this.accountScope(),
         this.resolvedAdcpVersion,
@@ -5327,7 +5446,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       ...snapshotTaskOptions(options),
       ...projectionCatalogs !== void 0 && { projectionCatalogs }
     };
-    return withTaskDeadline(
+    return this.withTaskConnectionScope(
       snapshottedOptions,
       (effectiveOptions) => this.createMediaBuyWithinDeadline(requestSnapshot, inputHandler, effectiveOptions)
     );
@@ -5486,7 +5605,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       ...snapshotTaskOptions(options),
       ...projectionCatalogs !== void 0 && { projectionCatalogs }
     };
-    return withTaskDeadline(
+    return this.withTaskConnectionScope(
       snapshottedOptions,
       (effectiveOptions) => this.updateMediaBuyWithinDeadline(requestSnapshot, inputHandler, effectiveOptions)
     );
@@ -5577,7 +5696,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       ...projectionCatalogs !== void 0 && { projectionCatalogs },
       ...creativeFormatProjection !== void 0 && { creativeFormatProjection }
     };
-    return withTaskDeadline(
+    return this.withTaskConnectionScope(
       snapshottedOptions,
       (effectiveOptions) => this.syncCreativesWithinDeadline(requestSnapshot, inputHandler, effectiveOptions)
     );
@@ -6029,25 +6148,31 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * Pass an explicit agent via options.agent to override.
    */
   async syncPlans(params, inputHandler, options) {
+    if (!options?.agent && !this.config.governance?.campaign?.agent) {
+      return this.executeTaskUnprojected("sync_plans", params, inputHandler, options);
+    }
     const agent = options?.agent ?? this.getGovernanceAgent();
     this.executor.validateRequest("sync_plans", params);
     return this.executor.executeTask(agent, "sync_plans", params, inputHandler, options);
   }
-  /**
-   * Get governance audit logs for one or more plans.
-   * Returns budget state, channel allocation, per-campaign breakdown, and audit trail.
-   *
-   * Uses the governance agent from config.governance.campaign.agent by default.
-   * Pass an explicit agent via options.agent to override.
-   */
-  async getPlanAuditLogs(params, options) {
+  async getPlanAuditLogs(params, inputHandlerOrOptions, taskOptions) {
+    const inputHandler = typeof inputHandlerOrOptions === "function" ? inputHandlerOrOptions : void 0;
+    const options = inputHandlerOrOptions === void 0 || typeof inputHandlerOrOptions === "function" ? taskOptions : inputHandlerOrOptions;
+    if (!options?.agent && !this.config.governance?.campaign?.agent) {
+      return this.executeTaskUnprojected(
+        "get_plan_audit_logs",
+        params,
+        inputHandler,
+        options
+      );
+    }
     const agent = options?.agent ?? this.getGovernanceAgent();
     this.executor.validateRequest("get_plan_audit_logs", params);
     return this.executor.executeTask(
       agent,
       "get_plan_audit_logs",
       params,
-      void 0,
+      inputHandler,
       options
     );
   }
@@ -6085,6 +6210,374 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     }
     return agent;
   }
+  async advertisesTool(taskName, options) {
+    const context = {};
+    const capabilities = await this.getCapabilities({
+      ...options,
+      [CAPABILITY_DISCOVERY_CONTEXT]: context
+    });
+    return capabilities.discoveredTools?.includes(taskName) === true || context.toolSchemas?.has(taskName) === true;
+  }
+  /** Accept a committed proposal to create or amend a media buy, or apply a negotiated cancellation. */
+  async acceptProposal(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "accept_proposal",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP acquire_rights tool. */
+  async acquireRights(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "acquire_rights",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Generate, transform, refine, retrieve, or adapt creative manifests for advertised creative capabilities. */
+  async buildCreative(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "build_creative",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Create a media buy directly from published seller products and record its accepted commercial snapshot. */
+  async buyProducts(params, inputHandler, options) {
+    return this.executeTaskUnprojected("buy_products", params, inputHandler, options);
+  }
+  /** Execute the AdCP calibrate_content tool. */
+  async calibrateContent(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "calibrate_content",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP check_governance tool. */
+  async checkGovernance(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "check_governance",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Control a seller compliance scenario. Intended for conformance testing. */
+  async complyTestController(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "comply_test_controller",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Rename, pause, resume, cancel, or adjust delivery controls within accepted proposal change rights. */
+  async controlMediaBuy(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "control_media_buy",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP create_collection_list tool. */
+  async createCollectionList(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "create_collection_list",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP create_content_standards tool. */
+  async createContentStandards(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "create_content_standards",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Terminally decline one or more proposals and record the buyer's reason. */
+  async declineProposals(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "decline_proposals",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP delete_collection_list tool. */
+  async deleteCollectionList(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "delete_collection_list",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Retrieve spend, credit or balance status, and invoice history for an operator-billed account. */
+  async getAccountFinancials(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "get_account_financials",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP get_brand_identity tool. */
+  async getBrandIdentity(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "get_brand_identity",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP get_collection_list tool. */
+  async getCollectionList(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "get_collection_list",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP get_content_standards tool. */
+  async getContentStandards(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "get_content_standards",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Evaluate a creative manifest and return scored safety, content, quality, and governance features. */
+  async getCreativeFeatures(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "get_creative_features",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP get_media_buy_artifacts tool. */
+  async getMediaBuyArtifacts(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "get_media_buy_artifacts",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Check reporting health, enumerate expected periods and all retained revisions, or resolve one exact reporting revision. */
+  async getReportingStatus(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "get_reporting_status",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP get_rights tool. */
+  async getRights(params, inputHandler, options) {
+    return this.executeTaskUnprojected("get_rights", params, inputHandler, options);
+  }
+  /** Execute the AdCP list_collection_lists tool. */
+  async listCollectionLists(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "list_collection_lists",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP list_content_standards tool. */
+  async listContentStandards(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "list_content_standards",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP list_creative_formats tool. */
+  async listCreativeFormats(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "list_creative_formats",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Discover account-scoped creative transformers and their selectable configuration options. */
+  async listTransformers(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "list_transformers",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Log batches of marketing events against a configured event source for measurement and attribution. */
+  async logEvent(params, inputHandler, options) {
+    return this.executeTaskUnprojected("log_event", params, inputHandler, options);
+  }
+  /** Revise draft proposals, finalize them into committed, inventory-held snapshots, or extend a committed hold. */
+  async refineProposals(params, inputHandler, options) {
+    return this.executeTask("refine_proposals", params, inputHandler, options);
+  }
+  /** Execute the AdCP report_plan_adjustment tool. */
+  async reportPlanAdjustment(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "report_plan_adjustment",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP report_plan_outcome tool. */
+  async reportPlanOutcome(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "report_plan_outcome",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Report vendor-service consumption and final measurements for revenue tracking and billing reconciliation. */
+  async reportUsage(params, inputHandler, options) {
+    return this.executeTaskUnprojected("report_usage", params, inputHandler, options);
+  }
+  /** Ask a seller to create one or more draft media-plan proposals from a campaign brief. */
+  async requestProposals(params, inputHandler, options) {
+    return this.executeTask("request_proposals", params, inputHandler, options);
+  }
+  /** Execute the AdCP search_brands tool. */
+  async searchBrands(params, inputHandler, options) {
+    return this.executeTaskUnprojected("search_brands", params, inputHandler, options);
+  }
+  /** Register, replace, pause, or clear caller-scoped webhooks for agent-level notifications. */
+  async syncAgentNotificationConfigs(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "sync_agent_notification_configs",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** List or synchronize buyer-managed account catalog feeds, suppress or restore specific items, and read current availability state. */
+  async syncCatalogs(params, inputHandler, options) {
+    return this.executeTaskUnprojected("sync_catalogs", params, inputHandler, options);
+  }
+  /** List or synchronize account event sources with upsert and optional replacement semantics. */
+  async syncEventSources(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "sync_event_sources",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Bind or replace the governance agent used for approval across specific advertiser accounts. */
+  async syncGovernance(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "sync_governance",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Record a consumer's independently verified reporting totals and destination evidence in the seller ledger. */
+  async syncReportingReceipts(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "sync_reporting_receipts",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Tell a seller whether expected reporting was received, omitted, missing, unreadable, or contradictory. */
+  async syncReportingStatus(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "sync_reporting_status",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP update_collection_list tool. */
+  async updateCollectionList(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "update_collection_list",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP update_content_standards tool. */
+  async updateContentStandards(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "update_content_standards",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP update_rights tool. */
+  async updateRights(params, inputHandler, options) {
+    return this.executeTaskUnprojected("update_rights", params, inputHandler, options);
+  }
+  /** Execute the AdCP validate_content_delivery tool. */
+  async validateContentDelivery(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "validate_content_delivery",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Preflight a creative manifest against canonical formats, products, third-party formats, or agent capabilities. */
+  async validateInput(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "validate_input",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP validate_property_delivery tool. */
+  async validatePropertyDelivery(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "validate_property_delivery",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP verify_brand_claim tool. */
+  async verifyBrandClaim(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "verify_brand_claim",
+      params,
+      inputHandler,
+      options
+    );
+  }
+  /** Execute the AdCP verify_brand_claims tool. */
+  async verifyBrandClaims(params, inputHandler, options) {
+    return this.executeTaskUnprojected(
+      "verify_brand_claims",
+      params,
+      inputHandler,
+      options
+    );
+  }
   // ====== PROTOCOL TASKS ======
   /**
    * Get AdCP capabilities
@@ -6094,7 +6587,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * @param options - Task execution options
    */
   async getAdcpCapabilities(params, inputHandler, options) {
-    return withTaskDeadline(
+    return this.withTaskConnectionScope(
       snapshotTaskOptions(options),
       (effectiveOptions) => this.getAdcpCapabilitiesWithinDeadline(params, inputHandler, effectiveOptions)
     );
@@ -6176,7 +6669,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     );
   }
   async resolveAccount(hints = {}, options, onTaskResult) {
-    return withTaskDeadline(snapshotTaskOptions(options), async (effectiveOptions) => {
+    return this.withTaskConnectionScope(snapshotTaskOptions(options), async (effectiveOptions) => {
       const capabilities = await this.getCapabilities(effectiveOptions);
       if (capabilities._synthetic || !capabilities.account) {
         throw new AccountRequiredError(
@@ -6616,6 +7109,12 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
         return this.getMediaBuyDelivery(params, inputHandler, options);
       case "get_creative_delivery":
         return this.getCreativeDelivery(params, inputHandler, options);
+      case "preview_creative":
+        return this.previewCreative(params, inputHandler, options);
+      case "sync_plans":
+        return this.syncPlans(params, inputHandler, options);
+      case "get_plan_audit_logs":
+        return this.getPlanAuditLogs(params, inputHandler, options);
       case "get_principal":
         return this.getPrincipal(params, inputHandler, options);
       case "sync_principal":
@@ -6652,7 +7151,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
   async executeTaskUnprojected(taskName, params, inputHandler, options, handlerName, beforeDispatch) {
     const requestParamsSnapshot = structuredClone(params);
     const taskOptionsSnapshot = snapshotTaskOptions(options);
-    return withTaskDeadline(taskOptionsSnapshot, async (effectiveOptions) => {
+    return this.withTaskConnectionScope(taskOptionsSnapshot, async (effectiveOptions) => {
       const result = await this.executeTaskUnprojectedWithinDeadline(
         taskName,
         requestParamsSnapshot,
@@ -6694,6 +7193,11 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       const serverVersion = await this.detectServerVersion(detectionOptions);
       detectedServerVersion = serverVersion;
       detectedServerVersionSynthetic = capabilityDiscoveryContext.capabilities?._synthetic;
+      if ((taskName === "sync_plans" || taskName === "get_plan_audit_logs") && capabilityDiscoveryContext.capabilities?.discoveredTools?.includes(taskName) !== true && capabilityDiscoveryContext.toolSchemas?.has(taskName) !== true) {
+        throw new ConfigurationError(
+          `No governance agent configured and this agent does not advertise ${taskName}. Pass options.agent or configure governance.campaign.agent.`
+        );
+      }
       const negotiatedRelease = this.negotiateCallRelease(capabilityDiscoveryContext.capabilities, options);
       this.assertToolAvailableAtRelease(taskName, negotiatedRelease, capabilityDiscoveryContext.toolSchemas);
       this.assertRequestSupportedByTargetVersion(
@@ -7067,21 +7571,10 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       });
     });
   }
-  // ====== TASK MANAGEMENT & NOTIFICATIONS ======
-  /**
-   * List all tasks for this agent with detailed information
-   *
-   * @returns Promise resolving to array of task information
-   *
-   * @example
-   * ```typescript
-   * const tasks = await client.listTasks();
-   * tasks.forEach(task => {
-   *   console.log(`${task.taskName}: ${task.status}`);
-   * });
-   * ```
-   */
-  async listTasks() {
+  async listTasks(params, inputHandler, options) {
+    if (params !== void 0) {
+      return this.executeTaskUnprojected("list_tasks", params, inputHandler, options);
+    }
     const tasks = await this.executor.getTaskList(this.agent.id);
     return tasks.map(
       (task) => assertNativeRequestProposalsTask(
@@ -7231,6 +7724,9 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * ```
    */
   async getAgentInfo(options) {
+    return this.withConnectionScope(options, () => this.getAgentInfoWithConnectionPolicy(options));
+  }
+  async getAgentInfoWithConnectionPolicy(options) {
     throwIfAborted(options?.signal);
     const reuse = this.config._reuseConfiguredDiscovery?.() && !this.usesScopedDiscoveryTransport(options);
     if (!reuse) return this.getAgentInfoLive(options);
@@ -7327,7 +7823,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       } else if (readAuthToken) {
         connectOptions.authToken = readAuthToken;
       }
-      const modernTools = !transport?.trustedFetchFn && this.discoveredMcpEra === "legacy" && Date.now() - this.discoveredMcpEraAt < 5 * 60 * 1e3 ? { handled: false } : await withResponseSizeLimit(
+      const modernTools = !this.usesScopedDiscoveryTransport(options) && this.discoveredMcpEra === "legacy" && Date.now() - this.discoveredMcpEraAt < 5 * 60 * 1e3 ? { handled: false } : await withResponseSizeLimit(
         maxResponseBytes,
         () => tryListModernMCPTools(agent.agent_uri, readAuthToken, this.normalizedAgent.headers, {
           authProvider,
@@ -7479,6 +7975,9 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * ```
    */
   async getCapabilities(options) {
+    return this.withConnectionScope(options, () => this.getCapabilitiesWithConnectionPolicy(options));
+  }
+  async getCapabilitiesWithConnectionPolicy(options) {
     throwIfAborted(options?.signal);
     this.synchronizeCapabilityEvidenceAuthorizationScope();
     const discoveryContext = options?.[CAPABILITY_DISCOVERY_CONTEXT];
@@ -7733,6 +8232,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     const effectiveAgent = this.normalizedAgent;
     return canonicalizeJson({
       authToken: effectiveAgent.auth_token ?? null,
+      connectionPartition: this.config.transport?.connectionPartition ?? null,
       headers: effectiveAgent.headers ?? null,
       oauthTokens: effectiveAgent.oauth_tokens ?? null,
       oauthClient: effectiveAgent.oauth_client ?? null,
@@ -7765,8 +8265,9 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
   /** A comply() run owns its configured fetch; per-call transport changes still discover separately. */
   usesScopedDiscoveryTransport(options) {
     const transport = normalizeTransportOptions(options?.transport ?? this.config.transport);
-    if (!this.config._reuseConfiguredDiscovery?.()) return transport?.trustedFetchFn !== void 0;
     const configured = normalizeTransportOptions(this.config.transport);
+    if (transport?.connectionPartition !== configured?.connectionPartition) return true;
+    if (!this.config._reuseConfiguredDiscovery?.()) return transport?.trustedFetchFn !== void 0;
     return transport?.trustedFetchFn !== configured?.trustedFetchFn || transport?.allowPrivateIp !== configured?.allowPrivateIp || transport?.maxResponseBytes !== configured?.maxResponseBytes || transport?.requestTimeoutMs !== configured?.requestTimeoutMs || transport?.legacyCompat?.enabled !== configured?.legacyCompat?.enabled;
   }
   /**
@@ -7894,6 +8395,8 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       kid: (provider ? provider.keyid : signing.kid) ?? null,
       alg: (provider ? provider.algorithm : signing.alg) ?? null,
       alwaysSign: signing.always_sign ?? null,
+      alwaysSignProtocolMethods: signing.always_sign_protocol_methods ?? null,
+      unsignedCapabilityBootstrap: hasUnsignedCapabilityBootstrap(signing),
       signSupported: signing.sign_supported ?? null
     };
   }
@@ -7913,6 +8416,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       adcpVersion: this.resolvedAdcpVersion,
       wireAdcpVersion: this.config.wireAdcpVersion,
       authIdentity: config.authIdentity,
+      connectionPartition: transport?.connectionPartition,
       credentialKind: this.discoveryCredentialKind(),
       headers: withAmbientIdentityHeaders(this.normalizedAgent.headers),
       signing: this.discoverySigningFingerprint(),