@adcp/sdk 12.1.1 → 13.0.0-rc.0

package/dist/lib/server/create-adcp-server.js

@@ -1078,6 +1078,127 @@ function buildSupportedVersionsList(capConfig, serverPin) {
   const pinMajor = (0, import_version.parseAdcpMajorVersion)(serverPin);
   return Number.isFinite(pinMajor) ? [String(pinMajor)] : [];
 }
+function isMcpToolResponse(value) {
+  return Array.isArray(value.content);
+}
+function parseAdcpRelease(value) {
+  if (typeof value !== "string") return void 0;
+  let wire;
+  try {
+    wire = (0, import_version.toReleasePrecisionVersion)(value);
+  } catch {
+    return void 0;
+  }
+  const match = /^v?(\d+)\.(\d+)(?:-([a-zA-Z0-9.-]+))?$/.exec(wire);
+  if (!match) return void 0;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    ...match[3] !== void 0 && { prerelease: match[3] },
+    value: wire
+  };
+}
+function compareAdcpRelease(left, right) {
+  if (left.major !== right.major) return left.major - right.major;
+  if (left.minor !== right.minor) return left.minor - right.minor;
+  if (left.prerelease === right.prerelease) return 0;
+  if (left.prerelease === void 0) return 1;
+  if (right.prerelease === void 0) return -1;
+  const leftParts = left.prerelease.split(".");
+  const rightParts = right.prerelease.split(".");
+  for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
+    const leftPart = leftParts[index];
+    const rightPart = rightParts[index];
+    if (leftPart === void 0) return -1;
+    if (rightPart === void 0) return 1;
+    if (leftPart === rightPart) continue;
+    const leftNumeric = /^\d+$/.test(leftPart);
+    const rightNumeric = /^\d+$/.test(rightPart);
+    if (leftNumeric && rightNumeric) return Number(leftPart) - Number(rightPart);
+    if (leftNumeric !== rightNumeric) return leftNumeric ? -1 : 1;
+    return leftPart.localeCompare(rightPart);
+  }
+  return 0;
+}
+let bundledCompatibleReleases;
+function bundledReleasesForMajors(majors, configured) {
+  const acceptedMajors = new Set(majors);
+  const releases = /* @__PURE__ */ new Map();
+  bundledCompatibleReleases ??= import_version.COMPATIBLE_ADCP_VERSIONS.flatMap((version) => {
+    if (!(0, import_schema_loader.hasSchemaBundle)(version)) return [];
+    const parsed = parseAdcpRelease(version);
+    return parsed ? [parsed] : [];
+  });
+  for (const parsed of bundledCompatibleReleases) {
+    if (!acceptedMajors.has(parsed.major) || compareAdcpRelease(parsed, configured) > 0) continue;
+    const key = `${parsed.major}.${parsed.minor}${parsed.prerelease ? `-${parsed.prerelease}` : ""}`;
+    const existing = releases.get(key);
+    if (!existing || parsed.value.startsWith("v")) releases.set(key, parsed);
+  }
+  return [...releases.values()];
+}
+function selectServedAdcpRelease(params, capConfig, serverPin) {
+  const configured = parseAdcpRelease(serverPin);
+  if (!configured) {
+    return (0, import_errors.adcpError)("VERSION_UNSUPPORTED", {
+      message: `Configured AdCP release ${JSON.stringify(serverPin)} is invalid.`,
+      details: { supported_versions: buildSupportedVersionsList(capConfig, serverPin) }
+    });
+  }
+  const advertisedValues = capConfig?.supported_versions?.length ? capConfig.supported_versions : void 0;
+  const advertised = advertisedValues ? advertisedValues.map(parseAdcpRelease) : capConfig?.major_versions?.length ? bundledReleasesForMajors(capConfig.major_versions, configured) : [configured];
+  if (advertised.some((value) => value === void 0)) {
+    return (0, import_errors.adcpError)("VERSION_UNSUPPORTED", {
+      message: "Seller capabilities contain an invalid supported_versions release.",
+      details: { supported_versions: buildSupportedVersionsList(capConfig, serverPin) }
+    });
+  }
+  const supported = advertised.filter(
+    (candidate) => compareAdcpRelease(candidate, configured) <= 0
+  );
+  if (supported.length === 0) {
+    return (0, import_errors.adcpError)("VERSION_UNSUPPORTED", {
+      message: "Seller capabilities do not include a release this server can serve.",
+      details: { supported_versions: buildSupportedVersionsList(capConfig, serverPin) }
+    });
+  }
+  const requestedVersion = params.adcp_version;
+  const requestedMajorRaw = params.adcp_major_version;
+  const requestedMajor = typeof requestedMajorRaw === "number" ? requestedMajorRaw : typeof requestedMajorRaw === "string" ? Number.parseInt(requestedMajorRaw, 10) : void 0;
+  let selected;
+  if (requestedVersion !== void 0) {
+    const requested = parseAdcpRelease(requestedVersion);
+    if (!requested) {
+      return (0, import_errors.adcpError)("VERSION_UNSUPPORTED", {
+        message: `Request carries invalid adcp_version=${JSON.stringify(requestedVersion)}.`,
+        details: { supported_versions: buildSupportedVersionsList(capConfig, serverPin) }
+      });
+    }
+    if (requestedMajor !== void 0 && Number.isFinite(requestedMajor) && requestedMajor !== requested.major) {
+      return (0, import_errors.adcpError)("VERSION_UNSUPPORTED", {
+        message: `Request carries adcp_version=${JSON.stringify(requestedVersion)} (major ${requested.major}) and adcp_major_version=${JSON.stringify(requestedMajorRaw)}; majors must agree.`,
+        details: { supported_versions: buildSupportedVersionsList(capConfig, serverPin) }
+      });
+    }
+    selected = supported.filter((candidate) => candidate.major === requested.major && compareAdcpRelease(candidate, requested) <= 0).sort((left, right) => compareAdcpRelease(right, left))[0];
+  } else if (requestedMajor !== void 0 && Number.isFinite(requestedMajor)) {
+    selected = supported.filter((candidate) => candidate.major === requestedMajor).sort(compareAdcpRelease)[0];
+  } else {
+    selected = [...supported].sort((left, right) => compareAdcpRelease(right, left))[0];
+  }
+  if (!selected) {
+    const claim = requestedVersion !== void 0 ? `adcp_version=${JSON.stringify(requestedVersion)}` : requestedMajorRaw !== void 0 ? `adcp_major_version=${JSON.stringify(requestedMajorRaw)} (major ${String(requestedMajor)})` : "no AdCP version";
+    return (0, import_errors.adcpError)("VERSION_UNSUPPORTED", {
+      message: `Request claims ${claim}; no mutually supported AdCP release is available.`,
+      details: { supported_versions: buildSupportedVersionsList(capConfig, serverPin) }
+    });
+  }
+  const validationVersion = selected.value;
+  return {
+    validationVersion,
+    ...(0, import_protocols.bundleSupportsAdcpVersionField)((0, import_schema_loader.resolveBundleKey)(validationVersion)) && { wireVersion: validationVersion }
+  };
+}
 function createAdcpServer(config) {
   const {
     name,
@@ -1303,43 +1424,42 @@ function createAdcpServer(config) {
     responseEnhancer?.(response);
     return response;
   };
+  const requestServedRelease = (params) => {
+    const selected = selectServedAdcpRelease(params, capConfig, adcpVersion);
+    return isMcpToolResponse(selected) ? void 0 : selected;
+  };
+  const releaseDefinesTool = (toolName, release) => {
+    try {
+      return (0, import_schema_loader.getValidator)(toolName, "request", release.validationVersion) !== void 0;
+    } catch {
+      return false;
+    }
+  };
   const finalizeProtocolTaskToolResponse = (toolName, params, response, opts = {}) => {
+    const release = requestServedRelease(params) ?? {
+      validationVersion: adcpVersion,
+      ...servedAdcpVersion !== void 0 && { wireVersion: servedAdcpVersion }
+    };
     sanitizeAdcpErrorEnvelope(response);
-    enrichErrorTwoLayer(response, toolName, toolsWithErrorArm);
+    enrichErrorTwoLayer(response, toolName, (0, import_error_arm_tools.getToolsWithErrorArm)(release.validationVersion));
     if (!isErrorResponse(response)) {
       normalizeMediaBuyStatusCollision(response, toolName);
       injectEnvelopeStatusIntoResponse(response);
-      const validationError = protocolTaskResponseValidationError(toolName, response);
+      const validationError = protocolTaskResponseValidationError(toolName, response, params);
       if (validationError) return finalizeProtocolTaskToolResponse(toolName, params, validationError, opts);
     }
     if (opts.echoContext !== false) injectContextIntoResponse(response, params.context);
-    injectVersionIntoResponse(response, servedAdcpVersion);
+    injectVersionIntoResponse(response, release.wireVersion);
     return applyResponseEnhancer(response);
   };
-  const unsupportedVersionResponse = (params) => {
-    const reqAdcpVersion = params.adcp_version;
-    const reqAdcpMajorRaw = params.adcp_major_version;
-    const reqAdcpMajor = typeof reqAdcpMajorRaw === "number" ? reqAdcpMajorRaw : typeof reqAdcpMajorRaw === "string" ? Number.parseInt(reqAdcpMajorRaw, 10) : void 0;
-    if (typeof reqAdcpVersion === "string" && reqAdcpMajor !== void 0 && Number.isFinite(reqAdcpMajor)) {
-      const stringMajor = (0, import_version.parseAdcpMajorVersion)(reqAdcpVersion);
-      if (Number.isFinite(stringMajor) && stringMajor !== reqAdcpMajor) {
-        return (0, import_errors.adcpError)("VERSION_UNSUPPORTED", {
-          message: `Request carries adcp_version="${reqAdcpVersion}" (major ${stringMajor}) and adcp_major_version=${JSON.stringify(reqAdcpMajorRaw)}; majors must agree.`,
-          details: { supported_versions: buildSupportedVersionsList(capConfig, adcpVersion) }
-        });
-      }
-    }
-    const effectiveReqMajor = reqAdcpMajor !== void 0 && Number.isFinite(reqAdcpMajor) ? reqAdcpMajor : typeof reqAdcpVersion === "string" ? (0, import_version.parseAdcpMajorVersion)(reqAdcpVersion) : void 0;
-    if (effectiveReqMajor !== void 0 && Number.isFinite(effectiveReqMajor)) {
-      const supportedMajors = getAdvertisedSupportedMajors(capConfig, adcpVersion);
-      if (!supportedMajors.has(effectiveReqMajor)) {
-        const claimed = typeof reqAdcpVersion === "string" ? `adcp_version="${reqAdcpVersion}"` : `adcp_major_version=${JSON.stringify(reqAdcpMajorRaw)}`;
-        const supportedList = [...supportedMajors].sort((a, b) => a - b).join(", ");
-        return (0, import_errors.adcpError)("VERSION_UNSUPPORTED", {
-          message: `Request claims ${claimed} (major ${effectiveReqMajor}); this seller supports major ${supportedList}.`,
-          details: { supported_versions: buildSupportedVersionsList(capConfig, adcpVersion) }
-        });
-      }
+  const unsupportedVersionResponse = (toolName, params) => {
+    const selected = selectServedAdcpRelease(params, capConfig, adcpVersion);
+    if (isMcpToolResponse(selected)) return selected;
+    if (!releaseDefinesTool(toolName, selected)) {
+      return (0, import_errors.adcpError)("VERSION_UNSUPPORTED", {
+        message: `${toolName} is not defined in the selected AdCP release ${selected.validationVersion}.`,
+        details: { supported_versions: buildSupportedVersionsList(capConfig, adcpVersion) }
+      });
     }
     return void 0;
   };
@@ -1358,7 +1478,7 @@ function createAdcpServer(config) {
   };
   const protocolTaskRequestValidationError = (toolName, params) => {
     const accountIssues = protocolTaskAccountExtensionIssues(params);
-    const outcome = requestValidationMode === "off" ? { valid: true, issues: [], schemaId: void 0 } : (0, import_schema_validator.validateRequest)(toolName, params, adcpVersion);
+    const outcome = requestValidationMode === "off" ? { valid: true, issues: [], schemaId: void 0 } : (0, import_schema_validator.validateRequest)(toolName, params, requestServedRelease(params)?.validationVersion ?? adcpVersion);
     const issues = [...outcome.valid ? [] : outcome.issues, ...accountIssues];
     if (issues.length === 0) return void 0;
     if (requestValidationMode === "strict" || accountIssues.length > 0) {
@@ -1379,9 +1499,13 @@ function createAdcpServer(config) {
     );
     return void 0;
   };
-  const protocolTaskResponseValidationError = (toolName, response) => {
+  const protocolTaskResponseValidationError = (toolName, response, params = {}) => {
     if (responseValidationMode === "off") return void 0;
-    const outcome = (0, import_schema_validator.validateResponse)(toolName, response.structuredContent, adcpVersion);
+    const outcome = (0, import_schema_validator.validateResponse)(
+      toolName,
+      response.structuredContent,
+      requestServedRelease(params)?.validationVersion ?? adcpVersion
+    );
     if (outcome.valid) return void 0;
     logger.warn(
       `Schema validation warning (response) for ${toolName}: ${(0, import_schema_validator.formatIssues)(outcome.issues, 3, { rootSchemaId: outcome.schemaId })}`,
@@ -1631,7 +1755,23 @@ function createAdcpServer(config) {
       const hasAccount = "account" in schema.shape;
       const wrap = meta?.wrap ?? ((data, summary) => genericResponse(toolName, data, summary));
       const toolHandler = async (params, extra) => {
-        const ctx = { store: stateStore };
+        const releaseSelection = selectServedAdcpRelease(params, capConfig, adcpVersion);
+        let releaseError;
+        let requestRelease;
+        if (isMcpToolResponse(releaseSelection)) {
+          releaseError = releaseSelection;
+          requestRelease = {
+            validationVersion: adcpVersion,
+            ...servedAdcpVersion !== void 0 && { wireVersion: servedAdcpVersion }
+          };
+        } else {
+          requestRelease = releaseSelection;
+        }
+        const requestErrorArms = (0, import_error_arm_tools.getToolsWithErrorArm)(requestRelease.validationVersion);
+        const ctx = {
+          store: stateStore,
+          servedAdcpVersion: requestRelease.validationVersion
+        };
         if (extra?.authInfo) {
           ctx.authInfo = extra.authInfo;
           const authInfo = ctx.authInfo;
@@ -1645,13 +1785,22 @@ function createAdcpServer(config) {
         if (webhookEmitter) ctx.emitWebhook = webhookEmitter.emit.bind(webhookEmitter);
         const finalize = (response) => {
           sanitizeAdcpErrorEnvelope(response);
-          enrichErrorTwoLayer(response, toolName, toolsWithErrorArm);
+          enrichErrorTwoLayer(response, toolName, requestErrorArms);
           normalizeMediaBuyStatusCollision(response, toolName);
           injectEnvelopeStatusIntoResponse(response);
           injectContextIntoResponse(response, params.context);
-          injectVersionIntoResponse(response, servedAdcpVersion);
+          injectVersionIntoResponse(response, requestRelease.wireVersion);
           return applyResponseEnhancer(response);
         };
+        if (releaseError) return finalize(releaseError);
+        if (!releaseDefinesTool(toolName, requestRelease)) {
+          return finalize(
+            (0, import_errors.adcpError)("VERSION_UNSUPPORTED", {
+              message: `${toolName} is not defined in the selected AdCP release ${requestRelease.validationVersion}.`,
+              details: { supported_versions: buildSupportedVersionsList(capConfig, adcpVersion) }
+            })
+          );
+        }
         if (agentRegistry !== void 0) {
           try {
             const resolved = await agentRegistry.resolve({
@@ -1755,7 +1904,7 @@ function createAdcpServer(config) {
           }
         }
         if (requestValidationMode !== "off") {
-          const outcome = (0, import_schema_validator.validateRequest)(toolName, params, adcpVersion);
+          const outcome = (0, import_schema_validator.validateRequest)(toolName, params, requestRelease.validationVersion);
           if (!outcome.valid) {
             const issues = idempotencyDisabled && toolIsMutating ? outcome.issues.filter((i) => !(i.keyword === "required" && i.pointer === "/idempotency_key")) : outcome.issues;
             if (issues.length > 0) {
@@ -2370,7 +2519,7 @@ function createAdcpServer(config) {
           }
           if (responseValidationMode !== "off" && !isErrorResponse(formatted)) {
             const payload = formatted.structuredContent;
-            const outcome = (0, import_schema_validator.validateResponse)(toolName, payload, adcpVersion);
+            const outcome = (0, import_schema_validator.validateResponse)(toolName, payload, requestRelease.validationVersion);
             if (!outcome.valid) {
               logger.warn(
                 `Schema validation warning (response) for ${toolName}: ${(0, import_schema_validator.formatIssues)(outcome.issues, 3, { rootSchemaId: outcome.schemaId })}`,
@@ -2538,7 +2687,7 @@ function createAdcpServer(config) {
         if (validationError) return finalizeProtocolTaskToolResponse("get_task_status", params ?? {}, validationError);
         const boundsError = protocolTaskBoundsError("get_task_status", params ?? {});
         if (boundsError) return finalizeProtocolTaskToolResponse("get_task_status", params ?? {}, boundsError);
-        const versionError = unsupportedVersionResponse(params ?? {});
+        const versionError = unsupportedVersionResponse("get_task_status", params ?? {});
         if (versionError) return finalizeProtocolTaskToolResponse("get_task_status", params ?? {}, versionError);
         const taskId = typeof params?.task_id === "string" ? params.task_id : "";
         const { accountId, ownerScope, error } = await resolveTaskQueryAccountId(
@@ -2612,7 +2761,7 @@ function createAdcpServer(config) {
         if (validationError) return finalizeProtocolTaskToolResponse("list_tasks", params ?? {}, validationError);
         const boundsError = protocolTaskBoundsError("list_tasks", params ?? {});
         if (boundsError) return finalizeProtocolTaskToolResponse("list_tasks", params ?? {}, boundsError);
-        const versionError = unsupportedVersionResponse(params ?? {});
+        const versionError = unsupportedVersionResponse("list_tasks", params ?? {});
         if (versionError) return finalizeProtocolTaskToolResponse("list_tasks", params ?? {}, versionError);
         const { accountId, ownerScope, error } = await resolveTaskQueryAccountId(params ?? {}, extra, "list_tasks");
         if (error) return finalizeProtocolTaskToolResponse("list_tasks", params ?? {}, error);
@@ -2758,6 +2907,9 @@ function createAdcpServer(config) {
   if (protocols.includes("media_buy") || capConfig?.features) {
     capabilitiesData.media_buy = {
       features: {
+        ...capConfig?.features?.canonicalCreatives !== void 0 && {
+          canonical_creatives: capConfig.features.canonicalCreatives
+        },
         inline_creative_management: capConfig?.features?.inlineCreativeManagement ?? false,
         property_list_filtering: capConfig?.features?.propertyListFiltering ?? false,
         content_standards: capConfig?.features?.contentStandards ?? false,
@@ -2813,6 +2965,52 @@ function createAdcpServer(config) {
       annotations: { readOnlyHint: true }
     },
     (async (params, extra = {}) => {
+      const requestParams = isPlainObject(params) ? params : {};
+      const releaseSelection = selectServedAdcpRelease(requestParams, capConfig, adcpVersion);
+      const release = isMcpToolResponse(releaseSelection) ? {
+        validationVersion: adcpVersion,
+        ...servedAdcpVersion !== void 0 && { wireVersion: servedAdcpVersion }
+      } : releaseSelection;
+      const finalizeCapabilityResponse = (response2) => {
+        sanitizeAdcpErrorEnvelope(response2);
+        injectContextIntoResponse(response2, requestParams.context);
+        injectVersionIntoResponse(response2, release.wireVersion);
+        return applyResponseEnhancer(response2);
+      };
+      if (isMcpToolResponse(releaseSelection)) {
+        return finalizeCapabilityResponse(releaseSelection);
+      }
+      if (!releaseDefinesTool("get_adcp_capabilities", release)) {
+        return finalizeCapabilityResponse(
+          (0, import_errors.adcpError)("VERSION_UNSUPPORTED", {
+            message: `get_adcp_capabilities is not defined in the selected AdCP release ${release.validationVersion}.`,
+            details: { supported_versions: buildSupportedVersionsList(capConfig, adcpVersion) }
+          })
+        );
+      }
+      if (requestValidationMode !== "off") {
+        const requestOutcome = (0, import_schema_validator.validateRequest)("get_adcp_capabilities", requestParams, release.validationVersion);
+        if (!requestOutcome.valid) {
+          logger.warn(
+            `Schema validation warning (request) for get_adcp_capabilities: ${(0, import_schema_validator.formatIssues)(requestOutcome.issues, 3, { rootSchemaId: requestOutcome.schemaId })}`,
+            {
+              tool: "get_adcp_capabilities",
+              issues: requestOutcome.issues
+            }
+          );
+          if (requestValidationMode === "strict") {
+            return finalizeCapabilityResponse(
+              (0, import_errors.adcpError)(
+                "VALIDATION_ERROR",
+                (0, import_schema_errors.buildAdcpValidationErrorPayload)("get_adcp_capabilities", "request", requestOutcome.issues, {
+                  exposeSchemaPath: exposeErrorDetails,
+                  rootSchemaId: requestOutcome.schemaId
+                })
+              )
+            );
+          }
+        }
+      }
       if (agentRegistry !== void 0 && extra.authInfo !== void 0) {
         const authInfo = extra.authInfo;
         const inboundCredential = authInfo.extra?.credential;
@@ -2824,28 +3022,77 @@ function createAdcpServer(config) {
             input: params
           });
           if (resolved?.status === "suspended" || resolved?.status === "blocked") {
-            return (0, import_errors.adcpError)(resolved.status === "suspended" ? "AGENT_SUSPENDED" : "AGENT_BLOCKED", {
-              message: resolved.status === "suspended" ? "Buyer agent is suspended. Contact the seller to restore access." : "Buyer agent is blocked.",
-              recovery: "terminal"
-            });
+            return finalizeCapabilityResponse(
+              (0, import_errors.adcpError)(resolved.status === "suspended" ? "AGENT_SUSPENDED" : "AGENT_BLOCKED", {
+                message: resolved.status === "suspended" ? "Buyer agent is suspended. Contact the seller to restore access." : "Buyer agent is blocked.",
+                recovery: "terminal"
+              })
+            );
           }
         } catch (err) {
           logger.warn("Buyer-agent registry resolution failed for get_adcp_capabilities", {
             error: err instanceof Error ? (0, import_redact.redactCredentialPatterns)(err.message) : (0, import_redact.redactCredentialPatterns)(String(err))
           });
-          return (0, import_errors.adcpError)("SERVICE_UNAVAILABLE", {
-            message: "Buyer-agent registry is unavailable",
-            recovery: "transient"
-          });
+          return finalizeCapabilityResponse(
+            (0, import_errors.adcpError)("SERVICE_UNAVAILABLE", {
+              message: "Buyer-agent registry is unavailable",
+              recovery: "transient"
+            })
+          );
         }
       }
-      const data = { ...capabilitiesData };
-      const ctx = params?.context;
+      const data = {
+        ...capabilitiesData,
+        adcp: { ...capabilitiesData.adcp },
+        ...capabilitiesData.media_buy !== void 0 && {
+          media_buy: {
+            ...capabilitiesData.media_buy,
+            features: { ...capabilitiesData.media_buy.features }
+          }
+        }
+      };
+      const selected = parseAdcpRelease(release.validationVersion);
+      if (selected !== void 0 && (selected.major < 3 || selected.major === 3 && selected.minor < 1)) {
+        delete data.adcp.supported_versions;
+        if (data.media_buy?.features !== void 0) {
+          delete data.media_buy.features.canonical_creatives;
+        }
+        delete data.library_version;
+      }
+      const ctx = requestParams.context;
       if (ctx !== null && typeof ctx === "object" && !Array.isArray(ctx)) {
         data.context = ctx;
       }
       const response = (0, import_responses.capabilitiesResponse)(data);
-      injectVersionIntoResponse(response, servedAdcpVersion);
+      injectVersionIntoResponse(response, release.wireVersion);
+      if (responseValidationMode !== "off" && data.supported_protocols.length > 0) {
+        const responseOutcome = (0, import_schema_validator.validateResponse)(
+          "get_adcp_capabilities",
+          response.structuredContent,
+          release.validationVersion
+        );
+        if (!responseOutcome.valid) {
+          logger.warn(
+            `Schema validation warning (response) for get_adcp_capabilities: ${(0, import_schema_validator.formatIssues)(responseOutcome.issues, 3, { rootSchemaId: responseOutcome.schemaId })}`,
+            {
+              tool: "get_adcp_capabilities",
+              issues: responseOutcome.issues,
+              variant: responseOutcome.variant
+            }
+          );
+          if (responseValidationMode === "strict") {
+            return finalizeCapabilityResponse(
+              (0, import_errors.adcpError)(
+                "VALIDATION_ERROR",
+                (0, import_schema_errors.buildAdcpValidationErrorPayload)("get_adcp_capabilities", "response", responseOutcome.issues, {
+                  exposeSchemaPath: exposeErrorDetails,
+                  rootSchemaId: responseOutcome.schemaId
+                })
+              )
+            );
+          }
+        }
+      }
       return applyResponseEnhancer(response);
     })
   );