@astrasyncai/verification-gateway 5.18.1 → 5.19.0

package/dist/adapters/mcp.d.ts

@@ -1,5 +1,5 @@
 import { Request, Response, RequestHandler } from 'express';
-import { d as VerificationResult, G as GatewayConfig } from '../types-Cns4l8gX.js';
+import { e as VerificationResult, G as GatewayConfig } from '../types-DqWPkiYl.js';
 
 /**
  * X-Astra-Verified-Hop — cross-hop verify-access dedupe marker.
@@ -378,23 +378,94 @@ interface McpMiddlewareOptions extends GatewayConfig {
     recordDecisions?: boolean;
     /** Forward runtime challenge (default `true`). */
     enableRuntimeChallenge?: boolean;
+    /**
+     * 5.19.0: how a dashboard tool rule combines with a code `toolGates`
+     * entry for the same tool. With `apiKey` + `counterpartyId` set, the
+     * middleware fetches the endpoint's tool rules (`{tool, purpose, action,
+     * resource?, observe?}`, edited in the AstraSync dashboard; refreshed every
+     * `routesRefreshMs`) and turns each into a gate for that tool.
+     *
+     * - `'code'` (default): a dashboard rule can TIGHTEN a code gate but never
+     *   loosen it. For a tool gated in code (object form), a dashboard
+     *   `observe` rule, or one with no purpose, is ignored; a dashboard rule
+     *   whose purpose or action differs is evaluated IN ADDITION — both must
+     *   pass. Tools with no code gate (or a code `'observe'`) follow the
+     *   dashboard rule.
+     * - `'dashboard'`: the dashboard rule wins outright for every tool it
+     *   names (including `observe`).
+     *
+     * Rules flagged `legacy: true` (path rules stored on an MCP endpoint before
+     * tool rules existed) are ignored. The middleware sends its code-gated tool
+     * names on the policy fetch (`?codeGates=`) so the dashboard can mark them.
+     */
+    toolGatePrecedence?: 'code' | 'dashboard';
+    /** 5.19.0: refresh interval (ms) for the dashboard tool rules. Default 5 minutes. */
+    routesRefreshMs?: number;
     /**
      * Posture when the MCP middleware itself throws an internal error.
-     * Default `'open'` for backward compatibility in SDK 2.4.13. Shadow logs
-     * record what WOULD be denied with `failOnError: 'closed'` so merchants
-     * can grep correlationId for impact analysis during the observation
-     * window. Default flips to `'closed'` in a follow-up release.
      *
-     * 5.12.0: `'closed'` answers the retryable verification-unavailable
-     * JSON-RPC error (HTTP 503 + Retry-After, code -32003) — never an
-     * identity-shaped 401.
+     * 5.19.0 (behaviour change): default `'closed'` — an internal throw answers
+     * the retryable verification-unavailable JSON-RPC error (HTTP 503 +
+     * Retry-After, code -32003; never an identity-shaped 401) and the tool
+     * handler is not called. `'open'` (pass the call through unverified) is
+     * an explicit opt-in. The `[SHADOW] would-have-denied` log line is still
+     * written on every throw, with the correlationId.
      */
     failOnError?: 'open' | 'closed';
 }
+/** 5.19.0: a dashboard tool rule as the MCP middleware evaluates it. */
+interface DashboardToolRule {
+    tool: string;
+    purpose?: string;
+    action?: string;
+    resource?: string;
+    observe?: boolean;
+}
+/** The usable tool rules in a fetched policy (tool key set, not legacy), by tool name. */
+declare function dashboardToolRules(routes: ReadonlyArray<{
+    tool?: string;
+    legacy?: boolean;
+    purpose?: string;
+    action?: string;
+    resource?: string;
+    observe?: boolean;
+}>): Map<string, DashboardToolRule>;
+type GateSource = 'toolGate' | 'methodGate' | 'dashboard' | 'tier' | 'discovery_default';
+/**
+ * Resolve whether a parsed MCP request is enforced, and the gate config to
+ * apply. SDK 5.0.0 removed the access-level band — a gate's only decision is
+ * enforce vs observe.
+ *
+ * Precedence:
+ *   1. Non-tools/call without `methodGates` entry → pass through
+ *      (`discovery_default`). Discovery is open — agents must list tools
+ *      before invoking them.
+ *   2. `methodGates[method]` — per-method override (`'observe'` or a config)
+ *   3. tools/call: the code `toolGates[toolName]` and the dashboard tool rule
+ *      (5.19.0) — see `toolGatePrecedence`. With the default `'code'`, a
+ *      dashboard rule only tightens a code gate: it is ignored when it is
+ *      `observe` or has no purpose, and evaluated as an `additional` gate
+ *      (both must pass) when its purpose/action differ.
+ *   4. `mcpDefaultEnforced` — built-in default (tools/call → enforced)
+ *
+ * The `source` field is logged for forensics / activity-feed attribution.
+ */
+declare function resolveGate(parsed: ParsedMcpRequest, opts: {
+    toolGates?: Record<string, ToolGate>;
+    methodGates?: Record<string, ToolGate>;
+    dashboardRules?: Map<string, DashboardToolRule>;
+    toolGatePrecedence?: 'code' | 'dashboard';
+}): {
+    enforce: boolean;
+    config?: ToolGateConfig;
+    /** 5.19.0: a dashboard gate evaluated in addition to `config` (both must pass). */
+    additional?: ToolGateConfig;
+    source: GateSource;
+};
 /**
  * Create the MCP middleware. Attach AFTER `express.json()` — the body must
  * already be a parsed object.
  */
 declare function createMcpMiddleware(options: McpMiddlewareOptions): RequestHandler;
 
-export { MCP_VERIFIED_HOP_HEADER, type McpMiddlewareOptions, type ParsedMcpRequest, type ToolGate, type ToolGateConfig, createMcpMiddleware, isVerifiedHopValidFor, mcpDefaultEnforced, mcpToPdlss, parseMcpJsonRpc, parseVerifiedHop, serializeVerifiedHop };
+export { type DashboardToolRule, MCP_VERIFIED_HOP_HEADER, type McpMiddlewareOptions, type ParsedMcpRequest, type ToolGate, type ToolGateConfig, createMcpMiddleware, dashboardToolRules, isVerifiedHopValidFor, mcpDefaultEnforced, mcpToPdlss, parseMcpJsonRpc, parseVerifiedHop, resolveGate, serializeVerifiedHop };

package/dist/adapters/mcp.js

@@ -22,17 +22,19 @@ var mcp_exports = {};
 __export(mcp_exports, {
   MCP_VERIFIED_HOP_HEADER: () => MCP_VERIFIED_HOP_HEADER,
   createMcpMiddleware: () => createMcpMiddleware,
+  dashboardToolRules: () => dashboardToolRules,
   isVerifiedHopValidFor: () => isVerifiedHopValidFor,
   mcpDefaultEnforced: () => mcpDefaultEnforced,
   mcpToPdlss: () => mcpToPdlss,
   parseMcpJsonRpc: () => parseMcpJsonRpc,
   parseVerifiedHop: () => parseVerifiedHop,
+  resolveGate: () => resolveGate,
   serializeVerifiedHop: () => serializeVerifiedHop
 });
 module.exports = __toCommonJS(mcp_exports);
 
 // src/version.ts
-var SDK_VERSION = "5.18.1";
+var SDK_VERSION = "5.19.0";
 
 // src/http.ts
 var SDK_USER_AGENT = `astrasync-sdk/${SDK_VERSION}`;
@@ -274,7 +276,12 @@ function getCacheKey(request, counterpartyId) {
     // its start_checkout quote was served the cached quote-leg grant (no
     // settlementOutcome) and never reached the backend. Same F-A1-07 bug class.
     request.commercePhase || "",
-    request.checkoutSessionId || ""
+    request.checkoutSessionId || "",
+    // 5.19.0: a route_config purpose claim is checked server-side against
+    // the stored rule for this method + path, so it changes the verdict.
+    request.purposeSource || "",
+    request.requestMethod || "",
+    request.requestPath || ""
   ].join("|");
 }
 function getCachedResult(request, counterpartyId) {
@@ -482,6 +489,11 @@ async function callVerifyAccessAPI(config, request) {
   if (requestData.buyerEmail) body.buyerEmail = requestData.buyerEmail;
   if (requestData.commerceArtifacts) body.commerceArtifacts = requestData.commerceArtifacts;
   if (requestData.attemptId) body.attemptId = requestData.attemptId;
+  if (requestData.purposeSource) body.purposeSource = requestData.purposeSource;
+  if (requestData.agentArtifacts) body.agentArtifacts = requestData.agentArtifacts;
+  if (requestData.metadata) body.metadata = requestData.metadata;
+  if (requestData.requestMethod) body.requestMethod = requestData.requestMethod;
+  if (requestData.requestPath) body.requestPath = requestData.requestPath;
   if (requestData.considerationSet) body.considerationSet = requestData.considerationSet;
   body.sdkVersion = SDK_VERSION;
   if (requestData.callerMetadata || requestData.clientIp || requestData.userAgent) {
@@ -671,9 +683,18 @@ async function verify(config, request, options) {
   if (!apiResponse.access?.allowed) {
     const aggregatedFailures = apiResponse.access?.failures;
     const idVerifiedFromBackend = apiResponse.verificationContext?.idVerified === true && !aggregatedFailures?.some((f) => REJECTED_IDENTITY_DIMENSIONS.has(f.dimension));
+    const denyAgent = idVerifiedFromBackend && apiResponse.agent ? {
+      astraId: apiResponse.agent.astraId,
+      name: apiResponse.agent.name,
+      trustScore: apiResponse.agent.trustScore,
+      trustLevel: getTrustLevel(apiResponse.agent.trustScore),
+      blockchainAnchored: apiResponse.agent.blockchainStatus === "anchored",
+      status: apiResponse.agent.agentStatus
+    } : void 0;
     const result2 = {
       identityVerified: idVerifiedFromBackend,
       policyAllowed: false,
+      ...denyAgent && { agent: denyAgent },
       // 3.6.0: the server now emits top-level denialReasons on every deny
       // path — prefer it verbatim; the failure-message reconstruction remains
       // as the fallback for older backends.
@@ -822,6 +843,34 @@ async function recordDecision(config, sessionId, decision, reason) {
   }).catch(() => {
   });
 }
+var refusedPolicyReads = /* @__PURE__ */ new Set();
+async function fetchRoutes(config, counterpartyId, options = {}) {
+  if (!counterpartyId) return null;
+  const headers = { "Content-Type": "application/json" };
+  if (config.apiKey) {
+    headers["Authorization"] = `Bearer ${config.apiKey}`;
+    headers["X-API-Key"] = config.apiKey;
+  }
+  try {
+    const response = await sdkFetch(
+      `${config.apiBaseUrl}/endpoints/${encodeURIComponent(counterpartyId)}/routes` + (options.codeGates?.length ? `?codeGates=${options.codeGates.map(encodeURIComponent).join(",")}` : ""),
+      { method: "GET", headers }
+    );
+    if (!response.ok) {
+      if ((response.status === 401 || response.status === 403 || response.status === 404) && !refusedPolicyReads.has(counterpartyId)) {
+        refusedPolicyReads.add(counterpartyId);
+        console.error(
+          `[VerificationGateway] the configured API key cannot read the route policy for ${counterpartyId} (HTTP ${response.status}). The key belongs to an account that does not own this endpoint, or the counterpartyId is wrong. The gateway is in PASS-THROUGH mode: no agent is being verified.`
+        );
+      }
+      return null;
+    }
+    const body = await response.json();
+    return body.data?.routes ?? [];
+  } catch {
+    return null;
+  }
+}
 
 // src/metadata-capture.ts
 var CAPTURE_SCHEMA_VERSION = 1;
@@ -1144,6 +1193,42 @@ async function awaitStepUpApproval(config, approval) {
   return "timeout";
 }
 
+// src/adapters/routes-cache.ts
+var DEFAULT_ROUTES_REFRESH_MS = 5 * 60 * 1e3;
+function createRoutesCache(config, opts = {}) {
+  const refreshMs = opts.refreshMs ?? DEFAULT_ROUTES_REFRESH_MS;
+  let cached = [];
+  let lastFetchAt = 0;
+  let refreshing = null;
+  async function refresh() {
+    if (!config.counterpartyId) {
+      opts.onNoCounterparty?.();
+      return;
+    }
+    const fetched = await fetchRoutes(config, config.counterpartyId, opts.fetchOptions);
+    if (fetched) {
+      cached = fetched;
+      lastFetchAt = Date.now();
+      opts.onFetched?.(fetched);
+    }
+  }
+  function start() {
+    refreshing = refresh().catch(() => void 0).finally(() => {
+      refreshing = null;
+    });
+  }
+  start();
+  return {
+    async current() {
+      if (refreshing) await refreshing.catch(() => {
+      });
+      if (config.counterpartyId && Date.now() - lastFetchAt > refreshMs) start();
+      return cached;
+    },
+    peek: () => cached
+  };
+}
+
 // src/verified-hop.ts
 var MCP_VERIFIED_HOP_HEADER = "X-Astra-Verified-Hop";
 var MCP_VERIFIED_HOP_MAX_AGE_MS = 6e4;
@@ -1364,6 +1449,21 @@ function defaultMcpDenied(result, req, res) {
     }
   });
 }
+function dashboardToolRules(routes) {
+  const out = /* @__PURE__ */ new Map();
+  for (const r of routes) {
+    if (typeof r.tool !== "string" || !r.tool || r.legacy === true) continue;
+    if (out.has(r.tool)) continue;
+    out.set(r.tool, {
+      tool: r.tool,
+      ...r.purpose && { purpose: r.purpose },
+      ...r.action && { action: r.action },
+      ...r.resource && { resource: r.resource },
+      ...r.observe === true && { observe: true }
+    });
+  }
+  return out;
+}
 function resolveGate(parsed, opts) {
   if (!parsed.toolName) {
     const methodGate = opts.methodGates?.[parsed.method];
@@ -1373,8 +1473,30 @@ function resolveGate(parsed, opts) {
     return { enforce: false, source: "discovery_default" };
   }
   const toolGate = opts.toolGates?.[parsed.toolName];
+  const rule = opts.dashboardRules?.get(parsed.toolName);
+  const fromRule = (r) => r.observe ? { enforce: false, source: "dashboard" } : {
+    enforce: true,
+    config: {
+      ...r.purpose && { purpose: r.purpose },
+      ...r.action && { action: r.action },
+      ...r.resource && { resource: r.resource }
+    },
+    source: "dashboard"
+  };
+  const codeGated = toolGate !== void 0 && toolGate !== "observe";
+  if (rule && (opts.toolGatePrecedence === "dashboard" || !codeGated)) return fromRule(rule);
   if (toolGate !== void 0) {
-    return toolGate === "observe" ? { enforce: false, source: "toolGate" } : { enforce: true, config: toolGate, source: "toolGate" };
+    if (toolGate === "observe") return { enforce: false, source: "toolGate" };
+    if (rule && !rule.observe && rule.purpose && (rule.purpose !== toolGate.purpose || rule.action && rule.action !== toolGate.action)) {
+      const extra = fromRule(rule).config;
+      return {
+        enforce: true,
+        config: toolGate,
+        additional: { ...extra, ...!extra.resource && toolGate.resource && { resource: toolGate.resource } },
+        source: "toolGate"
+      };
+    }
+    return { enforce: true, config: toolGate, source: "toolGate" };
   }
   return { enforce: mcpDefaultEnforced(parsed), source: "tier" };
 }
@@ -1389,13 +1511,20 @@ function createMcpMiddleware(options) {
     verifiedHopMaxAgeMs,
     recordDecisions,
     enableRuntimeChallenge = true,
-    failOnError = "open",
+    failOnError = "closed",
+    toolGatePrecedence = "code",
+    routesRefreshMs,
     ...config
   } = options;
   if (config.apiBaseUrl) {
     prefetchWellKnown(config.apiBaseUrl).catch(() => {
     });
   }
+  const codeGatedTools = Object.entries(toolGates ?? {}).filter(([, g]) => g !== "observe").map(([name]) => name);
+  const rulesCache = config.apiKey && config.counterpartyId ? createRoutesCache(config, {
+    ...routesRefreshMs !== void 0 && { refreshMs: routesRefreshMs },
+    ...codeGatedTools.length && { fetchOptions: { codeGates: codeGatedTools } }
+  }) : void 0;
   return async (req, res, next) => {
     try {
       if (skip) return next();
@@ -1444,9 +1573,12 @@ function createMcpMiddleware(options) {
           return next();
         }
       }
+      const dashboardRules = rulesCache ? dashboardToolRules(await rulesCache.current()) : void 0;
       const gateDecision = resolveGate(parsed, {
         toolGates,
-        methodGates
+        methodGates,
+        dashboardRules,
+        toolGatePrecedence
       });
       const credentials = extractCredentials(
         req.headers,
@@ -1544,6 +1676,20 @@ function createMcpMiddleware(options) {
           result.stepUpOutcome = outcome;
         }
       }
+      if (shouldEnforce && gateDecision.additional?.purpose && result.policyAllowed && !requiresHumanApproval(result)) {
+        const extra = mcpToPdlss(parsed, req.path, void 0, void 0, gateDecision.additional);
+        const extraResult = await verify(config, {
+          ...verificationRequest,
+          purpose: extra.purpose,
+          action: extra.action,
+          resource: extra.resource
+        });
+        if (!extraResult.policyAllowed || requiresHumanApproval(extraResult)) {
+          result = extraResult;
+          req.agentVerification = result;
+          sessionId = result.sessionId;
+        }
+      }
       if (!result.policyAllowed && isVerificationUnavailable(result) && (!shouldEnforce || isReadOnlyMcpMethod(parsed) && !credentials.astraId && !credentials.jwt)) {
         res.setHeader(VERIFICATION_STATUS_HEADER, "unavailable");
         return next();
@@ -1629,11 +1775,13 @@ function createMcpMiddleware(options) {
 0 && (module.exports = {
   MCP_VERIFIED_HOP_HEADER,
   createMcpMiddleware,
+  dashboardToolRules,
   isVerifiedHopValidFor,
   mcpDefaultEnforced,
   mcpToPdlss,
   parseMcpJsonRpc,
   parseVerifiedHop,
+  resolveGate,
   serializeVerifiedHop
 });
 //# sourceMappingURL=mcp.js.map