@agentcash/router 1.12.0 → 1.14.0

package/dist/index.js

@@ -20,7 +20,7 @@ var init_constants = __esm({
     BASE_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
     BASE_USDC_DECIMALS = 6;
     ZERO_EVM_ADDRESS = "0x0000000000000000000000000000000000000000";
-    DEFAULT_SOLANA_FACILITATOR_URL = "https://facilitator.corbits.dev";
+    DEFAULT_SOLANA_FACILITATOR_URL = "https://facilitator.payai.network";
     DEFAULT_TEMPO_RPC_URL = "https://rpc.tempo.xyz";
   }
 });
@@ -129,31 +129,64 @@ function buildSolanaExactOptions(accepts, price) {
 function hasSolanaAccepts(accepts) {
   return accepts.some((accept) => isSolanaNetwork(accept.network));
 }
-async function enrichRequirementsWithFacilitatorAccepts(facilitator, resource, requirements) {
+function facilitatorBaseUrl(facilitator) {
   if (!facilitator.url) {
-    throw new Error(`Facilitator for ${facilitator.network} is missing a URL for /accepts`);
+    throw new Error(`Facilitator for ${facilitator.network} is missing a URL`);
   }
-  const authHeaders = await getAcceptsHeadersForFacilitator(facilitator);
-  const response = await fetch(`${facilitator.url.replace(/\/+$/, "")}/accepts`, {
-    method: "POST",
-    headers: {
-      ...authHeaders,
-      "content-type": "application/json"
-    },
-    body: JSON.stringify({
-      x402Version: 2,
-      resource,
-      accepts: requirements
-    })
+  return facilitator.url.replace(/\/+$/, "");
+}
+function matchesSupportedKind(requirement, kind) {
+  const scheme = requirement.scheme ?? "exact";
+  return kind.network === requirement.network && (kind.scheme ?? "exact") === scheme;
+}
+async function fetchFacilitatorSupported(facilitator) {
+  const authHeaders = await getSupportedHeadersForFacilitator(facilitator);
+  const response = await fetch(`${facilitatorBaseUrl(facilitator)}/supported`, {
+    headers: authHeaders
   });
   if (!response.ok) {
-    throw new Error(`Facilitator /accepts failed with status ${response.status}`);
+    throw new Error(`Facilitator /supported failed with status ${response.status}`);
   }
   const body = await response.json();
-  if (!Array.isArray(body.accepts)) {
-    throw new Error("Facilitator /accepts response did not include accepts");
+  if (!Array.isArray(body.kinds)) {
+    throw new Error("Facilitator /supported response did not include kinds");
+  }
+  return body.kinds;
+}
+function enrichRequirementFromKind(requirement, kinds) {
+  const kind = kinds.find((candidate) => matchesSupportedKind(requirement, candidate));
+  if (!kind) {
+    throw new Error(
+      `Facilitator /supported has no kind for ${requirement.scheme} on ${requirement.network}`
+    );
+  }
+  const feePayer = kind.extra?.feePayer;
+  if (!feePayer) {
+    throw new Error(
+      `Facilitator /supported kind for ${requirement.network} is missing extra.feePayer`
+    );
   }
-  return body.accepts;
+  const requirementExtra = requirement.extra ?? {};
+  const kindExtra = kind.extra ?? {};
+  const requirementFeatures = requirementExtra.features ?? {};
+  const kindFeatures = kindExtra.features ?? {};
+  return {
+    ...requirement,
+    ...kind.asset && !requirement.asset ? { asset: kind.asset } : {},
+    extra: {
+      ...requirementExtra,
+      ...kindExtra,
+      features: {
+        ...requirementFeatures,
+        ...kindFeatures,
+        xSettlementAccountSupported: true
+      }
+    }
+  };
+}
+async function enrichRequirementsFromFacilitatorSupported(facilitator, requirements) {
+  const kinds = await fetchFacilitatorSupported(facilitator);
+  return requirements.map((requirement) => enrichRequirementFromKind(requirement, kinds));
 }
 function isSolanaRequirement(requirement) {
   return isSolanaNetwork(requirement.network);
@@ -210,10 +243,7 @@ function getFacilitatorForRequirement(facilitatorsByNetwork, requirement) {
 function sameResolvedX402Facilitator(a, b) {
   return sameFacilitatorConfig(a.config, b.config);
 }
-async function getAcceptsHeadersForFacilitator(facilitator) {
-  if (facilitator.config.createAcceptsHeaders) {
-    return facilitator.config.createAcceptsHeaders();
-  }
+async function getSupportedHeadersForFacilitator(facilitator) {
   if (facilitator.config.createAuthHeaders) {
     const headers = await facilitator.config.createAuthHeaders();
     return headers.supported;
@@ -235,7 +265,7 @@ function getNetworkFamily(network) {
   return null;
 }
 function sameFacilitatorConfig(a, b) {
-  return a.url === b.url && a.createAuthHeaders === b.createAuthHeaders && a.createAcceptsHeaders === b.createAcceptsHeaders;
+  return a.url === b.url && a.createAuthHeaders === b.createAuthHeaders;
 }
 var init_facilitators = __esm({
   "src/protocols/x402/facilitators.ts"() {
@@ -835,6 +865,13 @@ var HttpError = class extends Error {
     this.name = "HttpError";
   }
 };
+var RouteDefinitionError = class extends Error {
+  constructor(route, detail) {
+    super(`route '${route}': ${detail}`);
+    this.route = route;
+    this.name = "RouteDefinitionError";
+  }
+};
 
 // src/auth/agent-identity.ts
 var PROTOCOL_VERSION = 1;
@@ -1362,6 +1399,23 @@ function multiplyDecimal(decimal, factor) {
   return fracPart ? `${intPart}.${fracPart}` : intPart;
 }
 
+// src/protocols/detect.ts
+function hasX402Payment(request) {
+  return Boolean(
+    request.headers.get(HEADERS.X402_PAYMENT_SIGNATURE) ?? request.headers.get(HEADERS.X402_PAYMENT_LEGACY)
+  );
+}
+function hasMppPayment(request) {
+  const auth = request.headers.get(HEADERS.AUTHORIZATION);
+  return Boolean(auth && auth.startsWith(AUTH_SCHEME.MPP_PAYMENT));
+}
+function detectProtocol(request) {
+  if (hasX402Payment(request)) return "x402";
+  if (hasMppPayment(request)) return "mpp";
+  if (request.headers.get(HEADERS.SIWX)) return "siwx";
+  return null;
+}
+
 // src/protocols/mpp/credential.ts
 import { Credential } from "mppx";
 import { getAddress, isAddress } from "viem";
@@ -1728,10 +1782,7 @@ function settleHashMode(args) {
 // src/protocols/mpp/strategy.ts
 var mppStrategy = {
   protocol: "mpp",
-  detects(request) {
-    const auth = request.headers.get(HEADERS.AUTHORIZATION);
-    return Boolean(auth && auth.startsWith(AUTH_SCHEME.MPP_PAYMENT));
-  },
+  detects: hasMppPayment,
   preflight(request, _routeEntry) {
     const info = readMppCredential(request);
     if (!info?.sessionAction) return null;
@@ -1936,15 +1987,14 @@ async function buildChallengeRequirements(server, request, price, accepts, resou
 function needsFacilitatorEnrichment(accepts) {
   return hasSolanaAccepts(accepts);
 }
-async function enrichGroup(group, resource) {
-  const accepted = await enrichRequirementsWithFacilitatorAccepts(
+async function enrichGroup(group) {
+  const accepted = await enrichRequirementsFromFacilitatorSupported(
     group.facilitator,
-    resource,
     group.items.map(({ requirement }) => requirement)
   );
   if (accepted.length !== group.items.length) {
     throw new Error(
-      `Facilitator /accepts returned ${accepted.length} requirements for ${group.items.length} inputs on ${group.facilitator.url ?? group.facilitator.network}`
+      `Facilitator /supported enrichment returned ${accepted.length} requirements for ${group.items.length} inputs on ${group.facilitator.url ?? group.facilitator.network}`
     );
   }
   return accepted;
@@ -1955,13 +2005,13 @@ async function enrichChallengeRequirements(requirements, resource, facilitatorsB
   const results = await Promise.all(
     groups.map(async (group) => {
       try {
-        return { success: true, group, accepted: await enrichGroup(group, resource) };
+        return { success: true, group, accepted: await enrichGroup(group) };
       } catch (err) {
         const label = group.facilitator.url ?? group.facilitator.network;
         const reason = err instanceof Error ? err.message : String(err);
         report?.(
           "warn",
-          `${label} /accepts failed, dropping ${group.items.length} requirement(s): ${reason}`
+          `${label} /supported enrichment failed, dropping ${group.items.length} requirement(s): ${reason}`
         );
         return { success: false, group };
       }
@@ -2166,11 +2216,7 @@ function formatVerifyFailureMessage(failure) {
 }
 var x402Strategy = {
   protocol: "x402",
-  detects(request) {
-    return Boolean(
-      request.headers.get(HEADERS.X402_PAYMENT_SIGNATURE) ?? request.headers.get(HEADERS.X402_PAYMENT_LEGACY)
-    );
-  },
+  detects: hasX402Payment,
   verify: (args) => verifyX402(args),
   settle: (args) => settleX402(args),
   buildChallenge: (args) => buildX402ChallengeContribution(args)
@@ -2317,21 +2363,6 @@ function getAllowedStrategies(allowed) {
   return allowed.map((name) => STRATEGIES[name]);
 }
 
-// src/protocols/detect.ts
-function detectProtocol(request) {
-  if (request.headers.get(HEADERS.X402_PAYMENT_SIGNATURE) ?? request.headers.get(HEADERS.X402_PAYMENT_LEGACY)) {
-    return "x402";
-  }
-  const auth = request.headers.get(HEADERS.AUTHORIZATION);
-  if (auth && auth.startsWith(AUTH_SCHEME.MPP_PAYMENT)) {
-    return "mpp";
-  }
-  if (request.headers.get(HEADERS.SIWX)) {
-    return "siwx";
-  }
-  return null;
-}
-
 // src/pipeline/flows/api-key-only.ts
 async function runApiKeyOnlyFlow(ctx) {
   if (!ctx.routeEntry.apiKeyResolver) {
@@ -2654,6 +2685,61 @@ async function buildChallengeResponse(ctx, pricing, body, failure) {
   return response;
 }
 
+// src/pipeline/flows/paid-preamble.ts
+async function runPaidPreamble(ctx) {
+  const { request, routeEntry, deps, report } = ctx;
+  const apiKeyGate = await runApiKeyGate(ctx);
+  if (!apiKeyGate.ok) return { done: true, response: apiKeyGate.response };
+  const { account } = apiKeyGate;
+  const pricing = selectPricing(routeEntry.pricing, {
+    alert: report,
+    maxPrice: routeEntry.maxPrice,
+    minPrice: routeEntry.minPrice,
+    route: routeEntry.key
+  });
+  const incomingStrategy = selectIncomingStrategy(request, routeEntry.protocols);
+  const earlyResolution = await resolveEarlyBody({ ctx, pricing, incomingStrategy });
+  if (!earlyResolution.ok) return { done: true, response: earlyResolution.response };
+  const { earlyBody } = earlyResolution;
+  const siwxFastPath = await trySiwxFastPath(ctx, account);
+  if (siwxFastPath) return { done: true, response: siwxFastPath };
+  if (!incomingStrategy) {
+    const initError = protocolInitError(routeEntry, deps);
+    if (initError) return { done: true, response: fail(ctx, 500, initError) };
+    return { done: true, response: await buildChallengeResponse(ctx, pricing, earlyBody) };
+  }
+  return { done: false, account, pricing, incomingStrategy, earlyBody };
+}
+async function runPaidVerify(args) {
+  const { ctx, strategy, pricing, parsedBody, price } = args;
+  const { request, routeEntry, deps, report } = ctx;
+  const verifyOutcome = await strategy.verify({
+    request,
+    body: parsedBody,
+    price,
+    routeEntry,
+    deps,
+    report
+  });
+  if (verifyOutcome.ok === false) {
+    if (verifyOutcome.kind === "config") {
+      return { ok: false, response: fail(ctx, 500, verifyOutcome.message, parsedBody) };
+    }
+    return {
+      ok: false,
+      response: await buildChallengeResponse(ctx, pricing, parsedBody, verifyOutcome.failure)
+    };
+  }
+  ctx.pluginCtx.setVerifiedWallet(verifyOutcome.wallet);
+  firePaymentVerified(ctx, {
+    protocol: strategy.protocol,
+    payer: verifyOutcome.wallet,
+    amount: price,
+    network: verifyOutcome.payment.network
+  });
+  return { ok: true, verifyOutcome };
+}
+
 // src/pipeline/flows/dynamic/dynamic-body-and-price.ts
 async function resolveDynamicBodyAndPrice(args) {
   const { ctx, pricing, skipBody } = args;
@@ -3020,27 +3106,10 @@ async function runDynamicStreamFlow(args) {
 
 // src/pipeline/flows/dynamic/dynamic-paid.ts
 async function runDynamicPaidFlow(ctx) {
-  const { request, routeEntry, deps, report } = ctx;
-  const apiKeyGate = await runApiKeyGate(ctx);
-  if (!apiKeyGate.ok) return apiKeyGate.response;
-  const { account } = apiKeyGate;
-  const pricing = selectPricing(routeEntry.pricing, {
-    alert: report,
-    maxPrice: routeEntry.maxPrice,
-    minPrice: routeEntry.minPrice,
-    route: routeEntry.key
-  });
-  const incomingStrategy = selectIncomingStrategy(request, routeEntry.protocols);
-  const earlyResolution = await resolveEarlyBody({ ctx, pricing, incomingStrategy });
-  if (!earlyResolution.ok) return earlyResolution.response;
-  const { earlyBody } = earlyResolution;
-  const siwxFastPath = await trySiwxFastPath(ctx, account);
-  if (siwxFastPath) return siwxFastPath;
-  if (!incomingStrategy) {
-    const initError = protocolInitError(routeEntry, deps);
-    if (initError) return fail(ctx, 500, initError);
-    return buildChallengeResponse(ctx, pricing, earlyBody);
-  }
+  const { request, routeEntry } = ctx;
+  const preamble = await runPaidPreamble(ctx);
+  if (preamble.done) return preamble.response;
+  const { account, pricing, incomingStrategy } = preamble;
   const { skipBody, skipHandler } = resolveDynamicPreflight(incomingStrategy, request, routeEntry);
   if (skipHandler) {
     return runDynamicChannelMgmtFlow({
@@ -3054,27 +3123,15 @@ async function runDynamicPaidFlow(ctx) {
   const bodyAndPrice = await resolveDynamicBodyAndPrice({ ctx, pricing, skipBody });
   if (!bodyAndPrice.ok) return bodyAndPrice.response;
   const { parsedBody, price } = bodyAndPrice;
-  const verifyOutcome = await incomingStrategy.verify({
-    request,
-    body: parsedBody,
-    price,
-    routeEntry,
-    deps,
-    report
-  });
-  if (verifyOutcome.ok === false) {
-    if (verifyOutcome.kind === "config") {
-      return fail(ctx, 500, verifyOutcome.message, parsedBody);
-    }
-    return buildChallengeResponse(ctx, pricing, parsedBody, verifyOutcome.failure);
-  }
-  ctx.pluginCtx.setVerifiedWallet(verifyOutcome.wallet);
-  firePaymentVerified(ctx, {
-    protocol: incomingStrategy.protocol,
-    payer: verifyOutcome.wallet,
-    amount: price,
-    network: verifyOutcome.payment.network
+  const verify = await runPaidVerify({
+    ctx,
+    strategy: incomingStrategy,
+    pricing,
+    parsedBody,
+    price
   });
+  if (!verify.ok) return verify.response;
+  const { verifyOutcome } = verify;
   const result = await invokeDynamic(ctx, verifyOutcome, account, parsedBody);
   switch (result.kind) {
     case "stream":
@@ -3206,51 +3263,21 @@ function failureFromCause2(cause) {
 
 // src/pipeline/flows/static/static-paid.ts
 async function runStaticPaidFlow(ctx) {
-  const { request, routeEntry, deps, report } = ctx;
-  const apiKeyGate = await runApiKeyGate(ctx);
-  if (!apiKeyGate.ok) return apiKeyGate.response;
-  const { account } = apiKeyGate;
-  const pricing = selectPricing(routeEntry.pricing, {
-    alert: report,
-    maxPrice: routeEntry.maxPrice,
-    minPrice: routeEntry.minPrice,
-    route: routeEntry.key
-  });
-  const incomingStrategy = selectIncomingStrategy(request, routeEntry.protocols);
-  const earlyResolution = await resolveEarlyBody({ ctx, pricing, incomingStrategy });
-  if (!earlyResolution.ok) return earlyResolution.response;
-  const { earlyBody } = earlyResolution;
-  const siwxFastPath = await trySiwxFastPath(ctx, account);
-  if (siwxFastPath) return siwxFastPath;
-  if (!incomingStrategy) {
-    const initError = protocolInitError(routeEntry, deps);
-    if (initError) return fail(ctx, 500, initError);
-    return buildChallengeResponse(ctx, pricing, earlyBody);
-  }
+  const preamble = await runPaidPreamble(ctx);
+  if (preamble.done) return preamble.response;
+  const { account, pricing, incomingStrategy } = preamble;
   const bodyAndPrice = await resolveStaticBodyAndPrice({ ctx, pricing });
   if (!bodyAndPrice.ok) return bodyAndPrice.response;
   const { parsedBody, price } = bodyAndPrice;
-  const verifyOutcome = await incomingStrategy.verify({
-    request,
-    body: parsedBody,
-    price,
-    routeEntry,
-    deps,
-    report
-  });
-  if (verifyOutcome.ok === false) {
-    if (verifyOutcome.kind === "config") {
-      return fail(ctx, 500, verifyOutcome.message, parsedBody);
-    }
-    return buildChallengeResponse(ctx, pricing, parsedBody, verifyOutcome.failure);
-  }
-  ctx.pluginCtx.setVerifiedWallet(verifyOutcome.wallet);
-  firePaymentVerified(ctx, {
-    protocol: incomingStrategy.protocol,
-    payer: verifyOutcome.wallet,
-    amount: price,
-    network: verifyOutcome.payment.network
+  const verify = await runPaidVerify({
+    ctx,
+    strategy: incomingStrategy,
+    pricing,
+    parsedBody,
+    price
   });
+  if (!verify.ok) return verify.response;
+  const { verifyOutcome } = verify;
   const result = await invokePaidStatic(
     ctx,
     verifyOutcome.wallet,
@@ -3742,55 +3769,35 @@ var RouteBuilder = class _RouteBuilder {
     return next;
   }
   paid(arg, options) {
-    return this.applyPaid(normalizePaidArg(this.#s.key, arg, options), "paid");
+    const self = this;
+    return self.applyPaid(normalizePaidArg(self.#s.key, arg, options), "paid");
   }
-  /**
-   * x402-only handler-computed billing. The handler receives `charge(amount)`
-   * and the request settles once for the accumulated total, capped at
-   * `maxPrice`. Requires an `'upto'` accept on at least one configured network.
-   * Pass a bare string as sugar for `{ maxPrice }`.
-   *
-   * @example
-   * ```ts
-   * router.route('llm')
-   *   .upTo('0.05')
-   *   .body(schema)
-   *   .handler(async ({ body, charge }) => { await charge('0.001'); ... });
-   * ```
-   */
   upTo(arg) {
-    return this.applyPaid(normalizeUpToArg(this.#s.key, arg), "upTo");
+    const self = this;
+    return self.applyPaid(normalizeUpToArg(self.#s.key, arg), "upTo");
   }
-  /**
-   * MPP-only per-tick billing. `.handler()` bills exactly `tickCost`;
-   * `.stream()` calls `charge()` (no-arg) per yield, settling per tick up to
-   * `maxPrice`. Requires `RouterConfig.mpp.session`.
-   *
-   * @example
-   * ```ts
-   * router.route('llm/stream')
-   *   .metered({ tickCost: '0.0001', maxPrice: '0.05', unitType: 'token' })
-   *   .stream(async function* ({ charge }) { await charge(); yield 'hi'; });
-   * ```
-   */
   metered(options) {
-    return this.applyPaid(normalizeMeteredArg(this.#s.key, options), "metered");
+    const self = this;
+    return self.applyPaid(normalizeMeteredArg(self.#s.key, options), "metered");
   }
   applyPaid(normalized, method) {
     const { pricing, resolvedOptions, billing, tickCost, unitType, maxPrice } = normalized;
     if (this.#s.authMode === "unprotected") {
-      throw new Error(
-        `route '${this.#s.key}': Cannot combine .unprotected() and .${method}() on the same route.`
+      throw new RouteDefinitionError(
+        this.#s.key,
+        `Cannot combine .unprotected() and .${method}() on the same route.`
       );
     }
     if (this.#s.pricing !== void 0) {
-      throw new Error(
-        `route '${this.#s.key}': Cannot combine .paid(), .upTo(), and .metered() \u2014 pick one pricing mode.`
+      throw new RouteDefinitionError(
+        this.#s.key,
+        `Cannot combine .paid(), .upTo(), and .metered() \u2014 pick one pricing mode.`
       );
     }
     if (this.#s.siwxEnabled && billing === "metered") {
-      throw new Error(
-        `route '${this.#s.key}': Cannot combine .siwx() and .metered() \u2014 per-tick MPP billing has no entitlement model. Use .paid() or .upTo() with .siwx(), or drop .siwx() for metered routes.`
+      throw new RouteDefinitionError(
+        this.#s.key,
+        `Cannot combine .siwx() and .metered() \u2014 per-tick MPP billing has no entitlement model. Use .paid() or .upTo() with .siwx(), or drop .siwx() for metered routes.`
       );
     }
     const next = this.fork();
@@ -3798,15 +3805,17 @@ var RouteBuilder = class _RouteBuilder {
     next.#s.pricing = pricing;
     if (billing === "upto") {
       if (resolvedOptions.protocols?.some((p) => p !== "x402")) {
-        throw new Error(
-          `route '${this.#s.key}': .upTo() is x402-only \u2014 remove the conflicting protocols override.`
+        throw new RouteDefinitionError(
+          this.#s.key,
+          `.upTo() is x402-only \u2014 remove the conflicting protocols override.`
         );
       }
       next.#s.protocols = ["x402"];
     } else if (billing === "metered") {
       if (resolvedOptions.protocols?.some((p) => p !== "mpp")) {
-        throw new Error(
-          `route '${this.#s.key}': .metered() is MPP-only \u2014 remove the conflicting protocols override.`
+        throw new RouteDefinitionError(
+          this.#s.key,
+          `.metered() is MPP-only \u2014 remove the conflicting protocols override.`
         );
       }
       next.#s.protocols = ["mpp"];
@@ -3830,73 +3839,69 @@ var RouteBuilder = class _RouteBuilder {
     if (typeof pricing === "object" && "tiers" in pricing) {
       for (const [tierKey, tierConfig] of Object.entries(pricing.tiers)) {
         if (!tierKey) {
-          throw new Error(`route '${this.#s.key}': tier key cannot be empty`);
+          throw new RouteDefinitionError(this.#s.key, `tier key cannot be empty`);
         }
         if (!isPositiveDecimal(tierConfig.price)) {
-          throw new Error(
-            `route '${this.#s.key}': tier '${tierKey}' price '${tierConfig.price}' must be a positive decimal string`
+          throw new RouteDefinitionError(
+            this.#s.key,
+            `tier '${tierKey}' price '${tierConfig.price}' must be a positive decimal string`
           );
         }
       }
     }
     if (billing === "exact" && typeof pricing === "string" && !isPositiveDecimal(pricing)) {
-      throw new Error(
-        `route '${this.#s.key}': price '${pricing}' must be a positive decimal string`
+      throw new RouteDefinitionError(
+        this.#s.key,
+        `price '${pricing}' must be a positive decimal string`
       );
     }
     if (typeof pricing === "function" && next.#s.maxPrice === void 0) {
-      throw new Error(
-        `route '${this.#s.key}': dynamic pricing requires maxPrice \u2014 without it, bare probes would advertise a $0 challenge`
+      throw new RouteDefinitionError(
+        this.#s.key,
+        `dynamic pricing requires maxPrice \u2014 without it, bare probes would advertise a $0 challenge`
       );
     }
     if (next.#s.maxPrice !== void 0 && !isPositiveDecimal(next.#s.maxPrice)) {
-      throw new Error(
-        `route '${this.#s.key}': maxPrice '${next.#s.maxPrice}' must be a positive decimal string`
+      throw new RouteDefinitionError(
+        this.#s.key,
+        `maxPrice '${next.#s.maxPrice}' must be a positive decimal string`
       );
     }
     if (next.#s.minPrice !== void 0 && !isPositiveDecimal(next.#s.minPrice)) {
-      throw new Error(
-        `route '${this.#s.key}': minPrice '${next.#s.minPrice}' must be a positive decimal string`
+      throw new RouteDefinitionError(
+        this.#s.key,
+        `minPrice '${next.#s.minPrice}' must be a positive decimal string`
       );
     }
     if (next.#s.tickCost !== void 0 && !isPositiveDecimal(next.#s.tickCost)) {
-      throw new Error(
-        `route '${this.#s.key}': tickCost '${next.#s.tickCost}' must be a positive decimal string`
+      throw new RouteDefinitionError(
+        this.#s.key,
+        `tickCost '${next.#s.tickCost}' must be a positive decimal string`
       );
     }
     return next;
   }
-  /**
-   * Require Sign-In-with-X wallet identity on this route — clients prove
-   * control of a wallet via a signed challenge. Composes with `.paid()` and
-   * `.upTo()` for pay-once-then-replay: the first request settles normally,
-   * subsequent requests with a valid SIWX signature for the same wallet skip
-   * payment (on `.upTo()`, `charge(amount)` becomes a no-op on the replay).
-   * Mutually exclusive with `.metered()`.
-   *
-   * @example
-   * ```ts
-   * router.route('profile').siwx().handler(async ({ wallet }) => getProfile(wallet));
-   * router.route('inbox').paid('0.01').siwx().handler(async ({ wallet }) => getInbox(wallet));
-   * ```
-   */
   siwx() {
-    if (this.#s.authMode === "unprotected") {
-      throw new Error(
-        `route '${this.#s.key}': Cannot combine .unprotected() and .siwx() on the same route.`
+    const self = this;
+    if (self.#s.authMode === "unprotected") {
+      throw new RouteDefinitionError(
+        self.#s.key,
+        `Cannot combine .unprotected() and .siwx() on the same route.`
       );
     }
-    if (this.#s.apiKeyResolver) {
-      throw new Error(
-        `route '${this.#s.key}': Combining .siwx() and .apiKey() is not supported on the same route.`
+    if (self.#s.apiKeyResolver) {
+      throw new RouteDefinitionError(
+        self.#s.key,
+        `Combining .siwx() and .apiKey() is not supported on the same route.`
       );
     }
-    if (this.#s.billing === "metered") {
-      throw new Error(
-        `route '${this.#s.key}': Cannot combine .metered() and .siwx() \u2014 per-tick MPP billing has no entitlement model. Use .paid() or .upTo() with .siwx(), or drop .siwx() for metered routes.`
+    if (self.#s.billing === "metered") {
+      throw new RouteDefinitionError(
+        self.#s.key,
+        `Cannot combine .metered() and .siwx() \u2014 per-tick MPP billing has no entitlement model. Use .paid() or .upTo() with .siwx(), or drop .siwx() for metered routes.`
       );
     }
-    const next = this.fork();
+    const next = self.fork();
     next.#s.siwxEnabled = true;
     if (next.#s.authMode === "paid" || next.#s.pricing) {
       next.#s.authMode = "paid";
@@ -3907,59 +3912,48 @@ var RouteBuilder = class _RouteBuilder {
     next.#s.protocols = [];
     return next;
   }
-  /**
-   * Require an `X-API-Key` header (or `Authorization: Bearer <key>`); the
-   * resolver returns the account record, or `null` for 401. Composes with
-   * `.paid()` — key is checked first, payment second.
-   *
-   * @example
-   * ```ts
-   * router
-   *   .route('admin/users')
-   *   .apiKey(async (key) => db.admin.findByKey(key))
-   *   .handler(async ({ account }) => db.user.list(account.orgId));
-   * ```
-   */
   apiKey(resolver) {
-    if (this.#s.siwxEnabled) {
-      throw new Error(
-        `route '${this.#s.key}': Combining .apiKey() and .siwx() is not supported on the same route.`
+    const self = this;
+    if (self.#s.authMode === "unprotected") {
+      throw new RouteDefinitionError(
+        self.#s.key,
+        `Cannot combine .unprotected() and .apiKey() on the same route.`
       );
     }
-    const next = this.fork();
+    if (self.#s.siwxEnabled) {
+      throw new RouteDefinitionError(
+        self.#s.key,
+        `Combining .apiKey() and .siwx() is not supported on the same route.`
+      );
+    }
+    const next = self.fork();
     next.#s.authMode = "apiKey";
     next.#s.apiKeyResolver = resolver;
     return next;
   }
-  /**
-   * Mark the route as public — no auth, no payment, no SIWX. The handler
-   * receives `null` for `wallet`, `payment`, and `account`.
-   *
-   * @example
-   * ```ts
-   * router.route('health').unprotected().handler(async () => ({ status: 'ok' }));
-   * ```
-   */
   unprotected() {
-    if (this.#s.authMode && this.#s.authMode !== "unprotected") {
-      throw new Error(
-        `route '${this.#s.key}': Cannot combine .unprotected() and .${this.#s.authMode}() on the same route.`
+    const self = this;
+    if (self.#s.authMode && self.#s.authMode !== "unprotected") {
+      throw new RouteDefinitionError(
+        self.#s.key,
+        `Cannot combine .unprotected() and .${self.#s.authMode}() on the same route.`
       );
     }
-    if (this.#s.pricing) {
-      throw new Error(
-        `route '${this.#s.key}': Cannot combine .unprotected() and .paid() on the same route.`
+    if (self.#s.pricing) {
+      throw new RouteDefinitionError(
+        self.#s.key,
+        `Cannot combine .unprotected() and .paid() on the same route.`
       );
     }
-    const next = this.fork();
+    const next = self.fork();
     next.#s.authMode = "unprotected";
     next.#s.protocols = [];
     return next;
   }
   /**
    * Tag the route with an upstream provider for discovery and provider-side
-   * monitoring. The provider name and config surface in `well-known` and
-   * OpenAPI output.
+   * monitoring. The provider name and config surface in OpenAPI discovery
+   * output.
    *
    * @example
    * ```ts
@@ -4056,8 +4050,8 @@ var RouteBuilder = class _RouteBuilder {
     return next;
   }
   /**
-   * Set a human-readable summary of the route. Surfaces in OpenAPI,
-   * `well-known`, and `llms.txt` discovery output.
+   * Set a human-readable summary of the route. Surfaces in OpenAPI and
+   * `llms.txt` discovery output.
    *
    * @example
    * ```ts
@@ -4193,38 +4187,46 @@ var RouteBuilder = class _RouteBuilder {
   }
   register(handlerFn, streaming) {
     if (!this.#s.authMode) {
-      throw new Error(
-        `route '${this.#s.key}': Select an auth mode: .paid(pricing), .upTo(maxPrice), .metered(options), .siwx(), .apiKey(resolver), or .unprotected()`
+      throw new RouteDefinitionError(
+        this.#s.key,
+        `Select an auth mode: .paid(pricing), .upTo(maxPrice), .metered(options), .siwx(), .apiKey(resolver), or .unprotected()`
       );
     }
     if (this.#s.validateFn && !this.#s.bodySchema) {
-      throw new Error(
-        `route '${this.#s.key}': .validate() requires .body() \u2014 validation runs on parsed body`
+      throw new RouteDefinitionError(
+        this.#s.key,
+        `.validate() requires .body() \u2014 validation runs on parsed body`
       );
     }
     if (this.#s.settlement && !this.#s.pricing) {
-      throw new Error(`route '${this.#s.key}': .settlement() requires a paid route`);
+      throw new RouteDefinitionError(this.#s.key, `.settlement() requires a paid route`);
     }
     if (this.#s.mppInfo?.settleBeforeHandler) {
       if (!this.#s.pricing) {
-        throw new Error(`route '${this.#s.key}': mpp.settleBeforeHandler requires a paid route`);
+        throw new RouteDefinitionError(
+          this.#s.key,
+          `mpp.settleBeforeHandler requires a paid route`
+        );
       }
       if (this.#s.billing !== "exact") {
-        throw new Error(
-          `route '${this.#s.key}': mpp.settleBeforeHandler is only supported on .paid() routes`
+        throw new RouteDefinitionError(
+          this.#s.key,
+          `mpp.settleBeforeHandler is only supported on .paid() routes`
         );
       }
       if (this.#s.settlement?.beforeSettle) {
-        throw new Error(
-          `route '${this.#s.key}': mpp.settleBeforeHandler is incompatible with .settlement({ beforeSettle }) \u2014 MPP payment is already broadcast before the handler runs`
+        throw new RouteDefinitionError(
+          this.#s.key,
+          `mpp.settleBeforeHandler is incompatible with .settlement({ beforeSettle }) \u2014 MPP payment is already broadcast before the handler runs`
         );
       }
     }
     if (this.#s.billing === "upto") {
       const hasUpto = this.#s.deps.x402Accepts.some((accept) => accept.scheme === "upto");
       if (!hasUpto) {
-        throw new Error(
-          `route '${this.#s.key}': .upTo() requires an 'upto' accept on at least one configured network. Add { scheme: 'upto', network, asset } to RouterConfig.x402.accepts.`
+        throw new RouteDefinitionError(
+          this.#s.key,
+          `.upTo() requires an 'upto' accept on at least one configured network. Add { scheme: 'upto', network, asset } to RouterConfig.x402.accepts.`
         );
       }
     }
@@ -4233,26 +4235,30 @@ var RouteBuilder = class _RouteBuilder {
         (accept) => (accept.scheme ?? "exact") !== "upto"
       );
       if (!hasExact) {
-        throw new Error(
-          `route '${this.#s.key}': .paid() needs a non-'upto' x402 accept \u2014 an 'upto'-only accept list cannot serve a fixed-price route. Add { scheme: 'exact', network } to RouterConfig.x402.accepts, or use .upTo() for handler-computed billing.`
+        throw new RouteDefinitionError(
+          this.#s.key,
+          `.paid() needs a non-'upto' x402 accept \u2014 an 'upto'-only accept list cannot serve a fixed-price route. Add { scheme: 'exact', network } to RouterConfig.x402.accepts, or use .upTo() for handler-computed billing.`
         );
       }
     }
     if (this.#s.billing === "metered") {
       if (!this.#s.deps.mppSessionConfig) {
-        throw new Error(
-          `route '${this.#s.key}': .metered() requires MPP session mode. Set RouterConfig.mpp.session = {} and provide mpp.operatorKey.`
+        throw new RouteDefinitionError(
+          this.#s.key,
+          `.metered() requires MPP session mode. Set RouterConfig.mpp.session = {} and provide mpp.operatorKey.`
         );
       }
     }
     if (streaming && this.#s.billing !== "metered") {
-      throw new Error(
-        `route '${this.#s.key}': .stream() requires .metered() \u2014 static/free/upto routes can't meter per-chunk billing.`
+      throw new RouteDefinitionError(
+        this.#s.key,
+        `.stream() requires .metered() \u2014 static/free/upto routes can't meter per-chunk billing.`
       );
     }
     if (this.#s.description !== void 0 && this.#s.description.length > MAX_X402_DESCRIPTION_LENGTH && this.#s.pricing !== void 0 && this.#s.protocols.includes("x402")) {
-      throw new Error(
-        `route '${this.#s.key}': .description() is ${this.#s.description.length} chars; must be \u2264 ${MAX_X402_DESCRIPTION_LENGTH} chars \u2014 the CDP x402 facilitator rejects payments whose 402 challenge resource.description exceeds ~500 chars.`
+      throw new RouteDefinitionError(
+        this.#s.key,
+        `.description() is ${this.#s.description.length} chars; must be \u2264 ${MAX_X402_DESCRIPTION_LENGTH} chars \u2014 the CDP x402 facilitator rejects payments whose 402 challenge resource.description exceeds ~500 chars.`
       );
     }
     validateExamples(
@@ -4320,14 +4326,15 @@ function normalizePaidArg(routeKey, arg, options) {
   if ("price" in arg && typeof arg.price === "string") {
     return { pricing: arg.price, resolvedOptions: arg, billing: "exact" };
   }
-  throw new Error(
-    `route '${routeKey}': .paid() requires one of: a price string, a (body) => string function, { price }, or { field, tiers }. For handler-computed billing use .upTo(); for per-tick billing use .metered().`
+  throw new RouteDefinitionError(
+    routeKey,
+    `.paid() requires one of: a price string, a (body) => string function, { price }, or { field, tiers }. For handler-computed billing use .upTo(); for per-tick billing use .metered().`
   );
 }
 function normalizeUpToArg(routeKey, arg) {
   const options = typeof arg === "string" ? { maxPrice: arg } : arg;
   if (!options.maxPrice) {
-    throw new Error(`route '${routeKey}': .upTo() requires maxPrice`);
+    throw new RouteDefinitionError(routeKey, `.upTo() requires maxPrice`);
   }
   return {
     pricing: options.maxPrice,
@@ -4339,10 +4346,10 @@ function normalizeUpToArg(routeKey, arg) {
 }
 function normalizeMeteredArg(routeKey, options) {
   if (!options.maxPrice) {
-    throw new Error(`route '${routeKey}': .metered() requires maxPrice`);
+    throw new RouteDefinitionError(routeKey, `.metered() requires maxPrice`);
   }
   if (!options.tickCost) {
-    throw new Error(`route '${routeKey}': .metered() requires tickCost`);
+    throw new RouteDefinitionError(routeKey, `.metered() requires tickCost`);
   }
   return {
     pricing: options.maxPrice,
@@ -4649,9 +4656,9 @@ function createNotFoundHandler(baseUrl) {
       code: "route_not_found",
       error: "Route not found. Rediscover this origin and retry with the current discovery document.",
       requestedUrl: request.url,
+      // The deprecated /.well-known/x402 surface is intentionally not advertised.
       discovery: {
         openapi: `${normalizedBase}/openapi.json`,
-        wellKnown: `${normalizedBase}/.well-known/x402`,
         llmsTxt: `${normalizedBase}/llms.txt`
       }
     },
@@ -4684,6 +4691,7 @@ function formatRouterConfigIssues(issues) {
 }
 
 // src/config/schema.ts
+init_accepts();
 init_constants();
 import { z } from "zod";
 
@@ -4873,18 +4881,8 @@ function deriveBaseUrlEnv(env) {
     BASE_URL: vercelBaseUrl
   };
 }
-function getConfiguredX402Accepts2(config) {
-  if (config.x402?.accepts?.length) return [...config.x402.accepts];
-  return [
-    {
-      scheme: "exact",
-      network: config.network ?? BASE_MAINNET_NETWORK,
-      payTo: config.payeeAddress
-    }
-  ];
-}
 function validateX402Config(config, env) {
-  const accepts = getConfiguredX402Accepts2(config);
+  const accepts = getConfiguredX402Accepts(config);
   const issues = [];
   const push = (code, message) => issues.push({ code, protocol: "x402", message });
   if (accepts.length === 0) {
@@ -5185,7 +5183,8 @@ function getMppxRequestContext(args) {
         recipient: mppConfig.recipient ?? payeeAddress,
         getClient,
         ...feePayerAccount ? { feePayer: feePayerAccount } : {},
-        ...resolvedStore ? { store: resolvedStore } : {}
+        ...resolvedStore ? { store: resolvedStore } : {},
+        ...mppConfig.feePayerPolicy ? { feePayerPolicy: mppConfig.feePayerPolicy } : {}
       }),
       ...sessionEnabled ? [
         tempo.session({
@@ -5223,7 +5222,7 @@ async function initMpp(config, resolvedBaseUrl, kvStore, configError) {
   try {
     const { Mppx, tempo } = await import("mppx/server");
     const { createClient, http } = await import("viem");
-    const { tempo: tempoChain } = await import("viem/chains");
+    const { tempo: tempoChain } = await import("viem/tempo/chains");
     const { privateKeyToAccount: privateKeyToAccount2 } = await import("viem/accounts");
     const rpcUrl = config.mpp.rpcUrl ?? process.env.TEMPO_RPC_URL ?? DEFAULT_TEMPO_RPC_URL;
     const tempoClient = createClient({ chain: tempoChain, transport: http(rpcUrl) });
@@ -5241,7 +5240,9 @@ async function initMpp(config, resolvedBaseUrl, kvStore, configError) {
       getClient,
       ...operatorAccount ? { account: operatorAccount } : {},
       ...feePayerAccount ? { feePayer: feePayerAccount } : {},
-      ...resolvedStore ? { store: resolvedStore } : {}
+      ...resolvedStore ? { store: resolvedStore } : {},
+      ...mppConfig.feePayerPolicy ? { feePayerPolicy: mppConfig.feePayerPolicy } : {},
+      ...mppConfig.session?.settlementSchedule ? { settlementSchedule: mppConfig.session.settlementSchedule } : {}
     };
     const mppxArgs = {
       Mppx,
@@ -5257,6 +5258,7 @@ async function initMpp(config, resolvedBaseUrl, kvStore, configError) {
     };
     const primary = getMppxRequestContext(mppxArgs);
     const streaming = getMppxStreamingContext(mppxArgs);
+    subscribePaymentFailedAlerts(config.plugin, [primary, streaming]);
     const mppx = {
       charge: primary.charge,
       ...primary.session ? { sessionRequest: primary.session } : {},
@@ -5267,6 +5269,41 @@ async function initMpp(config, resolvedBaseUrl, kvStore, configError) {
     return { initError: err instanceof Error ? err.message : String(err) };
   }
 }
+function subscribePaymentFailedAlerts(plugin, instances) {
+  if (!plugin?.onAlert) return;
+  const ctx = {
+    requestId: "mppx",
+    route: "mpp",
+    walletAddress: null,
+    clientId: null,
+    sessionId: null,
+    verifiedWallet: null,
+    setVerifiedWallet() {
+    }
+  };
+  for (const instance of instances) {
+    const events = instance;
+    if (typeof events?.onPaymentFailed !== "function") continue;
+    events.onPaymentFailed((payload) => {
+      try {
+        const error = payload?.error ?? {};
+        firePluginHook(plugin, "onAlert", ctx, {
+          level: (error.status ?? 402) >= 500 ? "error" : "warn",
+          message: `MPP payment failed: ${error.message ?? error.name ?? "unknown error"}`,
+          route: "mpp",
+          meta: {
+            ...payload?.method ? { method: `${payload.method.name}/${payload.method.intent}` } : {},
+            ...error.type ? { errorType: error.type } : {},
+            ...error.status !== void 0 ? { status: error.status } : {},
+            ...error.hint ? { hint: error.hint } : {},
+            ...payload?.credential?.source ? { payer: payload.credential.source } : {}
+          }
+        });
+      } catch {
+      }
+    });
+  }
+}
 
 // src/index.ts
 init_constants();
@@ -5409,6 +5446,7 @@ export {
   DEFAULT_SOLANA_FACILITATOR_URL,
   DEFAULT_TEMPO_RPC_URL,
   HttpError,
+  RouteDefinitionError,
   RouterConfigError,
   SOLANA_MAINNET_NETWORK,
   TEMPO_USDC_ADDRESS,