@payments-ai/mcp 2.4.1 → 2.5.0

package/dist/main.http.js

@@ -247,17 +247,23 @@ var SUPPORTED_OAUTH_SCOPES = [
   "docs:read",
   "checkout:read",
   "checkout:write",
-  "transaction:read"
+  "transaction:read",
+  "customer:read",
+  "invoice:read"
 ];
 var OAUTH_CONSENT_READ_SCOPES = [
   "merchant:read",
   "product:read",
   "docs:read",
   "checkout:read",
-  "transaction:read"
+  "transaction:read",
+  "customer:read",
+  "invoice:read"
 ];
 var EXPLICIT_GRANT_OAUTH_SCOPES = [
-  "transaction:read"
+  "transaction:read",
+  "customer:read",
+  "invoice:read"
 ];
 var EXPLICIT_GRANT_SCOPE_SET = new Set(EXPLICIT_GRANT_OAUTH_SCOPES);
 function isExplicitGrantScope(scope) {
@@ -272,6 +278,7 @@ function buildOAuthAuthorizationServerMetadata(issuerUrl, options2) {
     issuer: issuerUrl,
     authorization_endpoint: `${issuerUrl}/api/v1/oauth/authorize`,
     token_endpoint: `${issuerUrl}/api/v1/oauth/token`,
+    revocation_endpoint: `${issuerUrl}/api/v1/oauth/revoke`,
     registration_endpoint: `${issuerUrl}/api/v1/oauth/register`,
     scopes_supported: SUPPORTED_OAUTH_SCOPES,
     response_types_supported: OAUTH_RESPONSE_TYPES_SUPPORTED,
@@ -287,6 +294,9 @@ var MCP_OAUTH_AUTHORIZATION_WINDOW_MINUTES = 30;
 var MCP_OAUTH_AUTHORIZATION_WINDOW_MS = MCP_OAUTH_AUTHORIZATION_WINDOW_MINUTES * 60 * 1e3;
 
 // ../../packages/mcp-contracts/dist/order-limits.js
+var import_currency2 = __toESM(require_currency(), 1);
+
+// ../../packages/mcp-contracts/dist/currency-precision.js
 var import_currency = __toESM(require_currency(), 1);
 
 // ../../packages/mcp-contracts/dist/plan-amount-limits.js
@@ -301,7 +311,8 @@ var MIN_PAID_PLAN_AMOUNT_BY_CURRENCY = {
   dkk: 2.5,
   nok: 3,
   cad: 1,
-  aud: 1
+  aud: 1,
+  jpy: 50
 };
 var SUPPORTED_CURRENCIES = Object.freeze(Object.keys(MIN_PAID_PLAN_AMOUNT_BY_CURRENCY));
 function isSupportedCurrency(currency5) {
@@ -320,15 +331,49 @@ function formatMinPaidPlanAmountMessage(currency5, minAmount) {
   const code = currency5.trim().toUpperCase() || "USD";
   return `Amount must be at least ${minAmount} ${code} for paid plans`;
 }
+function formatAmountPrecisionMessage(currency5, fractionDigits) {
+  const code = currency5.trim().toUpperCase();
+  if (fractionDigits === 0) {
+    return `Amount must be a whole number of ${code}, which has no minor unit. Recovery: round the amount to whole ${code}, e.g. 500 rather than 500.5.`;
+  }
+  return `Amount must have at most ${fractionDigits} decimal places in ${code}. Recovery: round the amount to ${fractionDigits} decimal places.`;
+}
 var LOWEST_MIN_PAID_PLAN_AMOUNT = Math.min(...Object.values(MIN_PAID_PLAN_AMOUNT_BY_CURRENCY));
 var PAID_PLAN_NOT_FREE_BY_ZERO_AMOUNT = "A paid plan cannot be made free by setting its amount to 0; create a free-access plan instead.";
 function formatAmountBelowLowestFloorMessage() {
   const higherFloors = Object.entries(MIN_PAID_PLAN_AMOUNT_BY_CURRENCY).filter(([, minAmount]) => minAmount > LOWEST_MIN_PAID_PLAN_AMOUNT).map(([currency5, minAmount]) => `${minAmount} ${currency5.toUpperCase()}`).join(", ");
   return `Amount must be at least ${LOWEST_MIN_PAID_PLAN_AMOUNT} for paid plans, and more in some currencies (${higherFloors}). Recovery: send an amount of at least the floor of the plan's currency, or 0 for a free-access plan. ${PAID_PLAN_NOT_FREE_BY_ZERO_AMOUNT}`;
 }
-var MAX_PLAN_AMOUNT = 1e5;
-function formatMaxPlanAmountMessage() {
-  return `Amount must be at most ${MAX_PLAN_AMOUNT}. Recovery: lower the plan amount, or contact support if you need a higher per-plan limit.`;
+var DEFAULT_MAX_PLAN_AMOUNT = 1e5;
+var MAX_PLAN_AMOUNT_BY_CURRENCY = {
+  usd: DEFAULT_MAX_PLAN_AMOUNT,
+  eur: DEFAULT_MAX_PLAN_AMOUNT,
+  gbp: DEFAULT_MAX_PLAN_AMOUNT,
+  pln: DEFAULT_MAX_PLAN_AMOUNT,
+  chf: DEFAULT_MAX_PLAN_AMOUNT,
+  sek: DEFAULT_MAX_PLAN_AMOUNT,
+  dkk: DEFAULT_MAX_PLAN_AMOUNT,
+  nok: DEFAULT_MAX_PLAN_AMOUNT,
+  cad: DEFAULT_MAX_PLAN_AMOUNT,
+  aud: DEFAULT_MAX_PLAN_AMOUNT,
+  // Tech-lead decision (about the USD 100000 ceiling in yen), not a measured Whop limit.
+  jpy: 15e6
+};
+function getMaxPlanAmount(currency5) {
+  const key = currency5.trim().toLowerCase();
+  return MAX_PLAN_AMOUNT_BY_CURRENCY[key] ?? DEFAULT_MAX_PLAN_AMOUNT;
+}
+var HIGHEST_MAX_PLAN_AMOUNT = Math.max(...Object.values(MAX_PLAN_AMOUNT_BY_CURRENCY));
+var MAX_AMOUNT_RECOVERY = "Recovery: lower the plan amount, or contact support if you need a higher per-plan limit.";
+function formatMaxPlanAmountMessage(currency5) {
+  const code = currency5.trim().toUpperCase();
+  return `Amount must be at most ${getMaxPlanAmount(currency5)} ${code}. ${MAX_AMOUNT_RECOVERY}`;
+}
+function formatHigherMaxAmounts() {
+  return Object.entries(MAX_PLAN_AMOUNT_BY_CURRENCY).filter(([, maxAmount]) => maxAmount > DEFAULT_MAX_PLAN_AMOUNT).map(([currency5, maxAmount]) => `${maxAmount} ${currency5.toUpperCase()}`).join(", ");
+}
+function formatAmountAboveCeilingMessage() {
+  return `Amount must be at most ${DEFAULT_MAX_PLAN_AMOUNT}, or the higher ceiling of its currency (${formatHigherMaxAmounts()}). ${MAX_AMOUNT_RECOVERY}`;
 }
 var MAX_PERIOD_LENGTH_BY_BILLING_PERIOD = {
   week: 52,
@@ -343,8 +388,52 @@ function formatPeriodLengthRecovery(maxLength) {
 }
 var MAX_FREE_TRIAL_DAYS = 730;
 
+// ../../packages/mcp-contracts/dist/currency-precision.js
+function currencyFractionDigits(currencyCode3) {
+  const code = currencyCode3.trim().toUpperCase();
+  let digits;
+  try {
+    digits = new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency: code
+    }).resolvedOptions().maximumFractionDigits;
+  } catch {
+    throw new Error(`Unsupported currency "${currencyCode3}"`);
+  }
+  if (typeof digits !== "number") {
+    throw new Error(`Unsupported currency "${currencyCode3}"`);
+  }
+  return digits;
+}
+var MINOR_UNIT_RELATIVE_TOLERANCE = Number.EPSILON * 16;
+function amountExceedsCurrencyPrecision(amount, currencyCode3) {
+  const minorUnits = amount * 10 ** currencyFractionDigits(currencyCode3);
+  const drift = Math.abs(minorUnits - Math.round(minorUnits));
+  return drift > Math.abs(minorUnits) * MINOR_UNIT_RELATIVE_TOLERANCE;
+}
+function describeAmountPrecisionViolation(amount, currencyCode3) {
+  const fractionDigits = resolveFractionDigits(currencyCode3);
+  if (fractionDigits === void 0 || !amountExceedsCurrencyPrecision(amount, currencyCode3)) {
+    return void 0;
+  }
+  return formatAmountPrecisionMessage(currencyCode3, fractionDigits);
+}
+function describeRequestAmountPrecisionViolation(amount, currencyCode3) {
+  return describeAmountPrecisionViolation((0, import_currency.default)(amount).value, currencyCode3);
+}
+function resolveFractionDigits(currencyCode3) {
+  try {
+    return currencyFractionDigits(currencyCode3);
+  } catch {
+    return void 0;
+  }
+}
+
 // ../../packages/mcp-contracts/dist/order-limits.js
-var MAX_ORDER_AMOUNT = MAX_PLAN_AMOUNT;
+function getMaxOrderAmount(currency5) {
+  return getMaxPlanAmount(currency5);
+}
+var HIGHEST_MAX_ORDER_AMOUNT = HIGHEST_MAX_PLAN_AMOUNT;
 var MAX_ORDER_ITEM_QUANTITY = 1e4;
 var MAX_ORDER_PERIOD_LENGTH_BY_BILLING_PERIOD = {
   day: 365,
@@ -358,7 +447,11 @@ function getMaxOrderPeriodLength(billingPeriod) {
 var ORDER_PERIOD_CAPS = Object.entries(MAX_ORDER_PERIOD_LENGTH_BY_BILLING_PERIOD).map(([period, max]) => `${max} ${period}`).join(" / ");
 var ORDER_PERIOD_LENGTH_TOO_LONG_MESSAGE = `periodLength must be at most ${MAX_ORDER_PERIOD_LENGTH}, and at most one year of the chosen billingPeriod (${ORDER_PERIOD_CAPS}). Recovery: lower periodLength to the cap for your billingPeriod; nothing can bill less often than once a year.`;
 var HIGHER_LIMIT_RECOVERY = "or contact support if you need a higher per-order limit.";
-var ORDER_UNIT_PRICE_TOO_HIGH_MESSAGE = `unitPrice must be at most ${MAX_ORDER_AMOUNT}. Recovery: confirm the price with the user (amounts are in major units, so 19.99 means $19.99), ${HIGHER_LIMIT_RECOVERY}`;
+var UNIT_PRICE_RECOVERY = `Recovery: confirm the price with the user (amounts are in major units, so 19.99 means $19.99), ${HIGHER_LIMIT_RECOVERY}`;
+var ORDER_UNIT_PRICE_TOO_HIGH_MESSAGE = `unitPrice must be at most ${DEFAULT_MAX_PLAN_AMOUNT}, or the higher ceiling of the order currency (${formatHigherMaxAmounts()}). ${UNIT_PRICE_RECOVERY}`;
+function formatOrderUnitPriceTooHighMessage(currency5) {
+  return `unitPrice must be at most ${formatOrderCeiling(currency5)}. ${UNIT_PRICE_RECOVERY}`;
+}
 var ORDER_QUANTITY_TOO_HIGH_MESSAGE = `quantity must be at most ${MAX_ORDER_ITEM_QUANTITY}. Recovery: lower the quantity, or contact support if you need more units on one order line.`;
 var ORDER_TRIAL_PERIOD_DAYS_TOO_LONG_MESSAGE = `trialPeriodDays must be at most ${MAX_FREE_TRIAL_DAYS} days. Recovery: lower the trial length.`;
 var RECURRING_ORDER_ITEM_CADENCE_MESSAGE = 'billingPeriod and periodLength are required when type is "recurring". Recovery: send both, e.g. billingPeriod "month" with periodLength 1 to bill monthly, or billingPeriod "day" with periodLength 30 to bill every 30 days.';
@@ -368,48 +461,86 @@ var INTERVAL_DAYS_TOO_SHORT_MESSAGE = `intervalDays must be at least ${MIN_WHOP_
 function isBelowMinWhopBillingPeriod(billingPeriod, periodLength) {
   return billingPeriod === "day" && periodLength < MIN_WHOP_BILLING_PERIOD_DAYS;
 }
-function formatOrderLineTotalTooHighMessage(lineTotal2) {
-  return `unitPrice x quantity is ${formatOrderAmount(lineTotal2)}; one order line can charge at most ${MAX_ORDER_AMOUNT}. Recovery: lower the quantity or the unitPrice, ${HIGHER_LIMIT_RECOVERY}`;
+function formatOrderLineTotalTooHighMessage(lineTotal2, currency5) {
+  return `unitPrice x quantity is ${formatOrderAmount(lineTotal2, currency5)}; one order line can charge at most ${formatOrderCeiling(currency5)}. Recovery: lower the quantity or the unitPrice, ${HIGHER_LIMIT_RECOVERY}`;
 }
-function formatOrderTotalTooHighMessage(total, moment) {
-  return `This order charges ${formatOrderAmount(total)} ${moment}; one order can charge at most ${MAX_ORDER_AMOUNT}. Recovery: remove items or lower quantities, ${HIGHER_LIMIT_RECOVERY}`;
+function formatOrderTotalTooHighMessage(total, moment, currency5) {
+  return `This order charges ${formatOrderAmount(total, currency5)} ${moment}; one order can charge at most ${formatOrderCeiling(currency5)}. Recovery: remove items or lower quantities, ${HIGHER_LIMIT_RECOVERY}`;
 }
 function formatMaxOrderPeriodLengthMessage(billingPeriod, maxLength) {
   return `periodLength must be at most ${maxLength} when billingPeriod is "${billingPeriod}" (an order renews at least once a year). ${formatPeriodLengthRecovery(maxLength)}`;
 }
-function formatOrderAmount(amount) {
-  return (0, import_currency.default)(amount).toString();
+function formatOrderCeiling(currencyCode3) {
+  return `${getMaxOrderAmount(currencyCode3)} ${currencyCode3.trim().toUpperCase()}`;
+}
+function formatOrderAmount(amount, currencyCode3) {
+  return (0, import_currency2.default)(amount, { precision: fractionDigitsOrTwo(currencyCode3) }).toString();
+}
+function fractionDigitsOrTwo(currencyCode3) {
+  try {
+    return currencyFractionDigits(currencyCode3);
+  } catch {
+    return 2;
+  }
 }
 
 // ../../packages/mcp-contracts/dist/order-item-limits.js
-var import_currency2 = __toESM(require_currency(), 1);
+var import_currency3 = __toESM(require_currency(), 1);
 var TRIAL_PERIOD_DAYS_NOT_RECURRING_MESSAGE = 'trialPeriodDays only applies to recurring custom items; a one_time line charges immediately. Recovery: remove trialPeriodDays, or use type "recurring" if the buyer should get a trial before the first charge.';
 function checkCustomOrderItemLimits(item, ctx) {
   checkRecurringCadence(item, ctx);
   checkTrialPeriodDaysIsRecurring(item, ctx);
   checkPeriodLengthCap(item, ctx);
   checkDailyCadence(item, ctx);
-  checkLineTotal(item, ctx);
 }
-function checkTrialPeriodDaysIsRecurring(item, ctx) {
-  if (item.type === "recurring" || item.trialPeriodDays === void 0)
+function checkCustomOrderItemAmounts(body, ctx) {
+  body.items.forEach((item, index) => {
+    if (!isPricedItem(item))
+      return;
+    const issue2 = describeLineAmountIssue(item, body.currency);
+    if (issue2 === void 0)
+      return;
+    ctx.addIssue({ code: "custom", message: issue2.message, path: ["items", index, issue2.field] });
+  });
+}
+function checkCustomOrderItemsTotal(body, ctx) {
+  const items = body.items.filter(isPricedItem);
+  if (items.some((item) => hasLineIssue(item, body.currency)))
+    return;
+  const total = items.reduce((sum, item) => sum.add(lineTotal(item)), (0, import_currency3.default)(0));
+  if (total.value <= getMaxOrderAmount(body.currency))
     return;
   ctx.addIssue({
     code: "custom",
-    message: TRIAL_PERIOD_DAYS_NOT_RECURRING_MESSAGE,
-    path: ["trialPeriodDays"]
+    message: formatOrderTotalTooHighMessage(total.value, "today", body.currency),
+    path: ["items"]
   });
 }
-function checkCustomOrderItemsTotal(items, ctx) {
-  if (items.some(exceedsLineCeiling))
-    return;
-  const total = items.reduce((sum, item) => sum.add(lineTotal(item)), (0, import_currency2.default)(0));
-  if (total.value <= MAX_ORDER_AMOUNT)
+function hasLineIssue(item, currencyCode3) {
+  return exceedsFieldCeiling(item) || describeLineAmountIssue(item, currencyCode3) !== void 0;
+}
+function describeLineAmountIssue(item, currencyCode3) {
+  if (exceedsFieldCeiling(item))
+    return void 0;
+  const maxAmount = getMaxOrderAmount(currencyCode3);
+  if (item.unitPrice > maxAmount) {
+    return { field: "unitPrice", message: formatOrderUnitPriceTooHighMessage(currencyCode3) };
+  }
+  const precision = describeRequestAmountPrecisionViolation(item.unitPrice, currencyCode3);
+  if (precision !== void 0)
+    return { field: "unitPrice", message: precision };
+  const total = lineTotal(item).value;
+  if (total <= maxAmount)
+    return void 0;
+  return { field: "quantity", message: formatOrderLineTotalTooHighMessage(total, currencyCode3) };
+}
+function checkTrialPeriodDaysIsRecurring(item, ctx) {
+  if (item.type === "recurring" || item.trialPeriodDays === void 0)
     return;
   ctx.addIssue({
     code: "custom",
-    message: formatOrderTotalTooHighMessage(total.value, "today"),
-    path: ["items"]
+    message: TRIAL_PERIOD_DAYS_NOT_RECURRING_MESSAGE,
+    path: ["trialPeriodDays"]
   });
 }
 function checkRecurringCadence(item, ctx) {
@@ -447,26 +578,14 @@ function checkDailyCadence(item, ctx) {
     path: ["periodLength"]
   });
 }
-function checkLineTotal(item, ctx) {
-  if (exceedsFieldCeiling(item))
-    return;
-  const total = lineTotal(item);
-  if (total.value <= MAX_ORDER_AMOUNT)
-    return;
-  ctx.addIssue({
-    code: "custom",
-    message: formatOrderLineTotalTooHighMessage(total.value),
-    path: ["quantity"]
-  });
-}
 function lineTotal(item) {
-  return (0, import_currency2.default)(item.unitPrice).multiply(item.quantity);
+  return (0, import_currency3.default)(item.unitPrice).multiply(item.quantity);
 }
 function exceedsFieldCeiling(item) {
-  return item.unitPrice > MAX_ORDER_AMOUNT || item.quantity > MAX_ORDER_ITEM_QUANTITY;
+  return item.unitPrice > HIGHEST_MAX_ORDER_AMOUNT || item.quantity > MAX_ORDER_ITEM_QUANTITY;
 }
-function exceedsLineCeiling(item) {
-  return exceedsFieldCeiling(item) || lineTotal(item).value > MAX_ORDER_AMOUNT;
+function isPricedItem(item) {
+  return typeof item === "object" && item !== null && "unitPrice" in item && typeof item.unitPrice === "number" && "quantity" in item && typeof item.quantity === "number";
 }
 
 // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/external.js
@@ -20170,7 +20289,7 @@ var createOrderPlanItemSchema = external_exports.object({
 }).strict();
 var createOrderCustomItemSchema = external_exports.object({
   label: external_exports.string().trim().min(1).max(255),
-  unitPrice: external_exports.number().positive().max(MAX_ORDER_AMOUNT, ORDER_UNIT_PRICE_TOO_HIGH_MESSAGE).describe("Price of one unit in major units of the order currency (decimal dollars, not cents): 10 means $10.00, 1999 means $1,999.00."),
+  unitPrice: external_exports.number().positive().max(HIGHEST_MAX_ORDER_AMOUNT, ORDER_UNIT_PRICE_TOO_HIGH_MESSAGE).describe("Price of one unit in major units of the order currency (decimal dollars, not cents): 10 means $10.00, 1999 means $1,999.00. A currency with no minor unit takes whole numbers: 500 means \xA5500."),
   quantity: orderQuantitySchema,
   type: external_exports.enum(ORDER_ITEM_TYPES),
   billingPeriod: external_exports.enum(ORDER_BILLING_PERIODS).optional(),
@@ -20186,7 +20305,10 @@ var createOrderInputSchema = external_exports.object({
   currency: supportedCurrencyCodeSchema,
   items: external_exports.array(createOrderItemSchema).min(1).max(MAX_ORDER_ITEMS),
   idempotencyKey: external_exports.string().trim().min(1).max(MAX_IDEMPOTENCY_KEY_LENGTH).optional()
-}).strict().superRefine((input2, ctx) => checkCustomOrderItemsTotal(input2.items.filter((item) => "unitPrice" in item), ctx));
+}).strict().superRefine((input2, ctx) => {
+  checkCustomOrderItemAmounts(input2, ctx);
+  checkCustomOrderItemsTotal(input2, ctx);
+});
 var createOrderItemResponseSchema = external_exports.object({
   label: external_exports.string(),
   unitPrice: external_exports.number(),
@@ -20241,13 +20363,13 @@ function formatPlanNameTooLong(length) {
 function formatPlanDescriptionTooLong(length) {
   return `Plan description is ${length} characters; max ${PLAN_DESCRIPTION_MAX}. Recovery: shorten the description to <=${PLAN_DESCRIPTION_MAX} characters \u2014 it is a one-line caption, so keep the pricing detail that distinguishes this plan \u2014 and move the full copy into this plan's richDescription (up to ${PLAN_RICH_DESCRIPTION_MAX} characters), which the hosted checkout page renders beneath it.`;
 }
-var PLAN_AMOUNT_DESCRIPTION = "Price in major units of `currency` (decimal dollars, not cents): 19.99 means $19.99 and 1999 means $1,999.00. Stored as 0 on a free-access plan.";
+var PLAN_AMOUNT_DESCRIPTION = "Price in major units of `currency` (decimal dollars, not cents): 19.99 means $19.99 and 1999 means $1,999.00. A currency with no minor unit takes whole numbers: 500 means \xA5500. Stored as 0 on a free-access plan.";
 var planShape = {
   name: external_exports.string().trim().min(1).max(PLAN_NAME_MAX, tooLongError(formatPlanNameTooLong)),
   description: external_exports.string().trim().max(PLAN_DESCRIPTION_MAX, tooLongError(formatPlanDescriptionTooLong)).optional(),
   richDescription: external_exports.string().trim().max(PLAN_RICH_DESCRIPTION_MAX).optional(),
   currency: supportedCurrencyCodeSchema,
-  amount: external_exports.number().nonnegative().max(MAX_PLAN_AMOUNT, `Amount must be at most ${MAX_PLAN_AMOUNT}. Recovery: lower the plan amount, or contact support if you need a higher per-plan limit.`).describe(PLAN_AMOUNT_DESCRIPTION),
+  amount: external_exports.number().nonnegative().max(HIGHEST_MAX_PLAN_AMOUNT, formatAmountAboveCeilingMessage()).describe(PLAN_AMOUNT_DESCRIPTION),
   type: external_exports.enum(PLAN_TYPES2),
   billingPeriod: external_exports.enum(BILLING_PERIODS2),
   periodLength: external_exports.number().int().positive(),
@@ -20265,6 +20387,8 @@ var createMcpPlanSchema = external_exports.strictObject(planShape, { error: unre
   checkPlanPeriodLength(plan, ctx);
   checkFreeTrialIsRecurring(plan, ctx);
   checkPaidPlanMinimum(plan, ctx);
+  checkPlanCeiling(plan, ctx);
+  checkPaidPlanPrecision(plan, ctx);
 });
 function checkPlanPeriodLength(plan, ctx) {
   const maxPeriodLength = MAX_PERIOD_LENGTH_BY_BILLING_PERIOD[plan.billingPeriod];
@@ -20297,6 +20421,24 @@ function checkPaidPlanMinimum(plan, ctx) {
     path: ["amount"]
   });
 }
+function checkPlanCeiling(plan, ctx) {
+  if (plan.amount > HIGHEST_MAX_PLAN_AMOUNT || plan.amount <= getMaxPlanAmount(plan.currency)) {
+    return;
+  }
+  ctx.addIssue({
+    code: "custom",
+    message: formatMaxPlanAmountMessage(plan.currency),
+    path: ["amount"]
+  });
+}
+function checkPaidPlanPrecision(plan, ctx) {
+  if (plan.type === "free-access")
+    return;
+  const message = describeRequestAmountPrecisionViolation(plan.amount, plan.currency);
+  if (message === void 0)
+    return;
+  ctx.addIssue({ code: "custom", message, path: ["amount"] });
+}
 var productBodyBaseSchema = external_exports.object({
   name: external_exports.string().trim().min(1).max(PRODUCT_NAME_MAX, tooLongError(formatProductNameTooLong)).refine((name) => !containsMarkupTag(name), PRODUCT_NAME_MARKUP_MESSAGE),
   description: external_exports.string().trim().min(1).max(PRODUCT_DESCRIPTION_MAX, tooLongError(formatProductDescriptionTooLong)).optional(),
@@ -20385,7 +20527,7 @@ var updatePlanFieldsSchema = external_exports.object({
   description: external_exports.string().trim().max(PLAN_DESCRIPTION_MAX, tooLongError3(formatPlanDescriptionTooLong2)).optional(),
   billingPeriod: external_exports.enum(BILLING_PERIODS3).optional(),
   periodLength: external_exports.number().int().positive().optional(),
-  amount: external_exports.number().nonnegative().max(MAX_PLAN_AMOUNT, formatMaxPlanAmountMessage()).refine((amount) => amount === 0 || amount >= LOWEST_MIN_PAID_PLAN_AMOUNT, {
+  amount: external_exports.number().nonnegative().max(HIGHEST_MAX_PLAN_AMOUNT, formatAmountAboveCeilingMessage()).refine((amount) => amount === 0 || amount >= LOWEST_MIN_PAID_PLAN_AMOUNT, {
     error: formatAmountBelowLowestFloorMessage()
   }).optional(),
   freeTrial: external_exports.number().int().min(0).max(MAX_FREE_TRIAL_DAYS, `freeTrial must be at most ${MAX_FREE_TRIAL_DAYS} days. Recovery: lower the trial length.`).optional()
@@ -20435,6 +20577,9 @@ var updateMcpPlanBackendBodySchema = external_exports.object({
 
 // ../../packages/mcp-contracts/dist/resource-url.js
 function canonicalResourceUrl(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
   if (value.includes("#")) {
     return null;
   }
@@ -25282,13 +25427,17 @@ var SANDBOX_TEST_CARD_NOTE = "To pay a sandbox checkout link, use test card 4242
 
 // src/tools/tool-descriptions.ts
 var CREATE_MERCHANT_CONTACT_GUIDANCE = "Requires only name and email. The email must be the user's own real address, asked from the user or taken from the conversation: example or placeholder addresses (such as you@example.com) and addresses that cannot receive mail are rejected. Phone is optional. If you pass one it must be the user's own mobile number, taken from the conversation or asked from the user; never invent a placeholder or a fictional number (such as a 555 number), because after go_live the identity-verification link is sent to it by SMS and a number that cannot be dialled is rejected. Use E.164 with country code (format only: +14155552671). If the user does not share a phone, omit it and the link goes by email.";
-var CREATE_PRODUCT_PLAN_BOUNDS = `A plan \`amount\` is at most ${MAX_PLAN_AMOUNT}, \`periodLength\` at most one year of the chosen billingPeriod (${formatPeriodCaps(MAX_PERIOD_LENGTH_BY_BILLING_PERIOD)}), and \`freeTrial\` at most ${MAX_FREE_TRIAL_DAYS} days and only on recurring plans. A plan accepts only its documented keys; an unknown key (such as freeTrialDays) is rejected, not ignored.`;
+var CREATE_PRODUCT_PLAN_BOUNDS = `A plan \`amount\` is at most ${formatAmountCeilings()} in the plan currency, \`periodLength\` at most one year of the chosen billingPeriod (${formatPeriodCaps(MAX_PERIOD_LENGTH_BY_BILLING_PERIOD)}), and \`freeTrial\` at most ${MAX_FREE_TRIAL_DAYS} days and only on recurring plans. A plan accepts only its documented keys; an unknown key (such as freeTrialDays) is rejected, not ignored.`;
+function formatAmountCeilings() {
+  const higher = Object.entries(MAX_PLAN_AMOUNT_BY_CURRENCY).filter(([, max]) => max > DEFAULT_MAX_PLAN_AMOUNT).map(([currency5, max]) => `${max} ${currency5.toUpperCase()}`);
+  return higher.length > 0 ? `${DEFAULT_MAX_PLAN_AMOUNT} (${higher.join(", ")})` : `${DEFAULT_MAX_PLAN_AMOUNT}`;
+}
 function formatPeriodCaps(caps) {
   return Object.entries(caps).map(([period, max]) => `${max} ${period}`).join(" / ");
 }
-var PRICE_UNITS = `a decimal dollar amount in the plan currency (major units, e.g. 9.99 for $9.99 \u2014 NOT cents, so 1999 means $1,999.00; currency is one of ${SUPPORTED_CURRENCIES.join(", ")})`;
+var PRICE_UNITS = `a decimal dollar amount in the plan currency (major units, e.g. 9.99 for $9.99 \u2014 NOT cents, so 1999 means $1,999.00; a currency with no minor unit takes whole numbers, so 500 means \xA5500 and 500.5 is rejected; currency is one of ${SUPPORTED_CURRENCIES.join(", ")})`;
 var CREATE_PRODUCT_STORED_PLANS = "`plans` repeats what was stored for each plan, in `planIds` order: amount, currency, `price` formatted as the checkout shows it, and for recurring plans billingPeriod, periodLength and freeTrial \u2014 check `price` against what the user asked for. `warnings`, when present, flags an amount that looks like cents; relay it and, if the user meant the smaller price, fix it with update_plan before sharing the link.";
-var CREATE_ORDER_BOUNDS = `currency is one of ${SUPPORTED_CURRENCIES.join(", ")}. unitPrice is at most ${MAX_ORDER_AMOUNT}, and so is each line (unitPrice x quantity) and the order total; quantity is at most ${MAX_ORDER_ITEM_QUANTITY}; periodLength is at most one year of the billingPeriod (${formatPeriodCaps(MAX_ORDER_PERIOD_LENGTH_BY_BILLING_PERIOD)}). When billingPeriod is "day", periodLength must be at least ${MIN_WHOP_BILLING_PERIOD_DAYS} (the payment provider rejects true daily subscriptions). trialPeriodDays is at most ${MAX_FREE_TRIAL_DAYS}, only on recurring custom lines, and must match the trial length of every other recurring line in the order (catalogue plan or custom).`;
+var CREATE_ORDER_BOUNDS = `currency is one of ${SUPPORTED_CURRENCIES.join(", ")}. unitPrice is at most ${formatAmountCeilings()} in the order currency, and so is each line (unitPrice x quantity) and the order total; quantity is at most ${MAX_ORDER_ITEM_QUANTITY}; periodLength is at most one year of the billingPeriod (${formatPeriodCaps(MAX_ORDER_PERIOD_LENGTH_BY_BILLING_PERIOD)}). When billingPeriod is "day", periodLength must be at least ${MIN_WHOP_BILLING_PERIOD_DAYS} (the payment provider rejects true daily subscriptions). trialPeriodDays is at most ${MAX_FREE_TRIAL_DAYS}, only on recurring custom lines, and must match the trial length of every other recurring line in the order (catalogue plan or custom).`;
 var CREATE_PRODUCT_STATUS_NOTE = "Optional `status` ('draft' | 'active' | 'archived') defaults to 'active' \u2014 the product is created live and purchasable immediately via its checkout link, regardless of status. Pass `status: 'draft'` only when the end user explicitly asks for a draft or temporary/not-yet-ready product.";
 var CREATE_PRODUCT_COPY_CAPS = `Product \`name\` (<=${PRODUCT_NAME_MAX} chars), product \`description\` (<=${PRODUCT_DESCRIPTION_MAX} chars) and plan \`description\` (<=${PLAN_DESCRIPTION_MAX} chars) are all short one-line copy \u2014 if yours is longer, shorten it before calling and put the full version in that plan's \`richDescription\` (<=${PLAN_RICH_DESCRIPTION_MAX} chars), which the hosted checkout page renders as plain text beneath the short description (newlines preserved, markup not interpreted). \`richDescription\` is per plan, so product-level copy that overflows must still be edited down.`;
 var TRANSACTION_STATUS_RULE = 'Status: only "succeeded" means paid. "pending" is not yet confirmed by the payment provider, so never report a pending transaction as paid. "partially_refunded" means some but not all of the amount was refunded; "refunded", "failed" and "disputed" mean what they say.';
@@ -25650,18 +25799,17 @@ function buildPlanCheckoutUrl(params) {
 }
 
 // src/tools/product/stored-plan-summary.ts
-var import_currency4 = __toESM(require_currency(), 1);
+var import_currency5 = __toESM(require_currency(), 1);
 
 // src/shared/format-price.ts
-var import_currency3 = __toESM(require_currency(), 1);
+var import_currency4 = __toESM(require_currency(), 1);
 function formatPrice(amount, currencyCode3) {
-  const price = (0, import_currency3.default)(amount);
+  const price = (0, import_currency4.default)(amount);
   const code = currencyCode3.toUpperCase();
   try {
     return new Intl.NumberFormat("en-US", {
       style: "currency",
-      currency: code,
-      minimumFractionDigits: 2
+      currency: code
     }).format(price.value);
   } catch {
     return `${price.toString()} ${code}`;
@@ -25702,12 +25850,19 @@ function buildAmountWarnings(plans) {
   );
 }
 function looksLikeCents(plan) {
-  return plan.type !== "free-access" && Number.isInteger(plan.amount) && plan.amount >= CENTS_SUSPECT_FLOOR_MULTIPLE * getMinPaidPlanAmount(plan.currency);
+  return plan.type !== "free-access" && hasMinorUnit(plan.currency) && Number.isInteger(plan.amount) && plan.amount >= CENTS_SUSPECT_FLOOR_MULTIPLE * getMinPaidPlanAmount(plan.currency);
 }
 function formatCentsWarning(plan, index) {
-  const asCents = (0, import_currency4.default)(plan.amount).divide(100).value;
+  const asCents = (0, import_currency5.default)(plan.amount).divide(100).value;
   return `plans.${index} ("${plan.name}"): amount ${plan.amount} is stored as ${formatPrice(plan.amount, plan.currency)}, because amounts are in major units, not cents. If the user meant ${formatPrice(asCents, plan.currency)}, call update_plan with amount ${asCents} before sharing the checkout link; otherwise no action is needed.`;
 }
+function hasMinorUnit(currencyCode3) {
+  try {
+    return currencyFractionDigits(currencyCode3) > 0;
+  } catch {
+    return true;
+  }
+}
 
 // src/tools/product/create-product.tool.ts
 var backendCreatedProductShapeSchema = external_exports.object({
@@ -27810,6 +27965,7 @@ var DEFAULT_ALLOWED_MCP_ORIGIN_HOSTNAMES = [
   "grok.com",
   "www.grok.com",
   "x.ai",
+  "antigravity.google",
   "gemini.google.com",
   "aistudio.google.com",
   "cursor.com",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payments-ai/mcp",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "private": false,
   "description": "MCP for Payments AI",
   "repository": {