@adcp/sdk 17.0.0-beta.0 → 17.0.0-beta.2

package/dist/lib/core/SingleAgentClient.mjs

@@ -3,7 +3,8 @@ 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 { withMCPConnectionPolicy } from "../protocols/mcp-connection-policy.mjs";
+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";
@@ -23,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";
@@ -74,6 +85,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,
@@ -175,6 +187,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";
@@ -740,10 +753,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",
@@ -1027,7 +1037,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);
@@ -1835,8 +1857,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);
@@ -2309,6 +2341,9 @@ 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) {
@@ -2319,8 +2354,8 @@ class SingleAgentClient {
   }
   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);
@@ -2350,19 +2385,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();
@@ -2379,7 +2430,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 = [];
@@ -2402,6 +2454,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;
@@ -2678,6 +2733,33 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
         };
       }
     }
+    let reportingAdcpVersion;
+    let artifactPayloadValidator;
+    if (registration?.deliveryKind) {
+      try {
+        if (registration.deliveryKind === "reporting") {
+          const { prepareMediaBuyDeliveryWebhookValidation } = require2("../webhooks/media-buy-delivery");
+          reportingAdcpVersion = prepareMediaBuyDeliveryWebhookValidation(
+            options.adcpVersion ?? this.resolvedAdcpVersion
+          ).adcpVersion;
+        } else {
+          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: registration.deliveryKind === "reporting" ? "Reporting webhook schema configuration is unavailable." : "Artifact webhook schema configuration is unavailable.",
+          cause
+        };
+      }
+    }
     if (registration?.mode === "rfc9421") {
       const { verifyWebBotAuth, selectSignatureProfile, WebBotAuthError, WebBotAuthUnavailableError } = loadWebBotAuth();
       const requestMethod = options.requestMethod;
@@ -2847,21 +2929,45 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       return parsedPayload;
     }
     if (registration?.deliveryKind) {
-      const loader = require2("../validation/schema-loader");
-      const body = parsedPayload.payload;
+      let body = parsedPayload.payload;
       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 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 {
-          ok: false,
-          code: "webhook_envelope_invalid",
-          message: "Authenticated delivery does not match its registered payload kind"
-        };
+      let payload;
+      if (isReport) {
+        const { parseMediaBuyDeliveryWebhook } = require2("../webhooks/media-buy-delivery");
+        const report = parseMediaBuyDeliveryWebhook(body, {
+          adcpVersion: reportingAdcpVersion
+        });
+        if (!report.ok) {
+          if (report.code === "webhook_unsupported_payload") {
+            return {
+              ...report,
+              message: "Registered reporting delivery requires a media_buy_delivery MCP envelope.",
+              errors: ["Registered reporting delivery requires a media_buy_delivery MCP envelope."]
+            };
+          }
+          return report;
+        }
+        if (report.wireFormat !== "mcp_envelope") {
+          return {
+            ok: false,
+            code: "webhook_unsupported_payload",
+            message: "Registered reporting delivery requires an MCP envelope."
+          };
+        }
+        body = report.envelope;
+        payload = report.result;
+      } else {
+        payload = body;
+        if (!artifactPayloadValidator || !artifactPayloadValidator(payload)) {
+          return {
+            ok: false,
+            code: "webhook_envelope_invalid",
+            message: "Authenticated delivery does not match its registered payload kind"
+          };
+        }
+      }
       const taskId = isReport && typeof body.task_id === "string" ? body.task_id : typeof body.media_buy_id === "string" ? body.media_buy_id : registration.operationId;
-      const operationId = isReport && typeof body.operation_id === "string" ? body.operation_id : registration.operationId;
+      const operationId = registration.operationId;
       const status = isReport && isAdcpStatus(body.status) ? body.status : "completed";
       return {
         ok: true,
@@ -3614,17 +3720,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,
@@ -3635,11 +3756,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);
@@ -3715,7 +3837,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,
@@ -4837,8 +4967,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
@@ -5107,8 +5244,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({
@@ -5170,7 +5308,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;
@@ -5379,7 +5517,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)
     );
@@ -5538,7 +5676,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)
     );
@@ -5629,7 +5767,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)
     );
@@ -6081,25 +6219,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
     );
   }
@@ -6137,6 +6281,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
@@ -6146,7 +6658,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)
     );
@@ -6228,7 +6740,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(
@@ -6672,6 +7184,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":
@@ -6708,7 +7226,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,
@@ -6750,6 +7268,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(
@@ -7123,21 +7646,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(
@@ -7287,10 +7799,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * ```
    */
   async getAgentInfo(options) {
-    return withMCPConnectionPolicy(
-      normalizeTransportOptions(options?.transport ?? this.config.transport),
-      () => this.getAgentInfoWithConnectionPolicy(options)
-    );
+    return this.withConnectionScope(options, () => this.getAgentInfoWithConnectionPolicy(options));
   }
   async getAgentInfoWithConnectionPolicy(options) {
     throwIfAborted(options?.signal);
@@ -7541,10 +8050,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * ```
    */
   async getCapabilities(options) {
-    return withMCPConnectionPolicy(
-      normalizeTransportOptions(options?.transport ?? this.config.transport),
-      () => this.getCapabilitiesWithConnectionPolicy(options)
-    );
+    return this.withConnectionScope(options, () => this.getCapabilitiesWithConnectionPolicy(options));
   }
   async getCapabilitiesWithConnectionPolicy(options) {
     throwIfAborted(options?.signal);