@adcp/sdk 16.4.0 → 16.5.0

package/dist/lib/core/TaskExecutor.mjs

@@ -3,7 +3,12 @@ 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 { VersionUnsupportedError } from "../errors/index.mjs";
+import {
+  NeedsAuthorizationError,
+  hasValidatedMcpAuthorizationRequirements
+} from "../auth/oauth/authorization-required.mjs";
 import { deliveryWebhookRegistrationId } from "./webhook-registration.mjs";
 import { isAdcpVersionAtLeast } from "../utils/adcp-version-config.mjs";
 function validateIdentity33Payload(...args) {
@@ -17,6 +22,16 @@ import {
   prepareProtocolToolCall
 } from "../protocols/index.mjs";
 import { listMCPTasks } from "../protocols/mcp-tasks.mjs";
+import { ensureClientCredentialsTokens, getAgentStorage } from "../auth/oauth/index.mjs";
+import { getNonInteractiveOAuthProvider, shareNonInteractiveOAuthProvider } from "../auth/oauth/provider-cache.mjs";
+import { isLikelyPrivateUrl } from "../net/address-guards.mjs";
+import { assertSigningPolicy } from "../signing/protocol-methods.mjs";
+import {
+  buildAgentSigningContext,
+  CAPABILITY_OP,
+  ensureCapabilityLoaded,
+  signingContextStorage
+} from "../signing/client.mjs";
 import { withPreparedProtocolToolCall } from "../protocols/prepared-call-context.mjs";
 import { getAuthToken } from "../auth/index.mjs";
 import { getSignedRequestRejection } from "../protocols/signedRequestRejection.mjs";
@@ -2400,22 +2415,79 @@ class TaskExecutor {
    * List tasks for an agent, preferring MCP Tasks protocol when available.
    */
   async listTasksForAgent(agent, transport) {
+    const credentialOwner = agent;
     if (agent.protocol === "mcp") {
-      const authToken = getAuthToken(agent);
+      agent = { ...agent, ...agent.headers && { headers: { ...agent.headers } } };
+      const version = this.config.wireAdcpVersion ?? this.config.adcpVersion ?? ADCP_VERSION;
+      let signingContext = buildAgentSigningContext(agent, { adcpVersion: version });
+      if (signingContext) agent = { ...agent, request_signing: signingContext.signing };
+      const syncTokens = () => {
+        agent.oauth_tokens = credentialOwner.oauth_tokens;
+      };
       try {
-        return await listMCPTasks(agent.agent_uri, authToken, void 0, {
-          transport: transport ?? this.config.transport,
-          onTransportActivity: this.config.onTransportActivity,
-          transportActivityContext: {
-            agentId: agent.id
+        if (credentialOwner.oauth_client_credentials) {
+          await ensureClientCredentialsTokens(credentialOwner, {
+            storage: getAgentStorage(credentialOwner),
+            allowPrivateIp: transport?.allowPrivateIp ?? isLikelyPrivateUrl(agent.agent_uri),
+            fetch: transport?.trustedFetchFn
+          });
+          syncTokens();
+        } else if (credentialOwner.oauth_tokens) {
+          getNonInteractiveOAuthProvider(credentialOwner, {
+            agentHint: credentialOwner.id,
+            storage: getAgentStorage(credentialOwner),
+            allowHttp: isLikelyPrivateUrl(credentialOwner.agent_uri)
+          });
+          shareNonInteractiveOAuthProvider(credentialOwner, agent);
+        }
+        signingContext = buildAgentSigningContext(agent, { adcpVersion: version });
+        if (signingContext) {
+          for (let attempt = 0; attempt < 2; attempt++) {
+            await ensureCapabilityLoaded(agent, signingContext, async (args) => {
+              const previousOwnerTokens = credentialOwner.oauth_tokens;
+              const previousRequestTokens = agent.oauth_tokens;
+              try {
+                return await ProtocolClient.callTool(agent, CAPABILITY_OP, args, {
+                  serverVersion: this.lastKnownServerVersion,
+                  adcpVersion: this.config.adcpVersion,
+                  wireAdcpVersion: this.config.wireAdcpVersion,
+                  versionEnvelope: this.config.versionEnvelope,
+                  transport: transport ?? this.config.transport,
+                  onTransportActivity: this.config.onTransportActivity
+                });
+              } finally {
+                if (credentialOwner.oauth_tokens === previousOwnerTokens && agent.oauth_tokens !== previousRequestTokens) {
+                  credentialOwner.oauth_tokens = agent.oauth_tokens;
+                } else {
+                  syncTokens();
+                }
+              }
+            });
+            syncTokens();
+            const current = buildAgentSigningContext(agent, { adcpVersion: version });
+            if (current.capabilityCacheKey === signingContext.capabilityCacheKey) break;
+            signingContext.invalidate();
+            if (attempt === 1)
+              throw new ConfigurationError("Task-list authorization changed during discovery; retry the call");
+            signingContext = current;
           }
-        });
+        }
+        return await signingContextStorage.run(
+          signingContext,
+          () => listMCPTasks(agent.agent_uri, getAuthToken(agent), void 0, {
+            signingContext,
+            headers: agent.headers,
+            transport: transport ?? this.config.transport,
+            onTransportActivity: this.config.onTransportActivity,
+            transportActivityContext: { agentId: agent.id }
+          })
+        );
       } catch (err) {
-        if (is401Error(err)) throw err;
+        if (is401Error(err) || err instanceof ConfigurationError || err instanceof TypeError) throw err;
       }
     }
     const response = await ProtocolClient.callTool(
-      agent,
+      credentialOwner,
       "tasks/list",
       {},
       {
@@ -2433,13 +2505,16 @@ class TaskExecutor {
    * Task tracking methods (PR #78)
    */
   async listTasks(agent, transport) {
-    const transportSnapshot = snapshotTransportOptions(transport ?? this.config.transport);
-    try {
-      return await this.listTasksForAgent(agent, transportSnapshot);
-    } catch {
-      console.warn("Failed to list tasks (see DEBUG=adcp:* logs for detail)");
-      return [];
-    }
+    return withMCPConnectionPolicy(transport ?? this.config.transport, async () => {
+      if (agent.request_signing) assertSigningPolicy(agent.request_signing);
+      const transportSnapshot = snapshotTransportOptions(transport ?? this.config.transport);
+      try {
+        return await this.listTasksForAgent(agent, transportSnapshot);
+      } catch {
+        console.warn("Failed to list tasks (see DEBUG=adcp:* logs for detail)");
+        return [];
+      }
+    });
   }
   async getTaskStatusWithRawResponse(agent, taskId, transport, signal, expectedTaskType, serverVersion, wireAdcpVersion, versionEnvelope, operationId) {
     const toolName = agent.protocol === "mcp" ? "tasks_get" : "tasks/get";
@@ -2515,7 +2590,8 @@ class TaskExecutor {
               a2aCancellationTaskId,
               cancelTransport?.trustedFetchFn,
               cancelTransport?.allowPrivateIp,
-              cancelTransport?.legacyCompat
+              cancelTransport?.legacyCompat,
+              wireAdcpVersion ?? this.config.wireAdcpVersion ?? this.config.adcpVersion ?? ADCP_VERSION
             ).catch(() => {
             });
           } catch {
@@ -4444,7 +4520,7 @@ class TaskExecutor {
       status: "failed",
       error: error.message || String(error),
       adcpError: adcpErrorInfo,
-      errorInstance: getSignedRequestRejection(error) ?? this.buildErrorInstance(taskId, adcpErrorInfo),
+      errorInstance: getSignedRequestRejection(error) ?? (error instanceof NeedsAuthorizationError && hasValidatedMcpAuthorizationRequirements(error.requirements, agent.agent_uri) ? error : this.buildErrorInstance(taskId, adcpErrorInfo)),
       correlationId,
       metadata: this.buildMetadata({
         taskId,

package/dist/lib/core/agent-discovery-cache.d.mts

@@ -89,6 +89,8 @@ export interface AgentDiscoveryKeyInput {
     authIdentity: string;
     /** Kind of credential presented (`none`, `bearer`, `oauth`, `header`, ...); never its value. */
     credentialKind?: string;
+    /** Local caller principal partition; included only in the opaque digest. */
+    connectionPartition?: string;
     /** Request headers the client sends on every call (correlation and credential headers are dropped here). */
     headers?: Record<string, string>;
     /** Non-secret fingerprint of the request-signing identity, when configured. */

package/dist/lib/core/agent-discovery-cache.d.ts

@@ -89,6 +89,8 @@ export interface AgentDiscoveryKeyInput {
     authIdentity: string;
     /** Kind of credential presented (`none`, `bearer`, `oauth`, `header`, ...); never its value. */
     credentialKind?: string;
+    /** Local caller principal partition; included only in the opaque digest. */
+    connectionPartition?: string;
     /** Request headers the client sends on every call (correlation and credential headers are dropped here). */
     headers?: Record<string, string>;
     /** Non-secret fingerprint of the request-signing identity, when configured. */

package/dist/lib/core/agent-discovery-cache.js

@@ -101,6 +101,7 @@ function agentDiscoveryCacheKey(input) {
       adcpVersion: input.adcpVersion,
       wireAdcpVersion: input.wireAdcpVersion ?? null,
       authIdentity: input.authIdentity,
+      ...input.connectionPartition !== void 0 && { connectionPartition: input.connectionPartition },
       credentialKind: input.credentialKind ?? null,
       headers,
       signing: input.signing ?? null,

package/dist/lib/core/agent-discovery-cache.mjs

@@ -73,6 +73,7 @@ function agentDiscoveryCacheKey(input) {
       adcpVersion: input.adcpVersion,
       wireAdcpVersion: input.wireAdcpVersion ?? null,
       authIdentity: input.authIdentity,
+      ...input.connectionPartition !== void 0 && { connectionPartition: input.connectionPartition },
       credentialKind: input.credentialKind ?? null,
       headers,
       signing: input.signing ?? null,

package/dist/lib/errors/index.js

@@ -460,7 +460,7 @@ function isRecord(value) {
 class ResponseTooLargeError extends ADCPError {
   constructor(limit, bytesRead, url, contentLengthHeader) {
     super(
-      contentLengthHeader !== void 0 ? `Response body declared ${contentLengthHeader} bytes, exceeds maxResponseBytes cap of ${limit} (${url})` : `Response body exceeded maxResponseBytes cap of ${limit} after reading ${bytesRead} bytes (${url})`
+      contentLengthHeader !== void 0 ? `Response body declared ${contentLengthHeader} bytes, exceeds response size cap of ${limit} (${url}). Raise transport.maxResponseBytes per client or per call to allow larger responses.` : `Response body exceeded response size cap of ${limit} after reading ${bytesRead} bytes (${url}). Raise transport.maxResponseBytes per client or per call to allow larger responses.`
     );
     this.limit = limit;
     this.bytesRead = bytesRead;

package/dist/lib/errors/index.mjs

@@ -399,7 +399,7 @@ function isRecord(value) {
 class ResponseTooLargeError extends ADCPError {
   constructor(limit, bytesRead, url, contentLengthHeader) {
     super(
-      contentLengthHeader !== void 0 ? `Response body declared ${contentLengthHeader} bytes, exceeds maxResponseBytes cap of ${limit} (${url})` : `Response body exceeded maxResponseBytes cap of ${limit} after reading ${bytesRead} bytes (${url})`
+      contentLengthHeader !== void 0 ? `Response body declared ${contentLengthHeader} bytes, exceeds response size cap of ${limit} (${url}). Raise transport.maxResponseBytes per client or per call to allow larger responses.` : `Response body exceeded response size cap of ${limit} after reading ${bytesRead} bytes (${url}). Raise transport.maxResponseBytes per client or per call to allow larger responses.`
     );
     this.limit = limit;
     this.bytesRead = bytesRead;

package/dist/lib/identity-3.3/trust.d.mts

@@ -149,15 +149,32 @@ export interface DemandGrantAuthorization {
 export interface DemandGrantOptions {
     evaluator: TrustEvaluator;
     now?: () => number;
-    /** Only evaluated for nonexclusive uncovered claims, never fetch failures. */
+    /**
+     * Only evaluated for uncovered claims, never fetch failures, and never for a scope an
+     * `exclusive_grants: true` record names in any grant.
+     */
     sellerAuthorization?: (claim: DemandGrantClaim) => Promise<boolean>;
     /** Only for authoritative absence; never after a 200 or an exclusive record. */
     legacyAuthorization?: (claim: DemandGrantClaim) => Promise<boolean>;
-    /** Seller-verified brand identity resolution, including the house's child-brand ID. Never accept a buyer-selected authorizer. */
+    /**
+     * Seller-verified brand identity resolution, including the house's child-brand ID. Never accept a buyer-selected authorizer.
+     * Return the house brand.json's mutual-assertion model resolves (a house redirect, or a `house_domain` whose
+     * `brand_refs[]` lists the brand back), or `undefined` when it resolves none, including a house that does not
+     * list the brand back: the brand is then its own house. The house is both the authorizing record and, with the
+     * brand's domain, a domain under which authority is implicit. An uncoded throw is an outage
+     * (`TrustRecordUnavailableError`, `SERVICE_UNAVAILABLE`), never `grant_absent`; an `IdentityAuthorizationError` or
+     * `AdcpError` (any error with a string `code`) thrown by the resolver keeps its code.
+     */
     resolveBrandHouse?: (brand: DemandGrantClaim['brand']) => Promise<{
         domain: string;
         brand_id: string;
     } | undefined>;
 }
-/** Always invoke before sync_accounts side effects and before spend. No account mutation. */
+/**
+ * Always invoke before sync_accounts side effects and before spend. No account mutation.
+ *
+ * Authority is implicit when `account.operator` and the signer's operator share a registrable domain with the
+ * brand's domain or with its house's (L2 Grants in trust records): an organization's own agents act for its
+ * child brands without a grant. Otherwise a grant chain from the house's record must reach the signer's operator.
+ */
 export declare function authorizeDemandGrant(claim: DemandGrantClaim, options: DemandGrantOptions): Promise<DemandGrantAuthorization>;

package/dist/lib/identity-3.3/trust.d.ts

@@ -149,15 +149,32 @@ export interface DemandGrantAuthorization {
 export interface DemandGrantOptions {
     evaluator: TrustEvaluator;
     now?: () => number;
-    /** Only evaluated for nonexclusive uncovered claims, never fetch failures. */
+    /**
+     * Only evaluated for uncovered claims, never fetch failures, and never for a scope an
+     * `exclusive_grants: true` record names in any grant.
+     */
     sellerAuthorization?: (claim: DemandGrantClaim) => Promise<boolean>;
     /** Only for authoritative absence; never after a 200 or an exclusive record. */
     legacyAuthorization?: (claim: DemandGrantClaim) => Promise<boolean>;
-    /** Seller-verified brand identity resolution, including the house's child-brand ID. Never accept a buyer-selected authorizer. */
+    /**
+     * Seller-verified brand identity resolution, including the house's child-brand ID. Never accept a buyer-selected authorizer.
+     * Return the house brand.json's mutual-assertion model resolves (a house redirect, or a `house_domain` whose
+     * `brand_refs[]` lists the brand back), or `undefined` when it resolves none, including a house that does not
+     * list the brand back: the brand is then its own house. The house is both the authorizing record and, with the
+     * brand's domain, a domain under which authority is implicit. An uncoded throw is an outage
+     * (`TrustRecordUnavailableError`, `SERVICE_UNAVAILABLE`), never `grant_absent`; an `IdentityAuthorizationError` or
+     * `AdcpError` (any error with a string `code`) thrown by the resolver keeps its code.
+     */
     resolveBrandHouse?: (brand: DemandGrantClaim['brand']) => Promise<{
         domain: string;
         brand_id: string;
     } | undefined>;
 }
-/** Always invoke before sync_accounts side effects and before spend. No account mutation. */
+/**
+ * Always invoke before sync_accounts side effects and before spend. No account mutation.
+ *
+ * Authority is implicit when `account.operator` and the signer's operator share a registrable domain with the
+ * brand's domain or with its house's (L2 Grants in trust records): an organization's own agents act for its
+ * child brands without a grant. Otherwise a grant chain from the house's record must reach the signer's operator.
+ */
 export declare function authorizeDemandGrant(claim: DemandGrantClaim, options: DemandGrantOptions): Promise<DemandGrantAuthorization>;

package/dist/lib/identity-3.3/trust.js

@@ -368,8 +368,16 @@ async function authorizeDemandGrant(claim, options) {
   });
   if (brand === operator && account === operator) return result("implicit", [brand]);
   if (brand === operator && account !== operator) throw new IdentityAuthorizationError("grant_absent");
-  const house = await options.resolveBrandHouse?.(claim.brand);
+  let house;
+  try {
+    house = await options.resolveBrandHouse?.(claim.brand);
+  } catch (cause) {
+    if (cause instanceof IdentityAuthorizationError || cause instanceof Error && typeof cause.code === "string")
+      throw cause;
+    unavailable(cause);
+  }
   const authoritativeBrand = house ? (0, import_etld.eTldPlusOne)(house.domain) : brand;
+  if (authoritativeBrand === operator && account === operator) return result("implicit", [brand, operator]);
   const grantClaim = house ? { ...claim, brand: { ...claim.brand, brand_id: house.brand_id } } : claim;
   const record = await options.evaluator.get(authoritativeBrand);
   if (record.status === "absent") {
@@ -394,7 +402,8 @@ async function authorizeDemandGrant(claim, options) {
     const grantee = registrableGrantee(g.grantee);
     return grantee !== void 0 && (grantee === account || selfOperated && grantee === operator) && grantsScope(g, claim.scope);
   });
-  if (!covered && !record.record.exclusive_grants && await options.sellerAuthorization?.(claim))
+  const exclusive = record.record.exclusive_grants === true && (record.record.grants ?? []).some((g) => grantsScope(g, claim.scope));
+  if (!covered && !exclusive && await options.sellerAuthorization?.(claim))
     return result("seller", [brand, account, operator]);
   throw new IdentityAuthorizationError("grant_absent");
 }

package/dist/lib/identity-3.3/trust.mjs

@@ -327,8 +327,16 @@ async function authorizeDemandGrant(claim, options) {
   });
   if (brand === operator && account === operator) return result("implicit", [brand]);
   if (brand === operator && account !== operator) throw new IdentityAuthorizationError("grant_absent");
-  const house = await options.resolveBrandHouse?.(claim.brand);
+  let house;
+  try {
+    house = await options.resolveBrandHouse?.(claim.brand);
+  } catch (cause) {
+    if (cause instanceof IdentityAuthorizationError || cause instanceof Error && typeof cause.code === "string")
+      throw cause;
+    unavailable(cause);
+  }
   const authoritativeBrand = house ? eTldPlusOne(house.domain) : brand;
+  if (authoritativeBrand === operator && account === operator) return result("implicit", [brand, operator]);
   const grantClaim = house ? { ...claim, brand: { ...claim.brand, brand_id: house.brand_id } } : claim;
   const record = await options.evaluator.get(authoritativeBrand);
   if (record.status === "absent") {
@@ -353,7 +361,8 @@ async function authorizeDemandGrant(claim, options) {
     const grantee = registrableGrantee(g.grantee);
     return grantee !== void 0 && (grantee === account || selfOperated && grantee === operator) && grantsScope(g, claim.scope);
   });
-  if (!covered && !record.record.exclusive_grants && await options.sellerAuthorization?.(claim))
+  const exclusive = record.record.exclusive_grants === true && (record.record.grants ?? []).some((g) => grantsScope(g, claim.scope));
+  if (!covered && !exclusive && await options.sellerAuthorization?.(claim))
     return result("seller", [brand, account, operator]);
   throw new IdentityAuthorizationError("grant_absent");
 }

package/dist/lib/identity-3.3/types.d.mts

@@ -1,4 +1,4 @@
-/** Experimental drafts; the released SDK wire/schema pin remains 3.2.5. */
+/** Experimental drafts; the released SDK wire/schema pin remains 3.2.7. */
 import type { GeneratedAccountCapabilities, ResolveAgentOnboarding } from './generated-compat.mjs';
 export type BillingParty = 'operator' | 'agent' | 'advertiser';
 type DraftAgentOnboardingRequirementKind = 'agent_identity' | 'grant' | 'billing_entity' | 'contract' | 'credit_application' | 'aao_verified' | 'storyboard' | 'sandbox' | 'experimental_feature';

package/dist/lib/identity-3.3/types.d.ts

@@ -1,4 +1,4 @@
-/** Experimental drafts; the released SDK wire/schema pin remains 3.2.5. */
+/** Experimental drafts; the released SDK wire/schema pin remains 3.2.7. */
 import type { GeneratedAccountCapabilities, ResolveAgentOnboarding } from './generated-compat';
 export type BillingParty = 'operator' | 'agent' | 'advertiser';
 type DraftAgentOnboardingRequirementKind = 'agent_identity' | 'grant' | 'billing_entity' | 'contract' | 'credit_application' | 'aao_verified' | 'storyboard' | 'sandbox' | 'experimental_feature';

package/dist/lib/negotiation/commercial-terms-semantics.d.mts

@@ -1,6 +1,6 @@
 /**
  * Reviewed non-JSON-Schema semantics from the 3.2 beta.8 / rc.2 / rc.3 / rc.4 / rc.6 / rc.7 / 3.2.1 / 3.2.3 /
- * 3.2.4 / 3.2.5 bundles.
+ * 3.2.4 / 3.2.5 / 3.2.6 / 3.2.7 bundles.
  * These are semantic contracts, NOT a binding-field allowlist: properties and
  * comparison always come from the selected runtime schema. Additions to these
  * annotations require a deliberate implementation/review instead of AJV silently

package/dist/lib/negotiation/commercial-terms-semantics.d.ts

@@ -1,6 +1,6 @@
 /**
  * Reviewed non-JSON-Schema semantics from the 3.2 beta.8 / rc.2 / rc.3 / rc.4 / rc.6 / rc.7 / 3.2.1 / 3.2.3 /
- * 3.2.4 / 3.2.5 bundles.
+ * 3.2.4 / 3.2.5 / 3.2.6 / 3.2.7 bundles.
  * These are semantic contracts, NOT a binding-field allowlist: properties and
  * comparison always come from the selected runtime schema. Additions to these
  * annotations require a deliberate implementation/review instead of AJV silently

package/dist/lib/negotiation/commercial-terms-semantics.js

@@ -202,6 +202,28 @@ const COMMERCIAL_SEMANTIC_OVERRIDES_BY_RELEASE = {
         }
       }
     }
+  },
+  "3.2.6": {
+    "media-buy/product-purchase.json": {
+      verifier_constraints: {
+        accepted_snapshot_terms: "Inside canonical-proposal.commercial_terms, each purchase MUST carry resolved start_time and end_time and MUST preserve every applicable measurement term and performance standard. Omission of measurement_terms or performance_standards means the accepted offer declared none.",
+        pricing_identity: {
+          pricing_option_id: "equals_pricing.pricing_option_id_when_pricing_present",
+          on_violation: "reject_before_commitment"
+        }
+      }
+    }
+  },
+  "3.2.7": {
+    "media-buy/product-purchase.json": {
+      verifier_constraints: {
+        accepted_snapshot_terms: "Inside canonical-proposal.commercial_terms, each purchase MUST carry resolved start_time and end_time and MUST preserve every applicable measurement term and performance standard. Omission of measurement_terms or performance_standards means the accepted offer declared none.",
+        pricing_identity: {
+          pricing_option_id: "equals_pricing.pricing_option_id_when_pricing_present",
+          on_violation: "reject_before_commitment"
+        }
+      }
+    }
   }
 };
 const REVIEWED_COMMERCIAL_ENUM_ANNOTATIONS = {

package/dist/lib/negotiation/commercial-terms-semantics.mjs

@@ -176,6 +176,28 @@ const COMMERCIAL_SEMANTIC_OVERRIDES_BY_RELEASE = {
         }
       }
     }
+  },
+  "3.2.6": {
+    "media-buy/product-purchase.json": {
+      verifier_constraints: {
+        accepted_snapshot_terms: "Inside canonical-proposal.commercial_terms, each purchase MUST carry resolved start_time and end_time and MUST preserve every applicable measurement term and performance standard. Omission of measurement_terms or performance_standards means the accepted offer declared none.",
+        pricing_identity: {
+          pricing_option_id: "equals_pricing.pricing_option_id_when_pricing_present",
+          on_violation: "reject_before_commitment"
+        }
+      }
+    }
+  },
+  "3.2.7": {
+    "media-buy/product-purchase.json": {
+      verifier_constraints: {
+        accepted_snapshot_terms: "Inside canonical-proposal.commercial_terms, each purchase MUST carry resolved start_time and end_time and MUST preserve every applicable measurement term and performance standard. Omission of measurement_terms or performance_standards means the accepted offer declared none.",
+        pricing_identity: {
+          pricing_option_id: "equals_pricing.pricing_option_id_when_pricing_present",
+          on_violation: "reject_before_commitment"
+        }
+      }
+    }
   }
 };
 const REVIEWED_COMMERCIAL_ENUM_ANNOTATIONS = {

package/dist/lib/protocols/a2a.d.mts

@@ -44,8 +44,8 @@ export declare function closeA2AConnections(): void;
  * into `pollTaskCompletion` (sibling promise trees), so we can't replay the
  * captured ALS context — instead we rebuild a one-shot signer fetch from
  * `agent.request_signing` directly and use it for this single POST. Inline
- * keys go through `createSigningFetch` (sync); provider-backed configs use
- * `createSigningFetchAsync`. A `signed-requests` seller that requires
+ * and provider-backed configs use the shared protocol-method signing policy
+ * with the active AdCP wire-version pin. A seller that requires
  * signing on `tasks/cancel` (or applies a uniform "all mutating POSTs must
  * be signed" policy) now accepts the cancel; one without signing config on
  * the agent gets the Phase 1 unsigned path.
@@ -57,7 +57,7 @@ export declare function closeA2AConnections(): void;
  * @param agent     The agent config (used for URL, auth token, signing).
  * @param taskId    The server-assigned A2A Task.id to cancel.
  */
-export declare function cancelA2ATask(agent: AgentConfig, taskId: string, fetchFn?: typeof fetch, allowPrivateIp?: boolean, legacyCompat?: A2ALegacyCompatOptions): Promise<void>;
+export declare function cancelA2ATask(agent: AgentConfig, taskId: string, fetchFn?: typeof fetch, allowPrivateIp?: boolean, legacyCompat?: A2ALegacyCompatOptions, adcpVersion?: string): Promise<void>;
 /**
  * Create an official A2A client from an agent-card URL.
  *

package/dist/lib/protocols/a2a.d.ts

@@ -44,8 +44,8 @@ export declare function closeA2AConnections(): void;
  * into `pollTaskCompletion` (sibling promise trees), so we can't replay the
  * captured ALS context — instead we rebuild a one-shot signer fetch from
  * `agent.request_signing` directly and use it for this single POST. Inline
- * keys go through `createSigningFetch` (sync); provider-backed configs use
- * `createSigningFetchAsync`. A `signed-requests` seller that requires
+ * and provider-backed configs use the shared protocol-method signing policy
+ * with the active AdCP wire-version pin. A seller that requires
  * signing on `tasks/cancel` (or applies a uniform "all mutating POSTs must
  * be signed" policy) now accepts the cancel; one without signing config on
  * the agent gets the Phase 1 unsigned path.
@@ -57,7 +57,7 @@ export declare function closeA2AConnections(): void;
  * @param agent     The agent config (used for URL, auth token, signing).
  * @param taskId    The server-assigned A2A Task.id to cancel.
  */
-export declare function cancelA2ATask(agent: AgentConfig, taskId: string, fetchFn?: typeof fetch, allowPrivateIp?: boolean, legacyCompat?: A2ALegacyCompatOptions): Promise<void>;
+export declare function cancelA2ATask(agent: AgentConfig, taskId: string, fetchFn?: typeof fetch, allowPrivateIp?: boolean, legacyCompat?: A2ALegacyCompatOptions, adcpVersion?: string): Promise<void>;
 /**
  * Create an official A2A client from an agent-card URL.
  *

package/dist/lib/protocols/a2a.js

@@ -34,9 +34,6 @@ var import_authorization_required = require('../auth/oauth/authorization-require
 var import_tracing = require('../observability/tracing.js');
 var import_a2a_discovery = require('../utils/a2a-discovery.js');
 var import_client2 = require('../signing/client.js');
-var import_agent_fetch = require('../signing/agent-fetch.js');
-var import_fetch = require('../signing/fetch.js');
-var import_fetch_async = require('../signing/fetch-async.js');
 var import_redact_args = require('../utils/redact-args.js');
 var import_rawResponseCapture = require('./rawResponseCapture.js');
 var import_signedRequestRejection = require('./signedRequestRejection.js');
@@ -117,7 +114,7 @@ function closeA2AConnections() {
   pendingA2AClients.clear();
 }
 const CANCEL_TIMEOUT_MS = 5e3;
-async function cancelA2ATask(agent, taskId, fetchFn, allowPrivateIp, legacyCompat) {
+async function cancelA2ATask(agent, taskId, fetchFn, allowPrivateIp, legacyCompat, adcpVersion) {
   if (agent.protocol !== "a2a") {
     return;
   }
@@ -125,10 +122,19 @@ async function cancelA2ATask(agent, taskId, fetchFn, allowPrivateIp, legacyCompa
   const transportFetch = (0, import_agent_transport_fetch.createAgentTransportFetch)(agentUrl, { trustedFetchFn: fetchFn, allowPrivateIp });
   const authToken = agent.auth_token;
   let requestFetch = (input, init) => transportFetch(input, init);
-  if (agent.request_signing && (0, import_agent_fetch.isInlineSigningConfig)(agent.request_signing)) {
-    requestFetch = (0, import_fetch.createSigningFetch)(requestFetch, (0, import_agent_fetch.toSignerKey)(agent.request_signing));
-  } else if (agent.request_signing && (0, import_agent_fetch.isProviderSigningConfig)(agent.request_signing)) {
-    requestFetch = (0, import_fetch_async.createSigningFetchAsync)(requestFetch, agent.request_signing.provider);
+  const signingContext = (0, import_client2.buildAgentSigningContext)(agent, { adcpVersion });
+  if (signingContext) {
+    requestFetch = (0, import_client2.buildAgentSigningFetch)({
+      upstream: requestFetch,
+      getCapability: signingContext.getCapability,
+      adcpVersion: signingContext.adcpVersion,
+      signing: {
+        ...signingContext.signing,
+        always_sign_protocol_methods: [
+          .../* @__PURE__ */ new Set([...signingContext.signing.always_sign_protocol_methods ?? [], "tasks/cancel", "CancelTask"])
+        ]
+      }
+    });
   }
   const timeoutSignal = AbortSignal.timeout(CANCEL_TIMEOUT_MS);
   const fetchImpl = (input, init = {}) => {

package/dist/lib/protocols/a2a.mjs

@@ -17,10 +17,11 @@ import { discoverOAuthMetadata } from "../auth/oauth/discovery.mjs";
 import { probeAuthChallenge } from "../auth/oauth/authorization-required.mjs";
 import { withSpan, injectTraceHeaders } from "../observability/tracing.mjs";
 import { isAgentCardPath, buildCardUrls } from "../utils/a2a-discovery.mjs";
-import { buildAgentSigningFetch, signingContextStorage } from "../signing/client.mjs";
-import { toSignerKey, isInlineSigningConfig, isProviderSigningConfig } from "../signing/agent-fetch.mjs";
-import { createSigningFetch } from "../signing/fetch.mjs";
-import { createSigningFetchAsync } from "../signing/fetch-async.mjs";
+import {
+  buildAgentSigningContext,
+  buildAgentSigningFetch,
+  signingContextStorage
+} from "../signing/client.mjs";
 import { redactArgsForLog } from "../utils/redact-args.mjs";
 import { wrapFetchWithCapture } from "./rawResponseCapture.mjs";
 import { getSignedRequestRejection, wrapFetchWithSignedRequestRejection } from "./signedRequestRejection.mjs";
@@ -101,7 +102,7 @@ function closeA2AConnections() {
   pendingA2AClients.clear();
 }
 const CANCEL_TIMEOUT_MS = 5e3;
-async function cancelA2ATask(agent, taskId, fetchFn, allowPrivateIp, legacyCompat) {
+async function cancelA2ATask(agent, taskId, fetchFn, allowPrivateIp, legacyCompat, adcpVersion) {
   if (agent.protocol !== "a2a") {
     return;
   }
@@ -109,10 +110,19 @@ async function cancelA2ATask(agent, taskId, fetchFn, allowPrivateIp, legacyCompa
   const transportFetch = createAgentTransportFetch(agentUrl, { trustedFetchFn: fetchFn, allowPrivateIp });
   const authToken = agent.auth_token;
   let requestFetch = (input, init) => transportFetch(input, init);
-  if (agent.request_signing && isInlineSigningConfig(agent.request_signing)) {
-    requestFetch = createSigningFetch(requestFetch, toSignerKey(agent.request_signing));
-  } else if (agent.request_signing && isProviderSigningConfig(agent.request_signing)) {
-    requestFetch = createSigningFetchAsync(requestFetch, agent.request_signing.provider);
+  const signingContext = buildAgentSigningContext(agent, { adcpVersion });
+  if (signingContext) {
+    requestFetch = buildAgentSigningFetch({
+      upstream: requestFetch,
+      getCapability: signingContext.getCapability,
+      adcpVersion: signingContext.adcpVersion,
+      signing: {
+        ...signingContext.signing,
+        always_sign_protocol_methods: [
+          .../* @__PURE__ */ new Set([...signingContext.signing.always_sign_protocol_methods ?? [], "tasks/cancel", "CancelTask"])
+        ]
+      }
+    });
   }
   const timeoutSignal = AbortSignal.timeout(CANCEL_TIMEOUT_MS);
   const fetchImpl = (input, init = {}) => {

package/dist/lib/protocols/index.d.mts

@@ -9,6 +9,7 @@ export declare function closeConnections(protocol?: 'mcp' | 'a2a'): Promise<void
 export declare function closeScopedConnections(protocol?: 'mcp' | 'a2a'): Promise<void>;
 export { withMCPConnectionScope };
 export type { MCPCallOptions, MCPConnectionResult } from './mcp.mjs';
+export type { MCPTaskConnectionOptions } from './mcp-tasks.mjs';
 export { callA2ATool, createA2AClientFromCardUrl } from './a2a.mjs';
 export { DEFAULT_REQUEST_TIMEOUT_MS } from './abort.mjs';
 export { DEFAULT_MAX_RESPONSE_BYTES, SSE_CUMULATIVE_BUDGET_MULTIPLIER } from './responseSizeLimit.mjs';
@@ -35,6 +36,16 @@ export declare function bundleSupportsAdcpVersionField(bundleKey: string): boole
  * reuses a fetch that was created on an earlier call with different limits.
  */
 export interface TransportOptions {
+    /** Caller-owned principal partition for MCP sessions. Never sent in headers or bodies.
+     * A nonempty partition opts into process-wide reuse for that partition outside a scope.
+     * Per-call transport replaces the constructor transport; repeat the partition when overriding it.
+     */
+    connectionPartition?: string;
+    /** Explicitly reuse unpartitioned MCP sessions across calls outside a connection scope.
+     * Only use when all callers with the same endpoint and credentials represent one principal.
+     * Without this opt-in or a partition, unscoped calls close their session after the operation.
+     */
+    connectionReuse?: 'process';
     /**
      * Maximum response body size (in octets) the SDK will read before aborting
      * with `ResponseTooLargeError`.
@@ -260,6 +271,7 @@ export declare class ProtocolClient {
      * @param options - Optional call-level configuration. See {@link CallToolOptions}.
      */
     static callTool(agent: AgentConfig, toolName: string, args: Record<string, unknown>, options?: CallToolOptions): Promise<unknown>;
+    private static callToolWithConnectionPolicy;
 }
 /**
  * Simple factory functions for protocol-specific clients.