@astrasyncai/verification-gateway 5.11.0 → 5.12.0

package/dist/edge-core/index.js

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var edge_core_exports = {};
 __export(edge_core_exports, {
   ASAT_HEADERS: () => ASAT_HEADERS,
+  BeaconBuffer: () => BeaconBuffer,
   _patterns: () => _patterns,
   applyOutcome: () => applyOutcome,
   buildDenyBody: () => buildDenyBody,
@@ -31,10 +32,12 @@ __export(edge_core_exports, {
   detectCommerce: () => detectCommerce,
   emitBeacon: () => emitBeacon,
   evaluateEdgeRequest: () => evaluateEdgeRequest,
+  getBeaconBuffer: () => getBeaconBuffer,
   headerValue: () => headerValue,
   outcomeFromVerifyResult: () => outcomeFromVerifyResult,
   passUntouched: () => passUntouched,
   requestUrl: () => requestUrl,
+  resetBeaconBuffer: () => resetBeaconBuffer,
   resolvePolicy: () => resolvePolicy,
   runTier: () => runTier,
   sampled: () => sampled,
@@ -43,7 +46,7 @@ __export(edge_core_exports, {
 module.exports = __toCommonJS(edge_core_exports);
 
 // 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}`;
@@ -256,7 +259,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]
@@ -398,6 +404,14 @@ function getCachedWellKnownUrls(apiBaseUrl) {
   return cache.get(apiBaseUrl)?.data;
 }
 
+// src/failure-posture.ts
+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.";
+
 // src/verify.ts
 var DEFAULT_CONFIG = {
   apiBaseUrl: "https://astrasync.ai/api",
@@ -643,11 +657,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 = {
@@ -704,7 +751,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,
@@ -742,6 +790,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 {
@@ -756,9 +821,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;
@@ -830,12 +897,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,
@@ -847,7 +916,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
@@ -947,7 +1019,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"];
   }
@@ -957,21 +1029,6 @@ async function verify(config, request, options) {
   }
   return result;
 }
-async function reportUnregisteredAttempt(config, data) {
-  const apiBaseUrl = config.apiBaseUrl || DEFAULT_CONFIG.apiBaseUrl;
-  const { counterpartyUrl, ...rest } = data;
-  const body = {
-    ...rest,
-    ...counterpartyUrl && { counterpartyUrl },
-    ...config.counterpartyId && { counterpartyId: config.counterpartyId }
-  };
-  await sdkFetch(`${apiBaseUrl}/verification-activity/unregistered-attempt`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body)
-  }).catch(() => {
-  });
-}
 
 // src/edge-core/request.ts
 function headerValue(req, name) {
@@ -1507,42 +1564,263 @@ async function withBudget(promise, ms) {
     if (timer) clearTimeout(timer);
   }
 }
-async function emitBeacon(options, req, classification, budgetMs, queryValueAllowlist) {
+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 getBeaconBuffer() {
+  return beaconBuffer;
+}
+function resetBeaconBuffer(options) {
+  beaconBuffer = new BeaconBuffer(options);
+  return beaconBuffer;
+}
+async function emitBeacon(options, req, classification, budgetMs, queryValueAllowlist, apiKey) {
   const attemptId = extractAttemptId(req);
   const declaredSource = normalizeDeclaredSource(headerValue(req, "x-astra-source"));
-  const budgeted = withBudget(
-    reportUnregisteredAttempt(
-      { apiBaseUrl: options.apiBaseUrl, counterpartyId: options.counterpartyId },
-      {
-        counterpartyUrl: options.counterpartyUrl,
-        counterpartyType: "website",
-        sourceIp: req.clientIp,
-        userAgent: headerValue(req, "user-agent"),
-        requestPath: req.uri,
-        requestMethod: req.method,
-        // Attempt-chain handle (header or ?astra_attempt= deep link) — joins
-        // this beacon into the agent's research chain via pe_attempt_idx.
-        ...attemptId && { attemptId },
-        // First-class referer + accept: traffic-source and surface-classifier
-        // inputs (previously buried inside observedMetadata.headers).
-        referer: headerValue(req, "referer"),
-        accept: headerValue(req, "accept"),
-        ...declaredSource && { declaredSource },
-        // Evidence fields the backend persists into the event record.
-        protocol: classification.protocol,
-        evidence: classification.evidence,
-        // The full sanitized header + connection capture for the
-        // unregistered caller (fire-and-forget, so free).
-        observedMetadata: buildObservedMetadata(req, queryValueAllowlist)
-      }
-    ),
-    budgetMs
+  const userAgent = headerValue(req, "user-agent");
+  const item = {
+    ...options.counterpartyId && { counterpartyId: options.counterpartyId },
+    ...options.counterpartyUrl && { counterpartyUrl: options.counterpartyUrl },
+    counterpartyType: "website",
+    sourceIp: req.clientIp,
+    userAgent,
+    requestPath: req.uri,
+    requestMethod: req.method,
+    // Attempt-chain handle (header or ?astra_attempt= deep link) — joins
+    // this beacon into the agent's research chain via pe_attempt_idx.
+    ...attemptId && { attemptId },
+    // First-class referer + accept: traffic-source and surface-classifier
+    // inputs (previously buried inside observedMetadata.headers).
+    referer: headerValue(req, "referer"),
+    accept: headerValue(req, "accept"),
+    ...declaredSource && { declaredSource },
+    // Evidence fields the backend persists into the event record.
+    protocol: classification.protocol,
+    evidence: classification.evidence,
+    // The full sanitized header + connection capture for the unregistered
+    // caller.
+    observedMetadata: buildObservedMetadata(req, queryValueAllowlist),
+    // Capture time — batched delivery skews createdAt by the flush delay.
+    observedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  for (const k of Object.keys(item)) if (item[k] === void 0) delete item[k];
+  const buffer = getBeaconBuffer();
+  buffer.enqueue(
+    {
+      apiBaseUrl: options.apiBaseUrl,
+      ...apiKey && { apiKey },
+      counterparty: options.counterpartyId || options.counterpartyUrl,
+      ...options.adapter && { adapter: options.adapter }
+    },
+    item,
+    // Repeat collapse needs a client identity; without an IP, distinct
+    // callers sharing a UA would merge, so don't collapse.
+    req.clientIp ? [
+      options.counterpartyId || options.counterpartyUrl,
+      req.clientIp,
+      userAgent ?? "",
+      req.method,
+      req.uri,
+      attemptId ?? ""
+    ].join("\0") : void 0
   );
+  const flushing = buffer.flush();
   if (options.waitUntil) {
-    options.waitUntil(budgeted);
+    options.waitUntil(flushing);
     return;
   }
-  await budgeted;
+  await withBudget(flushing, budgetMs);
 }
 function sampled(rate, random = Math.random) {
   if (rate <= 0) return false;
@@ -1707,7 +1985,7 @@ async function runTier(options, req, classification, policy, apiKey, capture) {
           }
           return outcomeFromVerifyResult(classification, result);
         }
-        await emitBeacon(options, req, classification, beaconMs, queryValueAllowlist);
+        await emitBeacon(options, req, classification, beaconMs, queryValueAllowlist, apiKey);
         const outcome = baseOutcome(classification);
         if (policy.mode === "enforce" && policy.depth !== "classify") {
           outcome.decision = "deny";
@@ -1722,7 +2000,8 @@ async function runTier(options, req, classification, policy, apiKey, capture) {
             req,
             { ...classification, protocol: classification.protocol ?? "ua-heuristic" },
             beaconMs,
-            queryValueAllowlist
+            queryValueAllowlist,
+            apiKey
           );
         }
         return baseOutcome(classification);
@@ -1776,6 +2055,7 @@ async function evaluateEdgeRequest(options, req, config, apiKey) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ASAT_HEADERS,
+  BeaconBuffer,
   _patterns,
   applyOutcome,
   buildDenyBody,
@@ -1786,10 +2066,12 @@ async function evaluateEdgeRequest(options, req, config, apiKey) {
   detectCommerce,
   emitBeacon,
   evaluateEdgeRequest,
+  getBeaconBuffer,
   headerValue,
   outcomeFromVerifyResult,
   passUntouched,
   requestUrl,
+  resetBeaconBuffer,
   resolvePolicy,
   runTier,
   sampled,