@astrasyncai/verification-gateway 4.3.0 → 4.5.0

package/dist/edge-core/index.mjs

@@ -1,3 +1,24 @@
+// src/version.ts
+var SDK_VERSION = "4.5.0";
+
+// src/http.ts
+var SDK_USER_AGENT = `astrasync-sdk/${SDK_VERSION}`;
+function withUserAgent(initHeaders) {
+  if (!initHeaders) return { "user-agent": SDK_USER_AGENT };
+  if (initHeaders instanceof Headers) {
+    const copy = new Headers(initHeaders);
+    if (!copy.has("user-agent")) copy.set("user-agent", SDK_USER_AGENT);
+    return copy;
+  }
+  if (Array.isArray(initHeaders)) {
+    const has2 = initHeaders.some(([name]) => name.toLowerCase() === "user-agent");
+    return has2 ? initHeaders : [...initHeaders, ["user-agent", SDK_USER_AGENT]];
+  }
+  const has = Object.keys(initHeaders).some((name) => name.toLowerCase() === "user-agent");
+  return has ? initHeaders : { "user-agent": SDK_USER_AGENT, ...initHeaders };
+}
+var sdkFetch = (input, init) => fetch(input, { ...init, headers: withUserAgent(init?.headers) });
+
 // src/edge-config.ts
 var DEFAULT_EDGE_CONFIG = Object.freeze({
   version: 1,
@@ -57,7 +78,13 @@ var PLATFORM_HEADER_NAMES = /* @__PURE__ */ new Set([
   "x-agent-card-url",
   "x-agent-provider"
 ]);
-var PLATFORM_HEADER_PREFIXES = ["x-goog-", "x-stainless-", "x-anthropic-", "x-openai-"];
+var PLATFORM_HEADER_PREFIXES = [
+  "x-goog-",
+  "x-stainless-",
+  "x-anthropic-",
+  "x-openai-",
+  "sec-ch-"
+];
 var KEY_FORMAT_PREFIXES = [
   "sk-ant-api03",
   "sk-ant-api",
@@ -129,6 +156,7 @@ function sanitizeHeaders(raw) {
   const headers = {};
   const platformHeaders = {};
   let apiKeyFormat;
+  let cookieCount;
   let totalBytes = 0;
   let count = 0;
   if (!raw) return { headers };
@@ -143,6 +171,9 @@ function sanitizeHeaders(raw) {
       if (fmt && !apiKeyFormat) apiKeyFormat = fmt;
       continue;
     }
+    if (name === "cookie") {
+      cookieCount = joined.split(";").filter((s) => s.trim().length > 0).length;
+    }
     if (isSecretHeader(name)) continue;
     let value = joined;
     if (byteLength(value) > MAX_HEADER_VALUE_BYTES) {
@@ -158,6 +189,7 @@ function sanitizeHeaders(raw) {
   const result = { headers };
   if (apiKeyFormat) result.apiKeyFormat = apiKeyFormat;
   if (Object.keys(platformHeaders).length > 0) result.platformHeaders = platformHeaders;
+  if (cookieCount !== void 0) result.cookieCount = cookieCount;
   return result;
 }
 
@@ -205,12 +237,43 @@ var PLATFORM_AGENT_SIGNATURES = [
     uaPatterns: [/perplexity/i],
     agentCardPatterns: [/perplexity\.ai/i],
     apiKeyFormatPatterns: [/^pplx-/i]
+  },
+  // Agentic browsers — versioned-token patterns ONLY (a stock Chrome UA must
+  // never match). Distinct vendor keys (not 'chatgpt'/'perplexity'): the
+  // browser product is a different surface than the assistant service, and
+  // the DB registry mirrors one row per vendor. These sit after the primary
+  // vendor entries so a UA carrying an explicit vendor token keeps its
+  // primary attribution; a browser-shaped UA with the agentic token is
+  // caught here BEFORE classify's human tier, which is what makes these
+  // visits observable at all. Token drift is real (some builds mimic Chrome
+  // outright) — re-verify against captured events when a new browser ships,
+  // and check `sec-ch-ua` platformHeaders for the real brand.
+  {
+    vendor: "chatgpt-atlas",
+    displayName: "ChatGPT Atlas browser",
+    uaPatterns: [/\batlas\/\d/i],
+    headerPatterns: [/^sec-ch-ua: .*atlas/i]
+  },
+  {
+    vendor: "perplexity-comet",
+    displayName: "Perplexity Comet browser",
+    uaPatterns: [/\bcomet\/\d/i],
+    headerPatterns: [/^sec-ch-ua: .*comet/i]
+  },
+  // Our own SDK self-identifies (sdkFetch stamps this UA) — first-party
+  // traffic must never pollute the unknown/anonymous pool it exists to audit.
+  {
+    vendor: "astrasync-sdk",
+    displayName: "AstraSync SDK",
+    uaPatterns: [/^astrasync-sdk\//i]
   }
 ];
 function matchPlatformSignature(signatures, input) {
   const ua = input.userAgent ?? "";
   const cardUrl = input.agentCardUrl ?? "";
   const apiKeyFormat = input.apiKeyFormat ?? "";
+  const ja4 = input.ja4 ?? "";
+  const asn = input.asn ?? "";
   const headerLines = [];
   if (input.platformHeaders) {
     for (const [name, value] of Object.entries(input.platformHeaders)) {
@@ -222,7 +285,9 @@ function matchPlatformSignature(signatures, input) {
     const cardMatch = sig.agentCardPatterns?.some((p) => p.test(cardUrl));
     const keyMatch = apiKeyFormat.length > 0 && sig.apiKeyFormatPatterns?.some((p) => p.test(apiKeyFormat));
     const headerMatch = headerLines.length > 0 && sig.headerPatterns?.some((p) => headerLines.some((line) => p.test(line)));
-    if (uaMatch || cardMatch || keyMatch || headerMatch) {
+    const ja4Match = ja4.length > 0 && sig.ja4Patterns?.some((p) => p.test(ja4));
+    const asnMatch = asn.length > 0 && sig.asnList?.includes(asn);
+    if (uaMatch || cardMatch || keyMatch || headerMatch || ja4Match || asnMatch) {
       const uaBase = ua.split(/[\s/]/)[0]?.toLowerCase() ?? "";
       const cardHost = (() => {
         try {
@@ -231,7 +296,7 @@ function matchPlatformSignature(signatures, input) {
           return "";
         }
       })();
-      const keyBasis = uaBase || cardHost || apiKeyFormat || "unknown";
+      const keyBasis = uaBase || cardHost || apiKeyFormat || ja4 || asn && `asn${asn}` || "unknown";
       return {
         vendor: sig.vendor,
         fingerprintKey: `${sig.vendor}:${keyBasis}`,
@@ -253,9 +318,6 @@ function getTrustLevel(score) {
   return "BRONZE";
 }
 
-// src/version.ts
-var SDK_VERSION = "4.1.0";
-
 // src/well-known.ts
 var CACHE_TTL_MS = 60 * 60 * 1e3;
 var cache = /* @__PURE__ */ new Map();
@@ -284,7 +346,7 @@ async function performInitCheck(apiBaseUrl, debug, strictInit, apiKey) {
   initCheckPerformed = true;
   try {
     const probeUrl = `${apiBaseUrl}/agents/verify-access`;
-    const response = await fetch(probeUrl, { method: "HEAD" });
+    const response = await sdkFetch(probeUrl, { method: "HEAD" });
     const contentType = response.headers.get("content-type") ?? "";
     if (contentType.startsWith("text/html")) {
       const message = `[VerificationGateway] apiBaseUrl '${apiBaseUrl}' returned HTML (content-type: ${contentType}). This usually means apiBaseUrl is pointing at a marketing site instead of the API. Expected: 'https://astrasync.ai/api' (prod) or 'https://staging.astrasync.ai/api' (staging).`;
@@ -298,7 +360,7 @@ async function performInitCheck(apiBaseUrl, debug, strictInit, apiKey) {
       );
     }
     if (apiKey) {
-      const selfCheck = await fetch(`${apiBaseUrl}/agents/verify-access/self-check`, {
+      const selfCheck = await sdkFetch(`${apiBaseUrl}/agents/verify-access/self-check`, {
         headers: { Authorization: `Bearer ${apiKey}` }
       });
       if (selfCheck.status === 401) {
@@ -545,7 +607,7 @@ async function callVerifyAccessAPI(config, request) {
     headers["X-API-Key"] = config.apiKey;
   }
   try {
-    const response = await fetch(`${config.apiBaseUrl}/agents/verify-access`, {
+    const response = await sdkFetch(`${config.apiBaseUrl}/agents/verify-access`, {
       method: "POST",
       headers,
       body: JSON.stringify(body),
@@ -727,12 +789,15 @@ async function verify(config, request, options) {
   const verificationContext = apiResponse.verificationContext;
   const accessLevel = apiResponse.access?.accessLevel ?? "standard";
   const result = {
-    // Round-18 G4: backend allowed access. Identity is verified (we resolved
-    // the caller to an agent) and policy passed all gates. Read idVerified
-    // from verificationContext for symmetry with the deny branch; default true
-    // on success path since `access.allowed === true` implies identity was
-    // resolvable (anonymous-allow paths flow through createGuidanceResponse).
-    identityVerified: apiResponse.verificationContext?.idVerified !== false,
+    // 4.5.0 (probe F1): read idVerified from verificationContext with the
+    // SAME absent⇒false default as the deny branch. The previous `!== false`
+    // default manufactured `identityVerified: true` for anonymous
+    // allow_full/allow_partial/audit responses (which allow access but omit
+    // verificationContext entirely) — the "anonymous caller labelled
+    // verified" defect. Every authenticated success response has carried
+    // `verificationContext.idVerified: true` since v2.2.4, so a truth claim
+    // this load-bearing must never be defaulted on.
+    identityVerified: apiResponse.verificationContext?.idVerified === true,
     policyAllowed: true,
     accessLevel,
     agent,
@@ -790,7 +855,7 @@ async function reportUnregisteredAttempt(config, data) {
     ...counterpartyUrl && { counterpartyUrl },
     ...config.counterpartyId && { counterpartyId: config.counterpartyId }
   };
-  await fetch(`${apiBaseUrl}/verification-activity/unregistered-attempt`, {
+  await sdkFetch(`${apiBaseUrl}/verification-activity/unregistered-attempt`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify(body)
@@ -807,16 +872,39 @@ function requestUrl(req, host) {
   return `https://${host}${req.uri}${qs}`;
 }
 function buildObservedMetadata(req) {
-  const { headers, apiKeyFormat, platformHeaders } = sanitizeHeaders(req.headers);
+  const { headers, apiKeyFormat, platformHeaders, cookieCount } = sanitizeHeaders(req.headers);
   const connection = req.connection ?? {};
+  const queryKeys = extractQueryKeys(req.querystring);
   return {
     headers,
     ...apiKeyFormat && { apiKeyFormat },
     ...platformHeaders && { platformHeaders },
     ...Object.keys(connection).length > 0 && { connection },
+    ...cookieCount !== void 0 && { cookieCount },
+    ...queryKeys && { queryKeys },
     schemaVersion: CAPTURE_SCHEMA_VERSION
   };
 }
+var MAX_QUERY_KEYS = 32;
+var MAX_QUERY_KEY_CHARS = 64;
+function extractQueryKeys(querystring) {
+  if (!querystring) return void 0;
+  let params;
+  try {
+    params = new URLSearchParams(querystring);
+  } catch {
+    return void 0;
+  }
+  const keys = [];
+  for (const key of params.keys()) {
+    const normalized = key.toLowerCase().slice(0, MAX_QUERY_KEY_CHARS);
+    if (normalized && !keys.includes(normalized)) {
+      keys.push(normalized);
+      if (keys.length >= MAX_QUERY_KEYS) break;
+    }
+  }
+  return keys.length > 0 ? keys : void 0;
+}
 
 // src/edge-core/detect.ts
 var SD_JWT_PATTERN = /^eyJ[\w-]+\.[\w-]*\.[\w-]+~/;
@@ -960,6 +1048,7 @@ function detectCommerce(req, host) {
 
 // src/edge-core/classify.ts
 var STATIC_EXTENSIONS = /\.(css|js|mjs|map|png|jpe?g|gif|webp|avif|svg|ico|woff2?|ttf|otf|eot|mp4|webm|pdf|txt|xml)$/i;
+var SELF_UA_PATTERN = /^astrasync-sdk\//i;
 var BOT_UA_PATTERN = /curl|wget|python-requests|python-urllib|node-fetch|axios|got|okhttp|go-http-client|libwww|httpie|java\/|ruby|php|scrapy|headless|phantomjs|selenium|playwright|puppeteer|bot|crawler|spider|slurp/i;
 var BROWSER_UA_PATTERN = /mozilla\/\d/i;
 function resolvePolicy(config, path) {
@@ -976,6 +1065,9 @@ function resolvePolicy(config, path) {
 }
 function classify(req, host, depth) {
   const userAgent = headerValue(req, "user-agent") ?? "";
+  if (SELF_UA_PATTERN.test(userAgent)) {
+    return { tier: "self" };
+  }
   const credentials = extractCredentials(req.headers, {});
   if (credentials.astraId || credentials.apiKey || credentials.jwt) {
     return { tier: "verified", protocol: "x-astra" };
@@ -1006,7 +1098,7 @@ function classify(req, host, depth) {
   }
   return { tier: "human" };
 }
-var _patterns = { STATIC_EXTENSIONS, BOT_UA_PATTERN, BROWSER_UA_PATTERN };
+var _patterns = { STATIC_EXTENSIONS, BOT_UA_PATTERN, BROWSER_UA_PATTERN, SELF_UA_PATTERN };
 
 // src/edge-core/messaging.ts
 var PROTOCOL_MESSAGES = {
@@ -1046,6 +1138,20 @@ function buildDenyBody(outcome, apiBaseUrl) {
     }
   };
 }
+function buildUnavailableBody(outcome) {
+  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 with exponential backoff.",
+      failures: outcome.reasons,
+      ...outcome.correlationId && { correlationId: outcome.correlationId },
+      guidance: {
+        message: "Retry the request with exponential backoff; the condition is transient."
+      }
+    }
+  };
+}
 function buildManualReviewBody(outcome) {
   return {
     success: false,
@@ -1088,6 +1194,14 @@ function applyOutcome(options, outcome, policy) {
   }
   switch (outcome.decision) {
     case "deny":
+      if (outcome.unavailable) {
+        return {
+          action: "respond",
+          status: 503,
+          headers: { "Retry-After": "30" },
+          bodyJson: buildUnavailableBody(outcome)
+        };
+      }
       return {
         action: "respond",
         status: 403,
@@ -1326,6 +1440,17 @@ function outcomeFromVerifyResult(classification, result) {
   };
   return outcome;
 }
+function unavailableOutcome(classification, policy, reason, correlationId) {
+  const outcome = baseOutcome(classification);
+  outcome.unavailable = true;
+  outcome.reasons = [reason];
+  if (correlationId) outcome.correlationId = correlationId;
+  if (policy.mode === "enforce") outcome.decision = "deny";
+  return outcome;
+}
+function isApiErrorResult(result) {
+  return (result.failures ?? []).some((f) => f.dimension === "verify_access.api_error") === true && !result.misconfigured;
+}
 async function runTier(options, req, classification, policy, apiKey, sampling) {
   const budgets = options.budgets ?? {};
   const beaconMs = budgets.beaconMs ?? 300;
@@ -1352,9 +1477,19 @@ async function runTier(options, req, classification, policy, apiKey, sampling) {
           verifyMs
         );
         if (!result) {
-          const outcome = baseOutcome(classification);
-          outcome.reasons = ["verify-access unreachable within budget \u2014 fail-open"];
-          return outcome;
+          return unavailableOutcome(
+            classification,
+            policy,
+            "verify-access unreachable within budget"
+          );
+        }
+        if (isApiErrorResult(result)) {
+          return unavailableOutcome(
+            classification,
+            policy,
+            result.denialReasons?.[0] ?? "verify-access api error",
+            result.correlationId
+          );
         }
         return outcomeFromVerifyResult(classification, result);
       }
@@ -1365,9 +1500,19 @@ async function runTier(options, req, classification, policy, apiKey, sampling) {
             verifyMs
           );
           if (!result) {
-            const outcome2 = baseOutcome(classification);
-            outcome2.reasons = ["verify-access unreachable within budget \u2014 fail-open"];
-            return outcome2;
+            return unavailableOutcome(
+              classification,
+              policy,
+              "verify-access unreachable within budget"
+            );
+          }
+          if (isApiErrorResult(result)) {
+            return unavailableOutcome(
+              classification,
+              policy,
+              result.denialReasons?.[0] ?? "verify-access api error",
+              result.correlationId
+            );
           }
           return outcomeFromVerifyResult(classification, result);
         }
@@ -1409,7 +1554,7 @@ async function evaluateEdgeRequest(options, req, config, apiKey) {
     if (policy.skip) return { policy, application: passUntouched() };
     const host = headerValue(req, "x-forwarded-host") ?? headerValue(req, "host") ?? new URL(options.counterpartyUrl).host;
     const classification = classify(req, host, policy.depth);
-    if (classification.tier === "human") {
+    if (classification.tier === "human" || classification.tier === "self") {
       return { policy, classification, application: passUntouched() };
     }
     const outcome = await runTier(options, req, classification, policy, apiKey, config.sampling);