@devlab.group/agent-commerce 0.2.0-beta.0 → 1.1.0

package/dist/guardrails-Dmwi63KB.d.ts

@@ -0,0 +1,38 @@
+/**
+ * How the gateway authenticates to a remote facilitator.
+ *
+ * Deliberately a list, not a vendor: x402 facilitators are not a Coinbase-only
+ * category, and a scheme that only fitted one vendor's credentials would make
+ * the abstraction a fiction.
+ *
+ * - `none` — the facilitator takes no credential (the public testnet one).
+ * - `bearer` — a static token. Covers most self-hosted and third-party
+ * facilitators, and needs nothing installed.
+ * - `cdp` — Coinbase Developer Platform, which signs a fresh JWT per request
+ * over method + host + path, so a static header cannot express it. Handled by
+ * the optional peer `@coinbase/x402`, imported only when this type is
+ * configured. Anyone not using CDP never installs it.
+ *
+ * A facilitator whose scheme is none of these is refused at config load rather
+ * than sent nothing.
+ */
+type FacilitatorAuth = {
+    readonly type: 'none';
+} | {
+    readonly type: 'bearer';
+    readonly token: string;
+} | {
+    readonly type: 'cdp';
+    readonly apiKeyId: string;
+    readonly apiKeySecret: string;
+};
+type X402FacilitatorConfig = {
+    readonly mode: 'local';
+    readonly signerPrivateKey: string;
+} | {
+    readonly mode: 'remote';
+    readonly url: string;
+    readonly auth: FacilitatorAuth;
+};
+
+export type { FacilitatorAuth as F, X402FacilitatorConfig as X };

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { I as IsoTimestamp, D as DecimalAmount, P as PaymentMethodName, B as BackendHandler, A as AdapterDescriptor, a as AdapterHealth, C as CommerceResource, R as ResourceRegistry, b as PaymentProvider, L as Logger, c as Clock, d as IdGenerator } from './runtime-Bie-9FAM.js';
-export { e as BackendMethod, f as DEFAULT_BACKEND_TIMEOUT_MS, J as JsonSchema, N as NOOP_LOGGER, g as PaymentChallenge, h as PaymentContext, i as PaymentRequirement, j as PaymentResult, k as PaymentSettlementContext, l as PaymentSubmission, m as PaymentVerificationContext, n as Pricing, o as ProtocolName, s as systemClock } from './runtime-Bie-9FAM.js';
-import { X as X402FacilitatorConfig } from './guardrails-Di_yI_DW.js';
-import { D as DeliveredOutcome, P as PaymentRequiredOutcome, C as CommerceEvent, a as PaymentAttempt, b as CommerceReceipt, E as ExecutionPipeline, c as ProtocolAdapter } from './protocol-adapter-CtB0sOnV.js';
-export { d as COMMERCE_EVENT_TYPES, e as CanonicalRequest, f as CommerceEventType, g as EventSink, h as ExecutionOutcome, H as HttpProtocolAdapter, i as ProtocolAdapterContext, j as isHttpProtocolAdapter } from './protocol-adapter-CtB0sOnV.js';
+import { I as IsoTimestamp, D as DecimalAmount, P as PaymentMethodName, B as BackendHandler, A as AdapterDescriptor, a as AdapterHealth, C as CommerceResource, R as ResourceRegistry, b as PaymentProvider, L as Logger, c as Clock, d as IdGenerator } from './runtime-CC6EFmLP.js';
+export { e as BackendMethod, f as DEFAULT_BACKEND_TIMEOUT_MS, J as JsonSchema, N as NOOP_LOGGER, g as PaymentChallenge, h as PaymentContext, i as PaymentRequirement, j as PaymentResult, k as PaymentSettlementContext, l as PaymentSubmission, m as PaymentVerificationContext, n as Pricing, o as ProtocolName, s as systemClock } from './runtime-CC6EFmLP.js';
+import { X as X402FacilitatorConfig } from './guardrails-Dmwi63KB.js';
+import { D as DeliveredOutcome, P as PaymentRequiredOutcome, C as CommerceEvent, a as PaymentAttempt, b as CommerceReceipt, E as ExecutionPipeline, c as ProtocolAdapter } from './protocol-adapter-DZ8qkkAa.js';
+export { A as AdapterHttpRoute, d as COMMERCE_EVENT_TYPES, e as CanonicalRequest, f as CommerceEventType, g as EventSink, h as ExecutionOutcome, H as HttpProtocolAdapter, i as ProtocolAdapterContext, j as isHttpProtocolAdapter } from './protocol-adapter-DZ8qkkAa.js';
 import { FastifyInstance } from 'fastify';
 import 'node:http';
 
@@ -286,7 +286,7 @@ interface ReceiptStore {
      * Receipts whose delivery did not succeed — `backendStatus` outside 2xx.
      *
      * A paid-but-undelivered purchase is the one row a merchant must notice:
-     * settlement is final and v0.1 has no refunds, so *seeing* it is the only
+     * settlement is final and this release has no refunds, so *seeing* it is the only
      * remedy available. Counted rather than listed for the same reason as
      * {@link countReceipts} — `listReceipts` is clamped, so counting by list
      * length silently saturates.
@@ -362,6 +362,10 @@ interface GatewayConfig {
             readonly enabled: boolean;
             readonly mountPath: string;
         };
+        readonly a2a: {
+            readonly enabled: boolean;
+            readonly mountPath: string;
+        };
     };
     /** Canonical resources, already normalised. */
     readonly resources: readonly CommerceResource[];
@@ -378,6 +382,7 @@ interface GatewayConfig {
             readonly maxTimeoutSeconds: number;
             readonly facilitator: X402FacilitatorConfig;
             readonly allowMainnet?: boolean;
+            readonly allowUnauthenticatedFacilitator?: boolean;
         };
     };
 }

package/dist/index.js

@@ -1,7 +1,7 @@
-import { resolveX402Deployment, resolveDeploymentMode, requireNetworkProfile } from './chunk-MQMKQGAB.js';
-import { CommerceError, PAYMENT_INPUT_FIELD, systemClock, NOOP_LOGGER, PACKAGE_VERSION, toCommerceError, DEFAULT_BACKEND_TIMEOUT_MS, toErrorEnvelope, isHttpProtocolAdapter, isCommerceError, PAYMENT_HEADER, toPaymentRequiredEnvelope, PAYMENT_REQUIRED_HEADER, PAYMENT_RESPONSE_HEADER } from './chunk-ASK67X56.js';
-export { COMMERCE_ERROR_CODES, COMMERCE_ERROR_HTTP_STATUS, COMMERCE_EVENT_TYPES, CommerceError, DEFAULT_BACKEND_TIMEOUT_MS, DELIVERY_SUMMARY_META_KEY, NOOP_LOGGER, PAYMENT_HEADER, PAYMENT_INPUT_FIELD, PAYMENT_REQUIRED_HEADER, PAYMENT_RESPONSE_HEADER, RETRYABLE_ERROR_CODES, isCommerceError, isHttpProtocolAdapter, isPaymentRequiredEnvelope, systemClock, toCommerceError, toDeliverySummary, toErrorEnvelope, toPaymentRequiredEnvelope } from './chunk-ASK67X56.js';
-import { promises, existsSync, mkdirSync, accessSync, constants, chmodSync } from 'fs';
+import { resolveX402Deployment, resolveDeploymentMode, requireNetworkProfile } from './chunk-M4I7I2UY.js';
+import { CommerceError, PAYMENT_INPUT_FIELD, systemClock, NOOP_LOGGER, PACKAGE_VERSION, toCommerceError, DEFAULT_BACKEND_TIMEOUT_MS, toErrorEnvelope, isHttpProtocolAdapter, isCommerceError, PAYMENT_HEADER, toPaymentRequiredEnvelope, PAYMENT_REQUIRED_HEADER, PAYMENT_RESPONSE_HEADER } from './chunk-64UZVJEO.js';
+export { COMMERCE_ERROR_CODES, COMMERCE_ERROR_HTTP_STATUS, COMMERCE_EVENT_TYPES, CommerceError, DEFAULT_BACKEND_TIMEOUT_MS, DELIVERY_SUMMARY_META_KEY, NOOP_LOGGER, PAYMENT_HEADER, PAYMENT_INPUT_FIELD, PAYMENT_REQUIRED_HEADER, PAYMENT_RESPONSE_HEADER, RETRYABLE_ERROR_CODES, isCommerceError, isHttpProtocolAdapter, isPaymentRequiredEnvelope, systemClock, toCommerceError, toDeliverySummary, toErrorEnvelope, toPaymentRequiredEnvelope } from './chunk-64UZVJEO.js';
+import { promises, existsSync, mkdirSync, accessSync, constants, closeSync, openSync, chmodSync } from 'fs';
 import * as path from 'path';
 import { dirname } from 'path';
 import { parse, YAMLError } from 'yaml';
@@ -14,6 +14,9 @@ import Database from 'better-sqlite3';
 
 // src/config/env.ts
 var PLACEHOLDER_PATTERN = /\$\{([A-Za-z_][A-Za-z0-9_]*)(:-([^}]*))?\}/g;
+var BRACE_TOKEN = /\$\{[^{}]*\}/g;
+var SUPPORTED_TOKEN = /^\$\{[A-Za-z_][A-Za-z0-9_]*(:-[^}]*)?\}$/;
+var NESTED_PLACEHOLDER = /\$\{[^{}]*\$\{/;
 function substituteEnv(value, env, path2 = "$") {
   if (typeof value === "string") {
     return substituteString(value, env, path2);
@@ -31,19 +34,26 @@ function substituteEnv(value, env, path2 = "$") {
   return value;
 }
 function substituteString(value, env, path2) {
-  const substituted = substituteOnce(value, env, path2);
-  PLACEHOLDER_PATTERN.lastIndex = 0;
-  if (PLACEHOLDER_PATTERN.test(substituted)) {
-    PLACEHOLDER_PATTERN.lastIndex = 0;
-    const residual = PLACEHOLDER_PATTERN.exec(substituted)?.[0] ?? "${\u2026}";
-    PLACEHOLDER_PATTERN.lastIndex = 0;
+  assertTemplateIsSupported(value, path2);
+  return substituteOnce(value, env, path2);
+}
+function assertTemplateIsSupported(value, path2) {
+  if (NESTED_PLACEHOLDER.test(value)) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Configuration value at "${path2}" nests placeholders (e.g. "\${A:-\${B}}"), which is not supported \u2014 the inner one is not resolved and its closing brace ends up in the value. Use a plain default, or set the variable.`,
+      { details: { path: path2 } }
+    );
+  }
+  BRACE_TOKEN.lastIndex = 0;
+  for (const [token] of value.matchAll(BRACE_TOKEN)) {
+    if (SUPPORTED_TOKEN.test(token)) continue;
     throw new CommerceError(
       "CONFIG_INVALID",
-      `Configuration value at "${path2}" still contains the unresolved placeholder "${residual}" after substitution \u2014 nested placeholders (e.g. "\${A:-\${B}}") are not supported. Use a plain default, or set the variable.`,
-      { details: { path: path2, residual } }
+      `Configuration value at "${path2}" contains "${token}", which is not a supported placeholder. Only "\${VAR}" and "\${VAR:-default}" are recognised; shell forms such as "\${VAR-default}", "\${VAR:=default}" and "\${VAR:?message}" would load as literal text.`,
+      { details: { path: path2, token } }
     );
   }
-  return substituted;
 }
 function substituteOnce(value, env, path2) {
   return value.replace(
@@ -1111,13 +1121,48 @@ var StorageSchema = z.object({
     path: z.string().min(1)
   }).strict()
 }).strict();
+var RESERVED_GATEWAY_PATHS = [
+  "/health",
+  "/ready",
+  "/.well-known/agent-commerce",
+  // Fixed by the A2A specification, so it is the adapter's to serve and never
+  // a configurable mount's to claim.
+  "/.well-known/agent-card.json",
+  "/api/resources",
+  "/api/resources/:id/invoke",
+  "/api/receipts",
+  "/api/events",
+  "/api/events/stream"
+];
+var MountPathSchema = z.string().min(1).refine((value) => value.startsWith("/"), {
+  message: 'must start with "/" \u2014 it is an absolute gateway path, e.g. "/mcp".'
+}).refine((value) => !/[:*?\s]/.test(value), {
+  message: 'must not contain ":", "*", "?" or whitespace \u2014 the mount is a literal path prefix, not a Fastify route pattern, and registers its own wildcard.'
+}).refine(
+  (value) => {
+    const base = value.replace(/\/+$/, "");
+    return !RESERVED_GATEWAY_PATHS.some(
+      (reserved) => reserved === base || reserved.startsWith(`${base}/`)
+    );
+  },
+  {
+    message: `must not collide with a route the gateway already serves (${RESERVED_GATEWAY_PATHS.join(", ")}); pick a dedicated prefix such as "/mcp".`
+  }
+);
 var ProtocolsSchema = z.object({
   http: z.object({ enabled: BooleanOrString }).strict(),
   mcp: z.object({
     enabled: BooleanOrString,
-    mountPath: z.string().min(1)
-  }).strict()
+    mountPath: MountPathSchema
+  }).strict(),
+  // Optional block: A2A is off unless an operator asks for it, and an
+  // existing config predating the adapter stays valid.
+  a2a: z.object({
+    enabled: BooleanOrString,
+    mountPath: MountPathSchema.optional()
+  }).strict().optional()
 }).strict();
+var DEFAULT_A2A_MOUNT_PATH = "/a2a";
 var BackendMethodSchema = z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]);
 var BackendHandlerSchema = z.object({
   type: z.literal("http"),
@@ -1152,7 +1197,14 @@ var ResourceEntrySchema = z.object({
 var ResourcesMapSchema = z.record(z.string().min(1), ResourceEntrySchema);
 var FacilitatorAuthSchema = z.discriminatedUnion("type", [
   z.object({ type: z.literal("none") }).strict(),
-  z.object({ type: z.literal("bearer"), token: z.string().min(1) }).strict()
+  z.object({ type: z.literal("bearer"), token: z.string().min(1) }).strict(),
+  // Coinbase Developer Platform. Needs the optional peer `@coinbase/x402`,
+  // which signs a fresh JWT per request; a static header cannot express it.
+  z.object({
+    type: z.literal("cdp"),
+    apiKeyId: z.string().min(1),
+    apiKeySecret: z.string().min(1)
+  }).strict()
 ]);
 var FacilitatorSchema = z.discriminatedUnion("mode", [
   z.object({
@@ -1181,7 +1233,9 @@ var X402Schema = z.object({
   maxTimeoutSeconds: NumberOrString,
   facilitator: FacilitatorSchema,
   /** Real funds. Never defaulted — see src/payments/x402/guardrails.ts. */
-  allowMainnet: BooleanOrString.optional()
+  allowMainnet: BooleanOrString.optional(),
+  /** Accepts a mainnet facilitator that takes no credential. Never defaulted. */
+  allowUnauthenticatedFacilitator: BooleanOrString.optional()
 }).strict();
 var PaymentsSchema = z.object({
   x402: X402Schema.optional()
@@ -1292,7 +1346,7 @@ function toBoolean(value, path2) {
     { details: { path: path2 } }
   );
 }
-var SUPPORTED_PROTOCOLS = /* @__PURE__ */ new Set(["http", "mcp"]);
+var SUPPORTED_PROTOCOLS = /* @__PURE__ */ new Set(["http", "mcp", "a2a"]);
 var SUPPORTED_PAYMENT_METHODS = /* @__PURE__ */ new Set(["x402"]);
 function normalise(raw) {
   const protocols = {
@@ -1300,8 +1354,13 @@ function normalise(raw) {
     mcp: {
       enabled: toBoolean(raw.protocols.mcp.enabled, "protocols.mcp.enabled"),
       mountPath: raw.protocols.mcp.mountPath
+    },
+    a2a: {
+      enabled: toBoolean(raw.protocols.a2a?.enabled ?? false, "protocols.a2a.enabled"),
+      mountPath: raw.protocols.a2a?.mountPath ?? DEFAULT_A2A_MOUNT_PATH
     }
   };
+  validateMountPaths(protocols);
   const x402Raw = raw.payments.x402;
   const facilitator = x402Raw === void 0 ? void 0 : x402Raw.facilitator.mode === "local" ? { mode: "local", signerPrivateKey: x402Raw.facilitator.signerPrivateKey } : {
     mode: "remote",
@@ -1328,7 +1387,13 @@ function normalise(raw) {
       }
     ),
     facilitator,
-    ...x402Raw.allowMainnet !== void 0 ? { allowMainnet: toBoolean(x402Raw.allowMainnet, "payments.x402.allowMainnet") } : {}
+    ...x402Raw.allowMainnet !== void 0 ? { allowMainnet: toBoolean(x402Raw.allowMainnet, "payments.x402.allowMainnet") } : {},
+    ...x402Raw.allowUnauthenticatedFacilitator !== void 0 ? {
+      allowUnauthenticatedFacilitator: toBoolean(
+        x402Raw.allowUnauthenticatedFacilitator,
+        "payments.x402.allowUnauthenticatedFacilitator"
+      )
+    } : {}
   } : void 0;
   if (x402) {
     validateAddress("payments.x402.payTo", x402.payTo);
@@ -1337,8 +1402,11 @@ function normalise(raw) {
       network: x402.network,
       payTo: x402.payTo,
       asset: x402.asset,
+      assetName: x402.assetName,
+      assetVersion: x402.assetVersion,
       facilitator: x402.facilitator,
-      ...x402.allowMainnet !== void 0 ? { allowMainnet: x402.allowMainnet } : {}
+      ...x402.allowMainnet !== void 0 ? { allowMainnet: x402.allowMainnet } : {},
+      ...x402.allowUnauthenticatedFacilitator !== void 0 ? { allowUnauthenticatedFacilitator: x402.allowUnauthenticatedFacilitator } : {}
     });
   }
   const resources = Object.entries(raw.resources).map(
@@ -1367,6 +1435,25 @@ function normalise(raw) {
     }
   };
 }
+function validateMountPaths(protocols) {
+  const mounts = [
+    ["mcp", protocols.mcp],
+    ["a2a", protocols.a2a]
+  ].filter(([, p]) => p.enabled);
+  for (const [index, [nameA, a]] of mounts.entries()) {
+    for (const [nameB, b] of mounts.slice(index + 1)) {
+      const baseA = a.mountPath.replace(/\/+$/, "");
+      const baseB = b.mountPath.replace(/\/+$/, "");
+      if (baseA === baseB || baseA.startsWith(`${baseB}/`) || baseB.startsWith(`${baseA}/`)) {
+        throw new CommerceError(
+          "CONFIG_INVALID",
+          `protocols.${nameA}.mountPath ("${a.mountPath}") collides with protocols.${nameB}.mountPath ("${b.mountPath}") \u2014 each mount registers a wildcard, so overlapping prefixes cannot both be served`,
+          { details: { path: `protocols.${nameA}.mountPath` } }
+        );
+      }
+    }
+  }
+}
 function normaliseResource(id, entry, protocols, x402) {
   if (entry.input !== void 0) validateResourceSchemaKeywords(id, "input", entry.input);
   const inputProperties = entry.input?.["properties"];
@@ -1387,7 +1474,7 @@ function normaliseResource(id, entry, protocols, x402) {
       const hint = protocol === "ucp" ? " (UCP is planned, not supported in this release)" : "";
       throw new CommerceError(
         "CONFIG_INVALID",
-        `Resource "${id}" exposes unsupported protocol "${protocol}"${hint}. Supported: http, mcp.`,
+        `Resource "${id}" exposes unsupported protocol "${protocol}"${hint}. Supported: http, mcp, a2a.`,
         { details: { path: `resources.${id}.expose`, resourceId: id, protocol } }
       );
     }
@@ -1408,6 +1495,13 @@ function normaliseResource(id, entry, protocols, x402) {
       );
     }
   }
+  if (entry.expose.includes("a2a") && !protocols.a2a.enabled) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Resource "${id}" is exposed via "a2a" but protocols.a2a.enabled is false`,
+      { details: { path: `resources.${id}.expose`, resourceId: id } }
+    );
+  }
   if (entry.expose.includes("http") && !protocols.http.enabled) {
     throw new CommerceError(
       "CONFIG_INVALID",
@@ -1497,6 +1591,10 @@ function defaultClosedObjectSchema(schema) {
   if (isPlainObject4(items)) {
     result["items"] = defaultClosedObjectSchema(items);
   }
+  const additional = schema["additionalProperties"];
+  if (isPlainObject4(additional)) {
+    result["additionalProperties"] = defaultClosedObjectSchema(additional);
+  }
   return result;
 }
 var EMPTY_CLOSED_OBJECT_SCHEMA = {
@@ -1570,6 +1668,10 @@ function validateResourceSchemaKeywords(id, path2, schema) {
       if (isPlainObject4(sub)) validateResourceSchemaKeywords(id, `${path2}.properties.${key}`, sub);
     }
   }
+  const additional = schema["additionalProperties"];
+  if (isPlainObject4(additional)) {
+    validateResourceSchemaKeywords(id, `${path2}.additionalProperties`, additional);
+  }
   const items = schema["items"];
   if (isPlainObject4(items)) {
     validateResourceSchemaKeywords(id, `${path2}.items`, items);
@@ -1619,6 +1721,23 @@ function validatePathParametersDeclared(id, url, input) {
   }
   const params = extractPathParameterNames(url);
   if (params.length === 0) return;
+  const firstBrace = url.indexOf("{");
+  if (firstBrace !== -1) {
+    const prefix = url.slice(0, firstBrace);
+    let origin;
+    try {
+      const parsedPrefix = new URL(prefix);
+      origin = parsedPrefix.hostname === "" ? void 0 : parsedPrefix.origin;
+    } catch {
+    }
+    if (origin === void 0 || !prefix.startsWith(`${origin}/`)) {
+      throw new CommerceError(
+        "CONFIG_INVALID",
+        `Resource "${id}" has a backend.url parameter before the end of the host ("${url}"). A caller-supplied value would choose which host the gateway calls, which is request forgery with the gateway's own network position. Parameters are supported inside the path and query only`,
+        { details: { path: `resources.${id}.backend.url`, resourceId: id } }
+      );
+    }
+  }
   const propertiesRaw = input?.["properties"];
   const properties = isPlainObject4(propertiesRaw) ? propertiesRaw : {};
   const requiredRaw = input?.["required"];
@@ -1899,6 +2018,7 @@ function hashToken(value) {
 // src/gateway/adapters.ts
 var MOUNT_BODY_LIMIT_BYTES = 256 * 1024;
 async function startAndMountAdapters(options) {
+  assertNoRouteConflicts(options.adapters);
   const runtimes = [];
   for (const adapter of options.adapters) {
     const adapterLogger = options.logger.child({ adapter: adapter.name });
@@ -1924,11 +2044,51 @@ async function startAndMountAdapters(options) {
   }
   return runtimes;
 }
+function routeClaims(adapters) {
+  const claims = [];
+  for (const adapter of adapters) {
+    if (!isHttpProtocolAdapter(adapter)) continue;
+    claims.push({
+      adapter: adapter.name,
+      path: adapter.mountPath.replace(/\/+$/, ""),
+      wildcard: true,
+      method: "ALL"
+    });
+    for (const route of adapter.additionalHttpRoutes ?? []) {
+      claims.push({
+        adapter: adapter.name,
+        path: route.path.replace(/\/+$/, ""),
+        wildcard: false,
+        method: route.method
+      });
+    }
+  }
+  return claims;
+}
+function claimsCollide(a, b) {
+  if (a.wildcard && (b.path === a.path || b.path.startsWith(`${a.path}/`))) return true;
+  if (b.wildcard && a.path.startsWith(`${b.path}/`)) return true;
+  return a.path === b.path && (a.method === b.method || a.method === "ALL" || b.method === "ALL");
+}
+function assertNoRouteConflicts(adapters) {
+  const claims = routeClaims(adapters);
+  for (const [index, a] of claims.entries()) {
+    for (const b of claims.slice(index + 1)) {
+      if (a.adapter === b.adapter || !claimsCollide(a, b)) continue;
+      throw new CommerceError(
+        "CONFIG_INVALID",
+        `Protocol adapters "${a.adapter}" and "${b.adapter}" both claim the HTTP path "${b.path}"; each adapter path must be served by exactly one adapter`,
+        { details: { adapters: [a.adapter, b.adapter], path: b.path } }
+      );
+    }
+  }
+}
 var MOUNT_MAX_CONCURRENT_REQUESTS = 20;
 var MOUNT_BUSY_RETRY_AFTER_SECONDS = 1;
 function mountHttpAdapter(server, adapter, logger) {
   const mountPath = adapter.mountPath;
   const wildcard = mountPath.endsWith("/") ? `${mountPath}*` : `${mountPath}/*`;
+  const additionalRoutes = adapter.additionalHttpRoutes ?? [];
   let inFlight = 0;
   void server.register(async (instance) => {
     instance.addContentTypeParser(
@@ -1940,7 +2100,7 @@ function mountHttpAdapter(server, adapter, logger) {
     instance.addContentTypeParser("*", (_request, _payload, done) => {
       done(null);
     });
-    const handler = async (request, reply) => {
+    const makeHandler = (handleHttp) => async (request, reply) => {
       if (inFlight >= MOUNT_MAX_CONCURRENT_REQUESTS) {
         const error = new CommerceError(
           "GATEWAY_BUSY",
@@ -1958,7 +2118,7 @@ function mountHttpAdapter(server, adapter, logger) {
           logger
         );
         try {
-          await adapter.handleHttp(request.raw, reply.raw);
+          await handleHttp(request.raw, reply.raw);
         } catch (error) {
           logger.error({ err: describeError3(error) }, "Protocol adapter request handler threw");
           if (!reply.raw.headersSent) {
@@ -1972,8 +2132,16 @@ function mountHttpAdapter(server, adapter, logger) {
         inFlight -= 1;
       }
     };
-    instance.all(mountPath, handler);
-    instance.all(wildcard, handler);
+    const mountHandler = makeHandler((req, res) => adapter.handleHttp(req, res));
+    instance.all(mountPath, mountHandler);
+    instance.all(wildcard, mountHandler);
+    for (const route of additionalRoutes) {
+      instance.route({
+        method: route.method,
+        url: route.path,
+        handler: makeHandler((req, res) => route.handleHttp(req, res))
+      });
+    }
   });
 }
 function enforceMountBodyLimit(req, res, maxBytes, logger) {
@@ -2163,13 +2331,17 @@ function createReadinessProbe(options, ttlMs = READINESS_TTL_MS) {
 }
 
 // src/gateway/well-known.ts
-var GATEWAY_SUPPORTED_SPEC = "agent-commerce/v0.2.0-beta";
+var GATEWAY_SUPPORTED_SPEC = "agent-commerce/v1.0.0";
+function publicHealth(health) {
+  const { detail: _detail, ...rest } = health;
+  return rest;
+}
 async function buildWellKnownDocument(options) {
   const adapters = await Promise.all(
-    options.adapterRuntimes.map(async (runtime) => ({
-      ...runtime.adapter.descriptor,
-      health: await getAdapterHealth(runtime, options.clock)
-    }))
+    options.adapterRuntimes.map(async (runtime) => {
+      const health = await getAdapterHealth(runtime, options.clock);
+      return { ...runtime.adapter.descriptor, health: publicHealth(health) };
+    })
   );
   const x402 = options.config.payments.x402;
   return {
@@ -2724,6 +2896,12 @@ function createSqliteReceiptStore(options) {
       );
     }
   }
+  if (isFileBacked) {
+    try {
+      closeSync(openSync(path2, "a", 384));
+    } catch {
+    }
+  }
   const db = new Database(path2);
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");