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

package/dist/lib/core/SingleAgentClient.js

@@ -35,6 +35,7 @@ __export(SingleAgentClient_exports, {
 });
 module.exports = __toCommonJS(SingleAgentClient_exports);
 var import_mcp_connection_policy = require('../protocols/mcp-connection-policy.js');
+var import_mcp_scope = require('../protocols/mcp-scope.js');
 var import_protocol_methods = require('../signing/protocol-methods.js');
 var import_pricing_adapter = require('../utils/pricing-adapter.js');
 var import_creative_adapter = require('../utils/creative-adapter.js');
@@ -83,6 +84,7 @@ var import_errors3 = require('../errors/index.js');
 var import_buyer_account_registry = require('./buyer-account-registry.js');
 var import_account_resolution = require('./account-resolution.js');
 var import_request_normalizer = require('../utils/request-normalizer.js');
+var import_legacy_metadata = require('../v2/projection/legacy-metadata.js');
 var import_global_async_local_storage = require('../utils/global-async-local-storage.js');
 var import_validate_user_agent = require('../utils/validate-user-agent.js');
 var import_webhook_url = require('./webhook-url.js');
@@ -92,7 +94,7 @@ var import_creative_delivery = require('../v2/projection/creative-delivery.js');
 var import_legacy_routes = require('../v2/projection/legacy-routes.js');
 var import_catalog_snapshot = require('../v2/projection/catalog-snapshot.js');
 var import_augment_response = require('../v2/projection/augment-response.js');
-var import_legacy_metadata = require('../v2/projection/legacy-metadata.js');
+var import_legacy_metadata2 = require('../v2/projection/legacy-metadata.js');
 var import_types = require('../v2/projection/types.js');
 var import_jcs = require('../utils/jcs.js');
 function loadWebBotAuth() {
@@ -100,6 +102,16 @@ function loadWebBotAuth() {
 }
 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);
+}
 function presentedStaticTransportCredential(authToken, headers, authProvider) {
   if (authProvider) return false;
   if (authToken) return true;
@@ -630,10 +642,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",
@@ -917,7 +926,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 import_AsyncHandler.AsyncHandler(config.handlers);
@@ -1465,18 +1486,18 @@ class SingleAgentClient {
           publisher_domain: option.publisher_domain,
           format_option_id: option.format_option_id
         } : { scope: "product", format_option_id: option.format_option_id };
-        const refs = (0, import_legacy_metadata.legacyFormatRefsForDeclaration)(option);
-        const declared = declaredOptions ? declaredOptions.get(product.product_id)?.some((declaredRef) => this.sameCanonicalOptionRef(declaredRef, ref)) : (0, import_legacy_metadata.sellerDeclaredFormatOption)(option);
-        if (declared !== void 0) (0, import_legacy_metadata.rememberSellerDeclaredFormatOption)(option, declared);
+        const refs = (0, import_legacy_metadata2.legacyFormatRefsForDeclaration)(option);
+        const declared = declaredOptions ? declaredOptions.get(product.product_id)?.some((declaredRef) => this.sameCanonicalOptionRef(declaredRef, ref)) : (0, import_legacy_metadata2.sellerDeclaredFormatOption)(option);
+        if (declared !== void 0) (0, import_legacy_metadata2.rememberSellerDeclaredFormatOption)(option, declared);
         if (declared === true && evidence)
-          (0, import_legacy_metadata.rememberSellerFormatEvidence)(option, { ...evidence, productId: product.product_id });
+          (0, import_legacy_metadata2.rememberSellerFormatEvidence)(option, { ...evidence, productId: product.product_id });
         this.rememberCanonicalLegacyRoute(this.canonicalLegacyRouteKey(account, product.product_id, ref), {
           kind: "product",
           accountScope,
           productId: product.product_id,
           optionRef: ref,
           refs,
-          ...declared === true && (0, import_legacy_metadata.sellerFormatEvidence)(option) ? { declaration: (0, import_legacy_metadata.structuredCloneWithLegacyCreativeMetadata)(option) } : {},
+          ...declared === true && (0, import_legacy_metadata2.sellerFormatEvidence)(option) ? { declaration: (0, import_legacy_metadata2.structuredCloneWithLegacyCreativeMetadata)(option) } : {},
           ...declared === false ? { undeclaredSelector: (0, import_legacy_routes.undeclaredFormatOptionSelector)(option) } : {}
         });
       }
@@ -1725,8 +1746,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);
@@ -2199,6 +2230,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) {
@@ -2209,8 +2243,8 @@ class SingleAgentClient {
   }
   async discoverMCPEndpointWithConnectionPolicy(providedUri, options) {
     (0, import_abort2.throwIfAborted)(options?.signal);
-    const { connectMCPWithFallback } = await import("../protocols/mcp.js");
-    const { probeModernMCPConnection } = await import("../protocols/mcp-modern.js");
+    const { connectMCPWithFallback, withScopedLegacyConnection } = await import("../protocols/mcp.js");
+    const { probeModernMCPConnection, retryAfterOf } = await import("../protocols/mcp-modern.js");
     const transport = (0, import_protocols.normalizeTransportOptions)(options?.transport ?? this.config.transport);
     const usesScopedFetch = this.usesScopedDiscoveryTransport(options);
     const endpointEpoch = this.discoveryEpochSnapshot(options);
@@ -2240,19 +2274,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();
@@ -2269,7 +2319,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 = [];
@@ -2292,6 +2343,9 @@ class SingleAgentClient {
         firstWorkingUrl = url;
         break;
       }
+      if (result.status === 429 || result.status === 503 && result.retryAfter !== void 0) {
+        throw new import_errors.AgentRateLimitedError(url, result.status, result.retryAfter, result.error);
+      }
       if (result.status === 401) {
         got401 = true;
         first401Error ??= result.error;
@@ -2568,6 +2622,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 } = require('../webhooks/media-buy-delivery.js');
+          reportingAdcpVersion = prepareMediaBuyDeliveryWebhookValidation(
+            options.adcpVersion ?? this.resolvedAdcpVersion
+          ).adcpVersion;
+        } else {
+          const loader = require('../validation/schema-loader.js');
+          artifactPayloadValidator = loader.getSchemaValidatorByRef(
+            "content-standards/artifact-webhook-payload.json",
+            this.resolvedAdcpVersion
+          );
+          if (!artifactPayloadValidator)
+            throw new import_errors.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;
@@ -2737,21 +2818,45 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       return parsedPayload;
     }
     if (registration?.deliveryKind) {
-      const loader = require('../validation/schema-loader.js');
-      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 } = require('../webhooks/media-buy-delivery.js');
+        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 && (0, import_task_status.isAdcpStatus)(body.status) ? body.status : "completed";
       return {
         ok: true,
@@ -3504,17 +3609,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 = (0, import_protocols.normalizeTransportOptions)(options?.transport ?? this.config.transport);
+    return (0, import_mcp_connection_policy.withMCPConnectionPolicy)(
+      transport,
+      () => (0, import_mcp_connection_policy.shouldReuseMCPConnection)(transport?.trustedFetchFn !== void 0) ? run() : (0, import_mcp_scope.withMCPConnectionScope)(run, {
+        signal: options?.signal,
+        preserveOnInterruption: true,
+        preserveSessionOnResult
+      })
+    );
+  }
+  withTaskConnectionScope(options, run) {
+    return (0, import_task_deadline.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 = (0, import_legacy_metadata.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 (0, import_task_deadline.withTaskDeadline)(
+    return this.withTaskConnectionScope(
       taskOptionsSnapshot,
       (effectiveOptions) => this.executeAndHandleWithinDeadline(
         taskType,
@@ -3525,11 +3645,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 = []) {
     (0, import_abort2.throwIfAborted)(options?.signal);
     const canonicalCreativeInvocation = CANONICAL_CREATIVE_ACTIVITY_TASKS.has(taskType) || canonicalRequest !== void 0;
     params = await this.applyAccountPolicy(taskType, params, options);
@@ -3605,7 +3726,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,
@@ -4727,8 +4856,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
@@ -4997,8 +5133,9 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     const adapterKey = (0, import_version2.resolveAdapterKey)(this.resolvedAdcpVersion, perCallCapabilities ?? this.cachedCapabilities);
     if (adapterKey) {
       const versionAdapter = (0, import_version2.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({
@@ -5060,7 +5197,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       legacyFormatConverter,
       projectionCatalogs ?? this.config.projectionCatalogs
     );
-    return (0, import_task_deadline.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;
@@ -5263,13 +5400,13 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
   async createMediaBuy(params, inputHandler, options) {
     assertRawMethodForGovernedPayload("create_media_buy", options);
     this.assertDurableProjectionOverrideSupported(options?.legacyFormatConverter);
-    const requestSnapshot = (0, import_legacy_metadata.structuredCloneWithLegacyCreativeMetadata)(params);
+    const requestSnapshot = (0, import_legacy_metadata2.structuredCloneWithLegacyCreativeMetadata)(params);
     const projectionCatalogs = options?.projectionCatalogs ? structuredClone(options.projectionCatalogs) : void 0;
     const snapshottedOptions = {
       ...snapshotTaskOptions(options),
       ...projectionCatalogs !== void 0 && { projectionCatalogs }
     };
-    return (0, import_task_deadline.withTaskDeadline)(
+    return this.withTaskConnectionScope(
       snapshottedOptions,
       (effectiveOptions) => this.createMediaBuyWithinDeadline(requestSnapshot, inputHandler, effectiveOptions)
     );
@@ -5422,13 +5559,13 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
   async updateMediaBuy(params, inputHandler, options) {
     assertRawMethodForGovernedPayload("update_media_buy", options);
     this.assertDurableProjectionOverrideSupported(options?.legacyFormatConverter);
-    const requestSnapshot = (0, import_legacy_metadata.structuredCloneWithLegacyCreativeMetadata)(params);
+    const requestSnapshot = (0, import_legacy_metadata2.structuredCloneWithLegacyCreativeMetadata)(params);
     const projectionCatalogs = options?.projectionCatalogs ? structuredClone(options.projectionCatalogs) : void 0;
     const snapshottedOptions = {
       ...snapshotTaskOptions(options),
       ...projectionCatalogs !== void 0 && { projectionCatalogs }
     };
-    return (0, import_task_deadline.withTaskDeadline)(
+    return this.withTaskConnectionScope(
       snapshottedOptions,
       (effectiveOptions) => this.updateMediaBuyWithinDeadline(requestSnapshot, inputHandler, effectiveOptions)
     );
@@ -5504,12 +5641,12 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     this.assertDurableProjectionOverrideSupported(
       options?.creativeFormatProjection?.legacyFormatConverter ?? options?.legacyFormatConverter
     );
-    const requestSnapshot = (0, import_legacy_metadata.structuredCloneWithLegacyCreativeMetadata)(params);
+    const requestSnapshot = (0, import_legacy_metadata2.structuredCloneWithLegacyCreativeMetadata)(params);
     const projectionCatalogs = options?.projectionCatalogs ? structuredClone(options.projectionCatalogs) : void 0;
     const creativeFormatProjection = options?.creativeFormatProjection ? {
       ...options.creativeFormatProjection,
       ...options.creativeFormatProjection.selectorContainers !== void 0 && {
-        selectorContainers: (0, import_legacy_metadata.structuredCloneWithLegacyCreativeMetadata)(
+        selectorContainers: (0, import_legacy_metadata2.structuredCloneWithLegacyCreativeMetadata)(
           options.creativeFormatProjection.selectorContainers
         )
       }
@@ -5519,7 +5656,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 (0, import_task_deadline.withTaskDeadline)(
+    return this.withTaskConnectionScope(
       snapshottedOptions,
       (effectiveOptions) => this.syncCreativesWithinDeadline(requestSnapshot, inputHandler, effectiveOptions)
     );
@@ -5677,10 +5814,10 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       const creativeRef = isPlainRecord(creative) ? optionRef(creative.format_option_ref) : void 0;
       if (isPlainRecord(creative) && creative.format_option_ref !== void 0 && !creativeRef) return false;
       const isSellerDeclaration = (value) => {
-        if (!isPlainRecord(value) || (0, import_legacy_metadata.sellerDeclaredFormatOption)(value) !== true || (0, import_legacy_metadata.isSynthesizedFormatOption)(value)) {
+        if (!isPlainRecord(value) || (0, import_legacy_metadata2.sellerDeclaredFormatOption)(value) !== true || (0, import_legacy_metadata2.isSynthesizedFormatOption)(value)) {
           return false;
         }
-        const evidence2 = (0, import_legacy_metadata.sellerFormatEvidence)(value);
+        const evidence2 = (0, import_legacy_metadata2.sellerFormatEvidence)(value);
         if (!evidence2 || evidence2.scopeKey !== scopeKey || typeof container.product_id === "string" && evidence2.productId !== container.product_id || evidence2.expiresAt <= Date.now() || evidence2.accountScope !== accountScope && evidence2.accountScope !== "none")
           return false;
         const ref = optionRef(value);
@@ -5694,7 +5831,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       };
       const declarations = [
         ...(Array.isArray(container.format_options) ? container.format_options : []).filter(isSellerDeclaration),
-        ...(0, import_legacy_metadata.selectedFormatOptions)(container).filter(isSellerDeclaration)
+        ...(0, import_legacy_metadata2.selectedFormatOptions)(container).filter(isSellerDeclaration)
       ];
       if (typeof container.product_id === "string") {
         for (const ref of [...refs, ...creativeRef ? [creativeRef] : []]) {
@@ -5971,25 +6108,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
     );
   }
@@ -6027,6 +6170,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
@@ -6036,7 +6547,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 (0, import_task_deadline.withTaskDeadline)(
+    return this.withTaskConnectionScope(
       snapshotTaskOptions(options),
       (effectiveOptions) => this.getAdcpCapabilitiesWithinDeadline(params, inputHandler, effectiveOptions)
     );
@@ -6118,7 +6629,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
     );
   }
   async resolveAccount(hints = {}, options, onTaskResult) {
-    return (0, import_task_deadline.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 import_errors3.AccountRequiredError(
@@ -6562,6 +7073,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":
@@ -6598,7 +7115,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 (0, import_task_deadline.withTaskDeadline)(taskOptionsSnapshot, async (effectiveOptions) => {
+    return this.withTaskConnectionScope(taskOptionsSnapshot, async (effectiveOptions) => {
       const result = await this.executeTaskUnprojectedWithinDeadline(
         taskName,
         requestParamsSnapshot,
@@ -6640,6 +7157,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 import_errors.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(
@@ -7013,21 +7535,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) => (0, import_request_proposals_guard.assertNativeRequestProposalsTask)(
@@ -7177,10 +7688,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * ```
    */
   async getAgentInfo(options) {
-    return (0, import_mcp_connection_policy.withMCPConnectionPolicy)(
-      (0, import_protocols.normalizeTransportOptions)(options?.transport ?? this.config.transport),
-      () => this.getAgentInfoWithConnectionPolicy(options)
-    );
+    return this.withConnectionScope(options, () => this.getAgentInfoWithConnectionPolicy(options));
   }
   async getAgentInfoWithConnectionPolicy(options) {
     (0, import_abort2.throwIfAborted)(options?.signal);
@@ -7431,10 +7939,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
    * ```
    */
   async getCapabilities(options) {
-    return (0, import_mcp_connection_policy.withMCPConnectionPolicy)(
-      (0, import_protocols.normalizeTransportOptions)(options?.transport ?? this.config.transport),
-      () => this.getCapabilitiesWithConnectionPolicy(options)
-    );
+    return this.withConnectionScope(options, () => this.getCapabilitiesWithConnectionPolicy(options));
   }
   async getCapabilitiesWithConnectionPolicy(options) {
     (0, import_abort2.throwIfAborted)(options?.signal);