@astrasyncai/verification-gateway 5.11.0 → 5.12.0

package/dist/index.js

@@ -51,6 +51,7 @@ __export(src_exports, {
   RegistrationTimeoutError: () => RegistrationTimeoutError,
   SDK_USER_AGENT: () => SDK_USER_AGENT,
   TRUST_LEVEL_RANGES: () => TRUST_LEVEL_RANGES,
+  VERIFICATION_STATUS_HEADER: () => VERIFICATION_STATUS_HEADER,
   VERSION: () => SDK_VERSION,
   _resetEdgeConfigCache: () => _resetEdgeConfigCache,
   agent: () => agent_exports,
@@ -58,9 +59,11 @@ __export(src_exports, {
   awaitStepUpApproval: () => awaitStepUpApproval,
   buildGuidance: () => buildGuidance,
   buildSdkObservedMetadata: () => buildSdkObservedMetadata,
+  buildVerificationUnavailableBody: () => buildVerificationUnavailableBody,
   clearCache: () => clearCache,
   createMcpMiddleware: () => createMcpMiddleware,
   degradeToObserve: () => degradeToObserve,
+  denyStatusFor: () => denyStatusFor,
   deriveConnectionFromHeaders: () => deriveConnectionFromHeaders,
   detectPlatformFingerprint: () => detectPlatformFingerprint,
   detectRuntime: () => detectRuntime,
@@ -77,6 +80,8 @@ __export(src_exports, {
   getWellKnownUrls: () => getWellKnownUrls,
   hasCredentials: () => hasCredentials,
   isEdgeConfig: () => isEdgeConfig,
+  isRejectedIdentityClaim: () => isRejectedIdentityClaim,
+  isVerificationUnavailable: () => isVerificationUnavailable,
   isVerifiedHopValidFor: () => isVerifiedHopValidFor,
   matchEdgePathRule: () => matchEdgePathRule,
   matchPlatformSignature: () => matchPlatformSignature,
@@ -96,6 +101,7 @@ __export(src_exports, {
   serializeVerifiedHop: () => serializeVerifiedHop,
   setMcpMeta: () => setMcpMeta,
   transport: () => transport_exports,
+  unavailableRetryAfterSeconds: () => unavailableRetryAfterSeconds,
   validateLocalPolicy: () => validatePolicy,
   verify: () => verify
 });
@@ -116,7 +122,7 @@ function getTrustLevel(score) {
 }
 
 // src/version.ts
-var SDK_VERSION = "5.11.0";
+var SDK_VERSION = "5.12.0";
 
 // src/http.ts
 var SDK_USER_AGENT = `astrasync-sdk/${SDK_VERSION}`;
@@ -195,6 +201,59 @@ function getCachedWellKnownUrls(apiBaseUrl) {
   return cache.get(apiBaseUrl)?.data;
 }
 
+// src/failure-posture.ts
+var VERIFICATION_STATUS_HEADER = "X-Astra-Verification";
+var DEFAULT_UNAVAILABLE_RETRY_AFTER_S = 30;
+var REJECTED_IDENTITY_DIMENSIONS = /* @__PURE__ */ new Set([
+  "identity.invalid_agent_id",
+  "identity.unknown_agent",
+  "agent.lookup"
+]);
+var UNKNOWN_AGENT_GUIDANCE = "Register your agent with AstraSync (or, inside an MCP host, add the AstraSync MCP connector for keyless, human-approved registration), then present the canonical ASTRA-* id issued after owner approval.";
+var UNAVAILABLE_DIMENSIONS = /* @__PURE__ */ new Set([
+  "verify_access.api_error",
+  "middleware.internal_error"
+]);
+function isVerificationUnavailable(result) {
+  if (result.misconfigured) return false;
+  return (result.failures ?? []).some((f) => UNAVAILABLE_DIMENSIONS.has(f.dimension));
+}
+function unavailableRetryAfterSeconds(result) {
+  if (typeof result.retryAfterMs === "number" && Number.isFinite(result.retryAfterMs)) {
+    return Math.max(1, Math.ceil(result.retryAfterMs / 1e3));
+  }
+  return DEFAULT_UNAVAILABLE_RETRY_AFTER_S;
+}
+function isAnonymousRead(method, credentials) {
+  const m = (method ?? "").toUpperCase();
+  if (m !== "GET" && m !== "HEAD") return false;
+  return !credentials.astraId && !credentials.jwt;
+}
+function buildVerificationUnavailableBody(result) {
+  return {
+    success: false,
+    error: {
+      code: "VERIFICATION_UNAVAILABLE",
+      message: "Agent verification is temporarily unavailable and this path enforces verification. Your identity was not evaluated and no denial was recorded \u2014 retry after the Retry-After interval.",
+      retryable: true,
+      retryAfterSeconds: unavailableRetryAfterSeconds(result),
+      ...result.failures && { failures: result.failures },
+      ...result.correlationId && { correlationId: result.correlationId },
+      guidance: {
+        message: "Retry the request after the Retry-After interval, with exponential backoff; the condition is transient."
+      }
+    }
+  };
+}
+function isRejectedIdentityClaim(result) {
+  return (result.failures ?? []).some((f) => REJECTED_IDENTITY_DIMENSIONS.has(f.dimension));
+}
+function denyStatusFor(result, policyDeniedCode) {
+  if (isRejectedIdentityClaim(result)) return { status: 403, code: "AGENT_IDENTITY_REJECTED" };
+  if (result.identityVerified) return { status: 403, code: policyDeniedCode };
+  return { status: 401, code: "UNAUTHORIZED" };
+}
+
 // src/verify.ts
 var DEFAULT_CONFIG = {
   apiBaseUrl: "https://astrasync.ai/api",
@@ -446,11 +505,44 @@ function createGuidanceResponse(_config, reason, options = {}) {
     // coercing the absent recommendation to a policy 'deny'. Misconfig is
     // deterministic and intentionally NOT marked retryable.
     ...isApiError && { retryable: true },
+    ...options.httpStatus !== void 0 && { httpStatus: options.httpStatus },
+    ...options.retryAfterMs !== void 0 && { retryAfterMs: options.retryAfterMs },
     correlationId: options.correlationId,
     attemptId: options.attemptId,
     verifiedAt: /* @__PURE__ */ new Date()
   };
 }
+async function readJsonSafe(response) {
+  try {
+    const parsed = await response.json();
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function rejectedIdentityGuidance(failures) {
+  const f = failures?.find((x) => REJECTED_IDENTITY_DIMENSIONS.has(x.dimension));
+  if (!f) return void 0;
+  if (f.dimension === "agent.lookup") {
+    return `The presented agent identifier is not registered with AstraSync. ${UNKNOWN_AGENT_GUIDANCE}`;
+  }
+  return f.guidance ? `${f.message} ${f.guidance}` : f.message;
+}
+var MAX_RETRY_AFTER_MS = 15 * 60 * 1e3;
+function parseRetryAfterMs(response) {
+  const raw = response.headers?.get?.("retry-after");
+  if (!raw) return void 0;
+  const trimmed = raw.trim();
+  let ms;
+  if (/^\d+(\.\d+)?$/.test(trimmed)) {
+    ms = Number(trimmed) * 1e3;
+  } else {
+    const at = Date.parse(trimmed);
+    if (Number.isNaN(at)) return void 0;
+    ms = at - Date.now();
+  }
+  return Math.min(MAX_RETRY_AFTER_MS, Math.max(0, Math.round(ms)));
+}
 async function callVerifyAccessAPI(config, request) {
   const { credentials, ...requestData } = request;
   const body = {
@@ -507,7 +599,8 @@ async function callVerifyAccessAPI(config, request) {
       body: JSON.stringify(body),
       signal: AbortSignal.timeout(config.verifyTimeoutMs ?? 1e4)
     });
-    const data = await response.json();
+    const data = await readJsonSafe(response);
+    const retryAfterMs = parseRetryAfterMs(response);
     if (response.status === 410) {
       return {
         success: true,
@@ -545,6 +638,23 @@ async function callVerifyAccessAPI(config, request) {
         }
       };
     }
+    if (response.status === 404 && credentials.astraId && (data?.error === "AGENT_NOT_FOUND" || typeof data?.message === "string" && /agent/i.test(data.message))) {
+      return {
+        success: true,
+        attemptId: typeof data?.attemptId === "string" ? data.attemptId : void 0,
+        access: {
+          allowed: false,
+          reason: "unknown_agent",
+          failures: [
+            {
+              dimension: "identity.unknown_agent",
+              message: "The presented agent identifier is not registered with AstraSync.",
+              guidance: UNKNOWN_AGENT_GUIDANCE
+            }
+          ]
+        }
+      };
+    }
     if (!response.ok) {
       if (response.status === 401) {
         return {
@@ -559,9 +669,11 @@ async function callVerifyAccessAPI(config, request) {
       }
       return {
         success: false,
-        error: data.message || data.error || `API returned ${response.status}`,
+        error: typeof data?.message === "string" && data.message || typeof data?.error === "string" && data.error || `API returned ${response.status}`,
         correlationId: typeof data?.correlationId === "string" ? data.correlationId : void 0,
-        attemptId: typeof data?.attemptId === "string" ? data.attemptId : void 0
+        attemptId: typeof data?.attemptId === "string" ? data.attemptId : void 0,
+        httpStatus: response.status,
+        ...retryAfterMs !== void 0 && { retryAfterMs }
       };
     }
     return data;
@@ -633,12 +745,14 @@ async function verify(config, request, options) {
       correlationId: apiResponse.correlationId,
       attemptId: apiResponse.attemptId,
       remediation: apiResponse.remediation,
+      httpStatus: apiResponse.httpStatus,
+      retryAfterMs: apiResponse.retryAfterMs,
       urls
     });
   }
   if (!apiResponse.access?.allowed) {
     const aggregatedFailures = apiResponse.access?.failures;
-    const idVerifiedFromBackend = apiResponse.verificationContext?.idVerified === true;
+    const idVerifiedFromBackend = apiResponse.verificationContext?.idVerified === true && !aggregatedFailures?.some((f) => REJECTED_IDENTITY_DIMENSIONS.has(f.dimension));
     const result2 = {
       identityVerified: idVerifiedFromBackend,
       policyAllowed: false,
@@ -650,7 +764,10 @@ async function verify(config, request, options) {
       requiresStepUp: apiResponse.access?.requiresStepUp,
       requiresApproval: apiResponse.access?.requiresApproval,
       guidance: {
-        message: apiResponse.access?.reason || "Access denied by PDLSS policy",
+        // 5.12.0: a presented-but-rejected id (malformed / unknown) carries
+        // actionable registration guidance on its failure — surface it
+        // instead of the bare machine reason ('unknown_agent').
+        message: rejectedIdentityGuidance(aggregatedFailures) ?? (apiResponse.access?.reason || "Access denied by PDLSS policy"),
         registrationUrl: urls?.registrationUrl ?? "",
         documentationUrl: urls?.documentationUrl ?? "",
         // 5.1.0: anonymous callers land on this branch — steer MCP-hosted
@@ -750,7 +867,7 @@ async function verify(config, request, options) {
       registrationUrl: urls?.registrationUrl ?? "",
       documentationUrl: urls?.documentationUrl ?? ""
     };
-  } else if (result.recommendation === "step_up_required") {
+  } else if (result.recommendation === "step_up_required" && result.identityVerified) {
     result.requiresStepUp = true;
     result.denialReasons = serverDenialReasons ?? result.recommendationReasons ?? ["Step-up verification required"];
   }
@@ -773,7 +890,7 @@ async function recordDecision(config, sessionId, decision, reason) {
   }).catch(() => {
   });
 }
-async function reportAttempt(config, report) {
+async function reportAttempt(config, report, options = {}) {
   const apiBaseUrl = config.apiBaseUrl || DEFAULT_CONFIG.apiBaseUrl;
   const headers = { "Content-Type": "application/json" };
   if (config.apiKey) {
@@ -784,13 +901,37 @@ async function reportAttempt(config, report) {
     ...report,
     ...!report.counterpartyId && config.counterpartyId && { counterpartyId: config.counterpartyId }
   };
-  await sdkFetch(`${apiBaseUrl}/agents/verify-access/attempt-report`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body)
-  }).catch(() => {
-  });
+  const url = `${apiBaseUrl}/agents/verify-access/attempt-report`;
+  const init = { method: "POST", headers, body: JSON.stringify(body) };
+  const fail = (failure) => {
+    try {
+      options.onFailure?.(failure);
+    } catch {
+    }
+  };
+  let response;
+  try {
+    response = await sdkFetch(url, init);
+  } catch (err) {
+    fail({ error: err instanceof Error ? err.message : String(err), retried: false });
+    return;
+  }
+  if (response.ok) return;
+  if (response.status !== 429 && response.status < 500) {
+    fail({ status: response.status, retried: false });
+    return;
+  }
+  const delayMs = Math.min(ATTEMPT_REPORT_MAX_RETRY_DELAY_MS, parseRetryAfterMs(response) ?? 500);
+  const timer = setTimeout(() => {
+    sdkFetch(url, init).then((retry) => {
+      if (!retry.ok) fail({ status: retry.status, retried: true });
+    }).catch((err) => {
+      fail({ error: err instanceof Error ? err.message : String(err), retried: true });
+    });
+  }, delayMs);
+  timer.unref?.();
 }
+var ATTEMPT_REPORT_MAX_RETRY_DELAY_MS = 2e3;
 async function fetchRoutes(config, counterpartyId) {
   if (!counterpartyId) return null;
   const headers = { "Content-Type": "application/json" };
@@ -820,7 +961,10 @@ async function reportUnregisteredAttempt(config, data) {
   };
   await sdkFetch(`${apiBaseUrl}/verification-activity/unregistered-attempt`, {
     method: "POST",
-    headers: { "Content-Type": "application/json" },
+    headers: {
+      "Content-Type": "application/json",
+      ...config.apiKey && { Authorization: `Bearer ${config.apiKey}` }
+    },
     body: JSON.stringify(body)
   }).catch(() => {
   });
@@ -842,7 +986,11 @@ async function quickVerify(config, credentials) {
   return {
     identityVerified: result.identityVerified,
     policyAllowed: result.policyAllowed,
-    reason: result.denialReasons?.[0]
+    reason: result.denialReasons?.[0],
+    ...isVerificationUnavailable(result) && {
+      unavailable: true,
+      retryAfterMs: unavailableRetryAfterSeconds(result) * 1e3
+    }
   };
 }
 
@@ -1590,7 +1738,10 @@ var PLATFORM_AGENT_SIGNATURES = [
   {
     vendor: "chatgpt",
     displayName: "OpenAI ChatGPT",
-    uaPatterns: [/chatgpt/i, /openai/i, /gpt-?\d/i],
+    // GPTBot (training crawler) and OAI-SearchBot (ChatGPT search) are
+    // OpenAI's declared crawler UAs — `gpt-?\d` never matched them, so they
+    // classified as unattributed crawlers (round-27.4 W5).
+    uaPatterns: [/chatgpt/i, /openai/i, /gpt-?\d/i, /\bGPTBot\b/i, /\bOAI-SearchBot\b/i],
     agentCardPatterns: [/openai\.com/i, /chatgpt\.com/i],
     apiKeyFormatPatterns: [/^sk-proj/i, /^sk-svcacct/i],
     headerPatterns: [/^openai-organization/i, /^openai-project/i, /^openai-version/i]
@@ -1725,6 +1876,215 @@ var BROWSER_UA_PATTERN = /mozilla\/\d/i;
 var _patterns = { STATIC_EXTENSIONS, BOT_UA_PATTERN, BROWSER_UA_PATTERN, SELF_UA_PATTERN };
 
 // src/edge-core/events.ts
+async function withBudget(promise, ms) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(void 0), ms);
+      })
+    ]);
+  } catch {
+    return void 0;
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+var destKeyOf = (d) => `${d.apiBaseUrl}\0${d.apiKey ?? ""}\0${d.counterparty}\0${d.adapter ?? ""}`;
+var BeaconBuffer = class {
+  constructor(options = {}) {
+    this.queue = [];
+    this.droppedSinceLast = 0;
+    this.droppedTotal = 0;
+    this.deliveredTotal = 0;
+    this.backoffUntil = 0;
+    this.collapse = /* @__PURE__ */ new Map();
+    /** Keys the backend answered 401 for — later batches go unauthenticated. */
+    this.rejectedKeys = /* @__PURE__ */ new Set();
+    this.opts = {
+      maxItems: options.maxItems ?? 1e3,
+      maxBatch: options.maxBatch ?? 100,
+      maxAttempts: options.maxAttempts ?? 3,
+      collapseWindowMs: options.collapseWindowMs ?? 6e4,
+      collapseMaxKeys: options.collapseMaxKeys ?? 1e3,
+      requestTimeoutMs: options.requestTimeoutMs ?? 1e4,
+      retryBackoffMs: options.retryBackoffMs ?? 1e3,
+      now: options.now ?? Date.now
+    };
+  }
+  /**
+   * Queue one beacon. With a `collapseKey`, a repeat inside the window is
+   * merged into a held aggregate (sent when the window closes) instead of
+   * becoming its own item.
+   */
+  enqueue(dest, item, collapseKey) {
+    const now = this.opts.now();
+    if (collapseKey) {
+      const entry = this.collapse.get(collapseKey);
+      if (entry && now - entry.firstSeenAt < this.opts.collapseWindowMs) {
+        for (const target of [entry.first, entry.held]) {
+          if (target && !target.inFlight && this.queue.includes(target)) {
+            target.item.repeatCount = (target.item.repeatCount ?? 1) + 1;
+            return;
+          }
+        }
+        const held = this.push(
+          dest,
+          { ...item, repeatCount: 1 },
+          entry.firstSeenAt + this.opts.collapseWindowMs
+        );
+        entry.held = held;
+        return;
+      }
+      this.collapse.delete(collapseKey);
+      if (this.collapse.size >= this.opts.collapseMaxKeys) {
+        const oldest = this.collapse.keys().next().value;
+        if (oldest !== void 0) this.collapse.delete(oldest);
+      }
+      const fresh = { firstSeenAt: now };
+      this.collapse.set(collapseKey, fresh);
+      fresh.first = this.push(dest, item, now);
+      return;
+    }
+    this.push(dest, item, now);
+  }
+  /**
+   * Deliver every eligible queued item. Concurrent callers share ONE
+   * in-flight drain (it survives the caller's budget and a Lambda freeze),
+   * so nothing in flight is ever sent twice; items queued while it runs are
+   * picked up by the same drain.
+   */
+  flush() {
+    if (!this.inFlight) {
+      this.inFlight = this.drain().finally(() => {
+        this.inFlight = void 0;
+      });
+    }
+    return this.inFlight;
+  }
+  /** Counters for tests and diagnostics. */
+  stats() {
+    return {
+      queueDepth: this.queue.length,
+      droppedSinceLast: this.droppedSinceLast,
+      droppedTotal: this.droppedTotal,
+      deliveredTotal: this.deliveredTotal,
+      flushing: this.inFlight !== void 0
+    };
+  }
+  push(dest, item, eligibleAt) {
+    while (this.queue.length >= this.opts.maxItems) this.dropOldest();
+    const entry = {
+      dest,
+      destKey: destKeyOf(dest),
+      item,
+      attempts: 0,
+      eligibleAt,
+      inFlight: false
+    };
+    this.queue.push(entry);
+    return entry;
+  }
+  dropOldest() {
+    if (this.queue.shift()) this.countDropped(1);
+  }
+  countDropped(n) {
+    this.droppedSinceLast += n;
+    this.droppedTotal += n;
+  }
+  async drain() {
+    for (; ; ) {
+      const now = this.opts.now();
+      if (now < this.backoffUntil) return;
+      const batch = this.takeBatch(now);
+      if (batch.length === 0) return;
+      const ok = await this.send(batch);
+      if (!ok) return;
+    }
+  }
+  /** Oldest eligible item + up to maxBatch-1 more for the same destination. */
+  takeBatch(now) {
+    const first = this.queue.find((q) => q.eligibleAt <= now);
+    if (!first) return [];
+    const batch = [];
+    const rest = [];
+    for (const q of this.queue) {
+      if (batch.length < this.opts.maxBatch && q.destKey === first.destKey && q.eligibleAt <= now) {
+        q.inFlight = true;
+        batch.push(q);
+      } else {
+        rest.push(q);
+      }
+    }
+    this.queue = rest;
+    return batch;
+  }
+  /** POST one batch. Returns false when the drain should pause (backoff). */
+  async send(batch) {
+    const dest = batch[0].dest;
+    const useKey = dest.apiKey && !this.rejectedKeys.has(dest.apiKey) ? dest.apiKey : void 0;
+    const reportedDropped = this.droppedSinceLast;
+    const meta = {
+      droppedSinceLast: reportedDropped,
+      queueDepth: this.queue.length,
+      adapter: dest.adapter ?? "edge-core",
+      version: SDK_VERSION
+    };
+    const controller = typeof AbortController !== "undefined" ? new AbortController() : void 0;
+    const response = await withBudget(
+      sdkFetch(`${dest.apiBaseUrl}/verification-activity/edge-events`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...useKey && { Authorization: `Bearer ${useKey}` }
+        },
+        body: JSON.stringify({ events: batch.map((q) => q.item), meta }),
+        ...controller && { signal: controller.signal }
+      }),
+      this.opts.requestTimeoutMs
+    );
+    if (!response) controller?.abort();
+    const status = response?.status;
+    for (const q of batch) q.inFlight = false;
+    if (status !== void 0 && status >= 200 && status < 300) {
+      this.droppedSinceLast = Math.max(0, this.droppedSinceLast - reportedDropped);
+      this.deliveredTotal += batch.length;
+      return true;
+    }
+    if (status === 401 && useKey) {
+      this.rejectedKeys.add(useKey);
+      this.requeue(batch, false);
+      return true;
+    }
+    if (status === 429) {
+      const retryAfter = Number(response?.headers.get("retry-after"));
+      const waitMs = Number.isFinite(retryAfter) && retryAfter > 0 ? Math.min(retryAfter, 120) * 1e3 : 3e4;
+      this.backoffUntil = this.opts.now() + waitMs;
+      this.requeue(batch, false);
+      return false;
+    }
+    if (status !== void 0 && status >= 400 && status < 500) {
+      this.countDropped(batch.length);
+      return true;
+    }
+    this.backoffUntil = this.opts.now() + this.opts.retryBackoffMs;
+    this.requeue(batch, true);
+    return false;
+  }
+  /** Put a failed batch back at the head of the queue (order preserved). */
+  requeue(batch, countAttempt) {
+    const keep = [];
+    for (const q of batch) {
+      if (countAttempt) q.attempts += 1;
+      if (q.attempts >= this.opts.maxAttempts) this.countDropped(1);
+      else keep.push(q);
+    }
+    this.queue = [...keep, ...this.queue];
+    while (this.queue.length > this.opts.maxItems) this.dropOldest();
+  }
+};
+var beaconBuffer = new BeaconBuffer();
 function sampled(rate, random = Math.random) {
   if (rate <= 0) return false;
   if (rate >= 1) return true;
@@ -1901,12 +2261,19 @@ function defaultOnDenied(result, _req, res) {
     });
     return;
   }
-  const statusCode = !result.identityVerified ? 401 : 403;
+  if (isVerificationUnavailable(result)) {
+    res.setHeader("X-Astra-Gateway-Mode", "enforced");
+    res.setHeader(VERIFICATION_STATUS_HEADER, "unavailable");
+    res.setHeader("Retry-After", String(unavailableRetryAfterSeconds(result)));
+    res.status(503).json(buildVerificationUnavailableBody(result));
+    return;
+  }
+  const { status: statusCode, code } = denyStatusFor(result, "INSUFFICIENT_ACCESS");
   res.setHeader("X-Astra-Gateway-Mode", "enforced");
   res.status(statusCode).json({
     success: false,
     error: {
-      code: !result.identityVerified ? "UNAUTHORIZED" : "INSUFFICIENT_ACCESS",
+      code,
       message: result.denialReasons?.[0] || "Access denied",
       guidance: result.guidance,
       // Round-10: aggregated per-dimension detail + correlation handle.
@@ -2154,6 +2521,21 @@ function createMiddleware(options) {
           result.stepUpOutcome = outcome;
         }
       }
+      if (!result.policyAllowed && isVerificationUnavailable(result) && (!shouldEnforce || isAnonymousRead(req.method, credentials))) {
+        res.setHeader(VERIFICATION_STATUS_HEADER, "unavailable");
+        return next();
+      }
+      if (!shouldEnforce) {
+        if (config.setPassThroughHeader) {
+          res.setHeader("X-Astra-Gateway-Mode", "enforced");
+          res.setHeader("X-Astra-Gateway-Reason", "evaluated-not-enforced");
+        }
+        if (shouldRecordDecisions && sessionId) {
+          recordDecision(config, sessionId, "granted").catch(() => {
+          });
+        }
+        return next();
+      }
       if (!result.policyAllowed) {
         if (shouldRecordDecisions && sessionId) {
           recordDecision(config, sessionId, "denied", result.denialReasons?.[0]).catch(() => {
@@ -2173,17 +2555,6 @@ function createMiddleware(options) {
         onDenied(result, req, res);
         return;
       }
-      if (!shouldEnforce) {
-        if (config.setPassThroughHeader) {
-          res.setHeader("X-Astra-Gateway-Mode", "enforced");
-          res.setHeader("X-Astra-Gateway-Reason", "evaluated-not-enforced");
-        }
-        if (shouldRecordDecisions && sessionId) {
-          recordDecision(config, sessionId, "granted").catch(() => {
-          });
-        }
-        return next();
-      }
       if (routeConfig.minTrustScore && result.agent) {
         if (result.agent.trustScore < routeConfig.minTrustScore) {
           const trustFailure = {
@@ -2239,14 +2610,6 @@ function createMiddleware(options) {
           verifiedAt: /* @__PURE__ */ new Date(),
           correlationId
         };
-        const catchUrls = config.apiBaseUrl ? await getWellKnownUrls(config.apiBaseUrl).catch(() => void 0) : void 0;
-        if (catchUrls) {
-          result.guidance = {
-            message: `Middleware threw ${errorClass} \u2014 failing closed`,
-            registrationUrl: catchUrls.registrationUrl,
-            documentationUrl: catchUrls.documentationUrl
-          };
-        }
         dedupeFailures(result);
         return onDenied(result, req, res);
       }
@@ -2666,6 +3029,20 @@ function createMiddleware2(options) {
     }
     const approvalRequired = result.policyAllowed && requiresHumanApproval(result);
     if (approvalRequired) annotateApprovalRequired(result);
+    if (!result.policyAllowed && isVerificationUnavailable(result)) {
+      if (isAnonymousRead(request.method, credentials)) {
+        const passThrough = NextResponse.next();
+        passThrough.headers.set(VERIFICATION_STATUS_HEADER, "unavailable");
+        return passThrough;
+      }
+      return NextResponse.json(buildVerificationUnavailableBody(result), {
+        status: 503,
+        headers: {
+          "Retry-After": String(unavailableRetryAfterSeconds(result)),
+          [VERIFICATION_STATUS_HEADER]: "unavailable"
+        }
+      });
+    }
     if (!result.policyAllowed || approvalRequired) {
       if (result.misconfigured && pathname.startsWith("/api/")) {
         return NextResponse.json(
@@ -2683,13 +3060,12 @@ function createMiddleware2(options) {
         );
       }
       if (pathname.startsWith("/api/")) {
+        const denyStatus = denyStatusFor(result, "POLICY_DENIED");
         return NextResponse.json(
           {
             success: false,
             error: {
-              // Round-18 G4: 401 → identity missing (re-auth); 403 → identity
-              // OK, policy denied (update PDLSS / step up).
-              code: !result.identityVerified ? "UNAUTHORIZED" : "POLICY_DENIED",
+              code: denyStatus.code,
               message: result.denialReasons?.[0] || "Access denied",
               guidance: result.guidance,
               failures: result.failures,
@@ -2699,7 +3075,7 @@ function createMiddleware2(options) {
             }
           },
           {
-            status: !result.identityVerified ? 401 : 403,
+            status: denyStatus.status,
             ...stepUpHoldOutcome && {
               headers: { "X-Astra-Step-Up": stepUpHoldOutcome }
             }
@@ -2826,6 +3202,12 @@ var VerificationGatewayClient = class {
    * fulfil against it only once the order is settled / pending_merchant. An
    * explicit `buyerEmail` (here or on the bridge handoff body) wins over the
    * account default.
+   *
+   * 5.12.0 approval binding: pass the bridge handoff body's `attemptId` (and
+   * the same `checkoutSessionId`) so a step-up approval minted for this cart
+   * is matched to — and only to — this confirm. A held cart's approval is
+   * bound to its checkout session and exact value; a confirm for any other
+   * cart is held for its own approval.
    */
   async confirmCheckout(options) {
     const credentials = {
@@ -2845,6 +3227,7 @@ var VerificationGatewayClient = class {
           commercePhase: "confirm",
           checkoutSessionId: options.checkoutSessionId,
           checkoutItems: options.checkoutItems,
+          ...options.attemptId && { attemptId: options.attemptId },
           buyerEmail: options.buyerEmail,
           counterpartyUrl: options.counterpartyUrl,
           counterpartyType: options.counterpartyType
@@ -5645,8 +6028,37 @@ function dedupeFailures2(result) {
     result.denialReasons = [...new Set(result.denialReasons)];
   }
 }
+function isReadOnlyMcpMethod(parsed) {
+  return parsed.method !== "tools/call";
+}
 function defaultMcpDenied(result, req, res) {
   const id = req.body?.id ?? null;
+  if (isVerificationUnavailable(result)) {
+    const retryAfterSeconds = unavailableRetryAfterSeconds(result);
+    const body = buildVerificationUnavailableBody(result).error;
+    res.setHeader("X-Astra-Gateway-Mode", "enforced");
+    res.setHeader(VERIFICATION_STATUS_HEADER, "unavailable");
+    res.setHeader("Retry-After", String(retryAfterSeconds));
+    res.status(503).json({
+      jsonrpc: "2.0",
+      id,
+      error: {
+        // -32003 → verification temporarily unavailable (retryable)
+        code: -32003,
+        message: body.message,
+        data: {
+          code: body.code,
+          recommendation: "error",
+          retryable: true,
+          retryAfterSeconds,
+          guidance: body.guidance,
+          failures: result.failures,
+          correlationId: result.correlationId
+        }
+      }
+    });
+    return;
+  }
   if (result.misconfigured) {
     res.setHeader("X-Astra-Gateway-Mode", "enforced");
     res.status(503).json({
@@ -5665,7 +6077,7 @@ function defaultMcpDenied(result, req, res) {
     });
     return;
   }
-  const status = !result.identityVerified ? 401 : 403;
+  const { status, code: denyCode } = denyStatusFor(result, "INSUFFICIENT_ACCESS");
   res.setHeader("X-Astra-Gateway-Mode", "enforced");
   res.status(status).json({
     jsonrpc: "2.0",
@@ -5675,9 +6087,11 @@ function defaultMcpDenied(result, req, res) {
       //   -32000 → unauthorized (no identity resolved)
       //   -32001 → insufficient access (identity OK, policy denied)
       //   -32002 → merchant verification misconfigured (handled above)
+      //   -32003 → verification temporarily unavailable (handled above)
       code: !result.identityVerified ? -32e3 : -32001,
       message: result.denialReasons?.[0] ?? "Access denied",
       data: {
+        code: denyCode,
         guidance: result.guidance,
         // Round-10: aggregated per-dimension detail + correlation handle.
         failures: result.failures,
@@ -5805,6 +6219,9 @@ function createMcpMiddleware(options) {
           resolved_action: pdlss.action
         });
       }
+      if (!pdlss.purpose && !shouldEnforce) {
+        return next();
+      }
       if (!pdlss.purpose) {
         const id = req.body?.id ?? null;
         res.status(400).json({
@@ -5824,6 +6241,9 @@ function createMcpMiddleware(options) {
       }
       const counterpartyUrl = config.counterpartyUrl || `${req.protocol}://${req.get("host")}${req.path}`;
       const shouldRecordDecisions = recordDecisions !== false;
+      const forwardedFor = req.headers["x-forwarded-for"];
+      const forwardedForStr = Array.isArray(forwardedFor) ? forwardedFor.join(", ") : forwardedFor;
+      const sourceIp = req.ip ?? (forwardedForStr ? forwardedForStr.split(",")[0].trim() : void 0);
       const verificationRequest = {
         credentials,
         purpose: pdlss.purpose,
@@ -5838,9 +6258,10 @@ function createMcpMiddleware(options) {
         counterpartyType: config.counterpartyType || "mcp_server",
         enableRuntimeChallenge,
         callerMetadata: {
-          sourceIp: req.ip,
+          sourceIp,
           userAgent: req.headers["user-agent"],
           host: req.headers.host,
+          ...forwardedForStr && { forwardedFor: forwardedForStr },
           // Capture EVERY inbound header (parity with the express adapter —
           // MCP-only merchants have no edge to do it upstream) plus the
           // CDN-derived connection block. Local string work, secrets
@@ -5863,6 +6284,21 @@ function createMcpMiddleware(options) {
           result.stepUpOutcome = outcome;
         }
       }
+      if (!result.policyAllowed && isVerificationUnavailable(result) && (!shouldEnforce || isReadOnlyMcpMethod(parsed) && !credentials.astraId && !credentials.jwt)) {
+        res.setHeader(VERIFICATION_STATUS_HEADER, "unavailable");
+        return next();
+      }
+      if (!shouldEnforce) {
+        if (config.setPassThroughHeader) {
+          res.setHeader("X-Astra-Gateway-Mode", "enforced");
+          res.setHeader("X-Astra-Gateway-Reason", "evaluated-not-enforced");
+        }
+        if (shouldRecordDecisions && sessionId) {
+          recordDecision(config, sessionId, "granted").catch(() => {
+          });
+        }
+        return next();
+      }
       if (!result.policyAllowed) {
         if (shouldRecordDecisions && sessionId) {
           recordDecision(config, sessionId, "denied", result.denialReasons?.[0]).catch(() => {
@@ -5882,17 +6318,6 @@ function createMcpMiddleware(options) {
         onDenied(result, req, res);
         return;
       }
-      if (!shouldEnforce) {
-        if (config.setPassThroughHeader) {
-          res.setHeader("X-Astra-Gateway-Mode", "enforced");
-          res.setHeader("X-Astra-Gateway-Reason", "evaluated-not-enforced");
-        }
-        if (shouldRecordDecisions && sessionId) {
-          recordDecision(config, sessionId, "granted").catch(() => {
-          });
-        }
-        return next();
-      }
       if (effectiveAstraId) {
         res.setHeader(
           MCP_VERIFIED_HOP_HEADER,
@@ -5933,14 +6358,6 @@ function createMcpMiddleware(options) {
           verifiedAt: /* @__PURE__ */ new Date(),
           correlationId
         };
-        const catchUrls = config.apiBaseUrl ? await getWellKnownUrls(config.apiBaseUrl).catch(() => void 0) : void 0;
-        if (catchUrls) {
-          result.guidance = {
-            message: `Middleware threw ${errorClass} \u2014 failing closed`,
-            registrationUrl: catchUrls.registrationUrl,
-            documentationUrl: catchUrls.documentationUrl
-          };
-        }
         dedupeFailures2(result);
         return onDenied(result, req, res);
       }
@@ -9948,6 +10365,7 @@ function parseYaml(yamlContent) {
   RegistrationTimeoutError,
   SDK_USER_AGENT,
   TRUST_LEVEL_RANGES,
+  VERIFICATION_STATUS_HEADER,
   VERSION,
   _resetEdgeConfigCache,
   agent,
@@ -9955,9 +10373,11 @@ function parseYaml(yamlContent) {
   awaitStepUpApproval,
   buildGuidance,
   buildSdkObservedMetadata,
+  buildVerificationUnavailableBody,
   clearCache,
   createMcpMiddleware,
   degradeToObserve,
+  denyStatusFor,
   deriveConnectionFromHeaders,
   detectPlatformFingerprint,
   detectRuntime,
@@ -9974,6 +10394,8 @@ function parseYaml(yamlContent) {
   getWellKnownUrls,
   hasCredentials,
   isEdgeConfig,
+  isRejectedIdentityClaim,
+  isVerificationUnavailable,
   isVerifiedHopValidFor,
   matchEdgePathRule,
   matchPlatformSignature,
@@ -9993,6 +10415,7 @@ function parseYaml(yamlContent) {
   serializeVerifiedHop,
   setMcpMeta,
   transport,
+  unavailableRetryAfterSeconds,
   validateLocalPolicy,
   verify
 });