@ar-agents/mercadopago 0.10.0 → 0.12.0

package/dist/index.cjs

@@ -228,6 +228,23 @@ var DEFAULT_BASE_URL = "https://api.mercadopago.com";
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function randomUuid() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) {
+    return c.randomUUID();
+  }
+  if (c?.getRandomValues) {
+    const bytes = new Uint8Array(16);
+    c.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  }
+  throw new Error(
+    "MercadoPagoClient: no Web Crypto available for idempotency key generation. This shouldn't happen on Node 19+, Edge Runtime, or modern browsers."
+  );
+}
 var MercadoPagoClient = class {
   accessToken;
   baseUrl;
@@ -271,8 +288,10 @@ var MercadoPagoClient = class {
       Authorization: `Bearer ${this.accessToken}`,
       "Content-Type": "application/json"
     };
-    if (options?.idempotencyKey) {
-      headers["X-Idempotency-Key"] = options.idempotencyKey;
+    const isMutatingPost = method === "POST";
+    const idempotencyKey = options?.idempotencyKey ?? (isMutatingPost ? randomUuid() : void 0);
+    if (idempotencyKey) {
+      headers["X-Idempotency-Key"] = idempotencyKey;
     }
     const trace = this.traceContext?.();
     if (trace?.traceId && trace?.spanId) {
@@ -2429,6 +2448,377 @@ function paginateSubscriptionPayments(client, preapprovalId, opts = {}) {
   );
 }
 
+// src/tax-id.ts
+function validateTaxId(input, type) {
+  switch (type) {
+    case "DNI":
+      return validateAR_DNI(input);
+    case "CUIT":
+    case "CUIL":
+      return validateAR_CUIT(input, type);
+    case "CPF":
+      return validateBR_CPF(input);
+    case "CNPJ":
+      return validateBR_CNPJ(input);
+    case "RFC":
+      return validateMX_RFC(input);
+    case "RUT_CL":
+      return validateCL_RUT(input);
+    case "NIT":
+      return validateCO_NIT(input);
+    case "RUT_UY":
+      return validateUY_RUT(input);
+    case "RUC":
+      return validatePE_RUC(input);
+  }
+}
+function validateAR_DNI(input) {
+  const normalized = (input ?? "").replace(/\D/g, "");
+  if (normalized.length === 0) {
+    return failure(normalized, "DNI", "AR", "DNI vac\xEDo.");
+  }
+  if (normalized.length < 7 || normalized.length > 8) {
+    return failure(
+      normalized,
+      "DNI",
+      "AR",
+      `Debe tener 7 u 8 d\xEDgitos; recib\xED ${normalized.length}.`
+    );
+  }
+  return {
+    valid: true,
+    normalized,
+    formatted: normalized.replace(/^(\d{1,2})(\d{3})(\d{3})$/, "$1.$2.$3"),
+    type: "DNI",
+    country: "AR",
+    error: null
+  };
+}
+var AR_CHECK_WEIGHTS = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
+function validateAR_CUIT(input, type) {
+  const normalized = (input ?? "").replace(/\D/g, "");
+  if (normalized.length !== 11) {
+    return failure(
+      normalized,
+      type,
+      "AR",
+      `Debe tener 11 d\xEDgitos; recib\xED ${normalized.length}.`
+    );
+  }
+  const sum = AR_CHECK_WEIGHTS.reduce(
+    (acc, w, i) => acc + w * Number(normalized[i]),
+    0
+  );
+  const remainder = sum % 11;
+  const expected = remainder === 0 ? 0 : remainder === 1 ? 9 : 11 - remainder;
+  const actual = Number(normalized[10]);
+  if (actual !== expected) {
+    return failure(
+      normalized,
+      type,
+      "AR",
+      `D\xEDgito verificador inv\xE1lido. Esperado: ${expected}, recibido: ${actual}.`
+    );
+  }
+  return {
+    valid: true,
+    normalized,
+    formatted: `${normalized.slice(0, 2)}-${normalized.slice(2, 10)}-${normalized.slice(10)}`,
+    type,
+    country: "AR",
+    error: null
+  };
+}
+function validateBR_CPF(input) {
+  const normalized = (input ?? "").replace(/\D/g, "");
+  if (normalized.length !== 11) {
+    return failure(
+      normalized,
+      "CPF",
+      "BR",
+      `Debe tener 11 d\xEDgitos; recib\xED ${normalized.length}.`
+    );
+  }
+  if (/^(\d)\1{10}$/.test(normalized)) {
+    return failure(normalized, "CPF", "BR", "CPF inv\xE1lido (todos los d\xEDgitos iguales).");
+  }
+  const computeDigit = (slice, weights) => {
+    const sum = weights.reduce((acc, w, i) => acc + w * Number(slice[i]), 0);
+    const r = sum * 10 % 11;
+    return r === 10 ? 0 : r;
+  };
+  const d1 = computeDigit(normalized.slice(0, 9), [10, 9, 8, 7, 6, 5, 4, 3, 2]);
+  const d2 = computeDigit(
+    normalized.slice(0, 10),
+    [11, 10, 9, 8, 7, 6, 5, 4, 3, 2]
+  );
+  if (d1 !== Number(normalized[9]) || d2 !== Number(normalized[10])) {
+    return failure(normalized, "CPF", "BR", "D\xEDgitos verificadores inv\xE1lidos.");
+  }
+  return {
+    valid: true,
+    normalized,
+    formatted: normalized.replace(
+      /^(\d{3})(\d{3})(\d{3})(\d{2})$/,
+      "$1.$2.$3-$4"
+    ),
+    type: "CPF",
+    country: "BR",
+    error: null
+  };
+}
+function validateBR_CNPJ(input) {
+  const normalized = (input ?? "").replace(/\D/g, "");
+  if (normalized.length !== 14) {
+    return failure(
+      normalized,
+      "CNPJ",
+      "BR",
+      `Debe tener 14 d\xEDgitos; recib\xED ${normalized.length}.`
+    );
+  }
+  if (/^(\d)\1{13}$/.test(normalized)) {
+    return failure(normalized, "CNPJ", "BR", "CNPJ inv\xE1lido (todos los d\xEDgitos iguales).");
+  }
+  const computeDigit = (slice, weights) => {
+    const sum = weights.reduce((acc, w, i) => acc + w * Number(slice[i]), 0);
+    const r = sum % 11;
+    return r < 2 ? 0 : 11 - r;
+  };
+  const w1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+  const w2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+  const d1 = computeDigit(normalized.slice(0, 12), w1);
+  const d2 = computeDigit(normalized.slice(0, 13), w2);
+  if (d1 !== Number(normalized[12]) || d2 !== Number(normalized[13])) {
+    return failure(normalized, "CNPJ", "BR", "D\xEDgitos verificadores inv\xE1lidos.");
+  }
+  return {
+    valid: true,
+    normalized,
+    formatted: normalized.replace(
+      /^(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})$/,
+      "$1.$2.$3/$4-$5"
+    ),
+    type: "CNPJ",
+    country: "BR",
+    error: null
+  };
+}
+function validateMX_RFC(input) {
+  const normalized = (input ?? "").trim().toUpperCase().replace(/[\s-]/g, "");
+  const pfPattern = /^[A-ZÑ&]{4}\d{6}[A-Z\d]{3}$/;
+  const pmPattern = /^[A-ZÑ&]{3}\d{6}[A-Z\d]{3}$/;
+  if (!pfPattern.test(normalized) && !pmPattern.test(normalized)) {
+    return failure(
+      normalized,
+      "RFC",
+      "MX",
+      "RFC mal formado. Persona f\xEDsica: 4 letras + YYMMDD + 3 alfanum\xE9ricos. Persona moral: 3 letras + YYMMDD + 3 alfanum\xE9ricos."
+    );
+  }
+  return {
+    valid: true,
+    normalized,
+    formatted: normalized,
+    type: "RFC",
+    country: "MX",
+    error: null
+  };
+}
+function validateCL_RUT(input) {
+  const cleaned = (input ?? "").replace(/[^0-9kK]/g, "").toUpperCase();
+  if (cleaned.length < 2) {
+    return failure(cleaned, "RUT_CL", "CL", "RUT vac\xEDo o muy corto.");
+  }
+  const body = cleaned.slice(0, -1);
+  const dv = cleaned.slice(-1);
+  if (!/^\d+$/.test(body)) {
+    return failure(cleaned, "RUT_CL", "CL", "Cuerpo del RUT debe ser num\xE9rico.");
+  }
+  let sum = 0;
+  let multiplier = 2;
+  for (let i = body.length - 1; i >= 0; i--) {
+    sum += Number(body[i]) * multiplier;
+    multiplier = multiplier === 7 ? 2 : multiplier + 1;
+  }
+  const r = 11 - sum % 11;
+  const expected = r === 11 ? "0" : r === 10 ? "K" : String(r);
+  if (dv !== expected) {
+    return failure(
+      cleaned,
+      "RUT_CL",
+      "CL",
+      `D\xEDgito verificador inv\xE1lido. Esperado: ${expected}, recibido: ${dv}.`
+    );
+  }
+  return {
+    valid: true,
+    normalized: cleaned,
+    formatted: `${formatThousands(body)}-${dv}`,
+    type: "RUT_CL",
+    country: "CL",
+    error: null
+  };
+}
+var CO_NIT_WEIGHTS = [3, 7, 13, 17, 19, 23, 29, 37, 41, 43, 47, 53, 59, 67, 71];
+function validateCO_NIT(input) {
+  const cleaned = (input ?? "").replace(/[^0-9-]/g, "");
+  const parts = cleaned.split("-");
+  if (parts.length !== 2 || !/^\d+$/.test(parts[0]) || !/^\d$/.test(parts[1])) {
+    return failure(
+      cleaned,
+      "NIT",
+      "CO",
+      "NIT debe tener formato: d\xEDgitos + '-' + d\xEDgito verificador."
+    );
+  }
+  const body = parts[0];
+  const dv = Number(parts[1]);
+  if (body.length > CO_NIT_WEIGHTS.length) {
+    return failure(cleaned, "NIT", "CO", "NIT excesivamente largo.");
+  }
+  let sum = 0;
+  for (let i = 0; i < body.length; i++) {
+    sum += Number(body[body.length - 1 - i]) * CO_NIT_WEIGHTS[i];
+  }
+  const r = sum % 11;
+  const expected = r > 1 ? 11 - r : r;
+  if (dv !== expected) {
+    return failure(
+      cleaned,
+      "NIT",
+      "CO",
+      `D\xEDgito verificador inv\xE1lido. Esperado: ${expected}, recibido: ${dv}.`
+    );
+  }
+  return {
+    valid: true,
+    normalized: body + parts[1],
+    formatted: cleaned,
+    type: "NIT",
+    country: "CO",
+    error: null
+  };
+}
+var UY_RUT_WEIGHTS = [4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+function validateUY_RUT(input) {
+  const normalized = (input ?? "").replace(/\D/g, "");
+  if (normalized.length !== 12) {
+    return failure(
+      normalized,
+      "RUT_UY",
+      "UY",
+      `Debe tener 12 d\xEDgitos; recib\xED ${normalized.length}.`
+    );
+  }
+  let sum = 0;
+  for (let i = 0; i < 11; i++) {
+    sum += Number(normalized[i]) * UY_RUT_WEIGHTS[i];
+  }
+  const r = sum % 11;
+  const expected = r === 0 ? 0 : 11 - r;
+  if (Number(normalized[11]) !== expected) {
+    return failure(
+      normalized,
+      "RUT_UY",
+      "UY",
+      `D\xEDgito verificador inv\xE1lido. Esperado: ${expected}, recibido: ${normalized[11]}.`
+    );
+  }
+  return {
+    valid: true,
+    normalized,
+    formatted: normalized.replace(
+      /^(\d{2})(\d{6})(\d{3})(\d{1})$/,
+      "$1$2$3$4"
+    ),
+    type: "RUT_UY",
+    country: "UY",
+    error: null
+  };
+}
+var PE_RUC_WEIGHTS = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
+function validatePE_RUC(input) {
+  const normalized = (input ?? "").replace(/\D/g, "");
+  if (normalized.length !== 11) {
+    return failure(
+      normalized,
+      "RUC",
+      "PE",
+      `Debe tener 11 d\xEDgitos; recib\xED ${normalized.length}.`
+    );
+  }
+  const prefix = normalized.slice(0, 2);
+  if (!["10", "15", "17", "20"].includes(prefix)) {
+    return failure(
+      normalized,
+      "RUC",
+      "PE",
+      `Prefijo ${prefix} no v\xE1lido. Debe ser 10, 15, 17 o 20.`
+    );
+  }
+  let sum = 0;
+  for (let i = 0; i < 10; i++) {
+    sum += Number(normalized[i]) * PE_RUC_WEIGHTS[i];
+  }
+  const r = 11 - sum % 11;
+  const expected = r === 11 ? 0 : r === 10 ? 1 : r;
+  if (Number(normalized[10]) !== expected) {
+    return failure(
+      normalized,
+      "RUC",
+      "PE",
+      `D\xEDgito verificador inv\xE1lido. Esperado: ${expected}, recibido: ${normalized[10]}.`
+    );
+  }
+  return {
+    valid: true,
+    normalized,
+    formatted: normalized,
+    type: "RUC",
+    country: "PE",
+    error: null
+  };
+}
+function failure(normalized, type, country, error) {
+  return {
+    valid: false,
+    normalized,
+    formatted: null,
+    type,
+    country,
+    error
+  };
+}
+function formatThousands(s) {
+  return s.replace(/\B(?=(\d{3})+(?!\d))/g, ".");
+}
+function detectAndValidate(input, country) {
+  const cleaned = input.replace(/\D/g, "");
+  switch (country) {
+    case "AR": {
+      if (cleaned.length === 7 || cleaned.length === 8) return validateTaxId(input, "DNI");
+      if (cleaned.length === 11) return validateTaxId(input, "CUIT");
+      return null;
+    }
+    case "BR": {
+      if (cleaned.length === 11) return validateTaxId(input, "CPF");
+      if (cleaned.length === 14) return validateTaxId(input, "CNPJ");
+      return null;
+    }
+    case "MX":
+      return validateTaxId(input, "RFC");
+    case "CL":
+      return validateTaxId(input, "RUT_CL");
+    case "CO":
+      return validateTaxId(input, "NIT");
+    case "UY":
+      return validateTaxId(input, "RUT_UY");
+    case "PE":
+      return validateTaxId(input, "RUC");
+  }
+}
+
 // src/test-cards.ts
 var TEST_CARDS_AR = {
   VISA_CREDIT: {
@@ -2748,7 +3138,9 @@ var DEFAULT_DESCRIPTIONS = {
   confirm_3ds_challenge: "After the buyer completes a 3DS challenge (redirected back from challengeUrl), call this to poll MP and confirm whether the payment is now resolved. Polls get_payment up to N times with exponential backoff. Returns { payment, threeDs, resolved, attempts }. USE THIS as the FINAL step in the 3DS flow (after analyze_payment_3ds detected a challenge_required). Without confirming, the payment stays in 'pending' indefinitely from the buyer's perspective.",
   // ── v0.10 — Auto-paginate variants ──────────────────────────────────────
   search_payments_all: "Collect ALL payments matching a filter \u2014 auto-paginates under the hood. Returns an array (NOT paginated) so the agent doesn't have to manage offset/limit loops manually. SAFETY: pass `max_items` to cap; without it, MP traversal is bounded by the toolkit's internal max (10,000 items) to prevent runaway iterations. USE WHEN the agent needs to enumerate everything (e.g., monthly reconciliation 'all approved payments in March'). For agent flows that only need 'first N matches', pass `max_items` directly.",
-  list_settlements_all: "Collect ALL settlements matching a filter \u2014 auto-paginates. Pass `max_items` to cap. Use for monthly bank-conciliation reports."
+  list_settlements_all: "Collect ALL settlements matching a filter \u2014 auto-paginates. Pass `max_items` to cap. Use for monthly bank-conciliation reports.",
+  // ── v0.11 — TaxID validation cross-LATAM (pure) ──────────────────────────
+  validate_tax_id: "PURE HELPER (no network, sub-ms) \u2014 validates a tax ID against the appropriate country algorithm. Supports AR (DNI/CUIT/CUIL with modulo-11), BR (CPF/CNPJ with two-step weighted modulo), MX (RFC structure), CL (RUT with K digit), CO (NIT modulo-11), UY (RUT 12-digit checksum), PE (RUC 11-digit + prefix validation). Returns { valid, normalized, formatted, type, country, error }. USE THIS BEFORE submitting buyer identification to MP \u2014 invalid tax IDs cause 4xx rejections. Surface the Spanish error verbatim."
 };
 function mercadoPagoTools(client, options) {
   const desc = (name) => options.descriptions?.[name] ?? DEFAULT_DESCRIPTIONS[name];
@@ -2876,7 +3268,45 @@ function mercadoPagoTools(client, options) {
           type: zod.z.enum(["DNI", "CUIT", "CUIL"]),
           number: zod.z.string()
         }).optional().describe("Payer identification \u2014 required for some payment types in AR"),
-        statement_descriptor: zod.z.string().max(13).optional().describe("Shows on buyer's card statement (max 13 chars)")
+        statement_descriptor: zod.z.string().max(13).optional().describe("Shows on buyer's card statement (max 13 chars)"),
+        // v0.11 — fraud scoring enrichment fields
+        additional_info: zod.z.object({
+          ip_address: zod.z.string().optional().describe(
+            "Buyer's IP address (from req.headers X-Forwarded-For). STRONGLY RECOMMENDED for card payments \u2014 improves MP fraud scoring confidence and reduces false-positive rejections (3-5x lower per RG 5286/2023)."
+          ),
+          referral_url: zod.z.string().url().optional().describe("Page the buyer came from"),
+          payer: zod.z.object({
+            first_name: zod.z.string().optional(),
+            last_name: zod.z.string().optional(),
+            phone: zod.z.object({ area_code: zod.z.string().optional(), number: zod.z.string().optional() }).optional(),
+            address: zod.z.object({
+              zip_code: zod.z.string().optional(),
+              street_name: zod.z.string().optional(),
+              street_number: zod.z.number().optional()
+            }).optional(),
+            registration_date: zod.z.string().optional().describe("ISO 8601 \u2014 when the buyer registered on YOUR platform"),
+            authentication_type: zod.z.string().optional(),
+            is_prime_user: zod.z.boolean().optional(),
+            is_first_purchase_online: zod.z.boolean().optional(),
+            last_purchase: zod.z.string().optional()
+          }).optional(),
+          shipments: zod.z.object({
+            receiver_address: zod.z.object({
+              zip_code: zod.z.string().optional(),
+              street_name: zod.z.string().optional(),
+              street_number: zod.z.number().optional(),
+              floor: zod.z.string().optional(),
+              apartment: zod.z.string().optional(),
+              city_name: zod.z.string().optional(),
+              state_name: zod.z.string().optional(),
+              country_name: zod.z.string().optional()
+            }).optional(),
+            express_shipment: zod.z.boolean().optional(),
+            local_pickup: zod.z.boolean().optional()
+          }).optional()
+        }).optional().describe(
+          "Fraud scoring enrichment. Pass IP address + payer profile + shipping address for materially better approval rates on card payments."
+        )
       }),
       execute: async (input) => {
         const payment = await client.createPayment({
@@ -2889,6 +3319,7 @@ function mercadoPagoTools(client, options) {
           ...input.external_reference !== void 0 ? { externalReference: input.external_reference } : {},
           ...input.identification !== void 0 ? { identification: input.identification } : {},
           ...input.statement_descriptor !== void 0 ? { statementDescriptor: input.statement_descriptor } : {},
+          ...input.additional_info !== void 0 ? { additionalInfo: input.additional_info } : {},
           ...options.notificationUrl !== void 0 ? { notificationUrl: options.notificationUrl } : {},
           // Deterministic idempotency key — safe to retry, same inputs always
           // produce the same key (MP dedupes on its side).
@@ -4642,6 +5073,34 @@ function mercadoPagoTools(client, options) {
         const all = await collect(paginateSettlements(client, filterClean, opts));
         return { ok: true, count: all.length, settlements: all };
       }
+    }),
+    // ─────────────────────────────────────────────────────────────────────
+    // v0.11 — TaxID validation cross-LATAM (pure)
+    // ─────────────────────────────────────────────────────────────────────
+    validate_tax_id: ai.tool({
+      description: desc("validate_tax_id"),
+      inputSchema: zod.z.object({
+        tax_id: zod.z.string().min(1).describe(
+          "The tax ID to validate. Accepts any format with or without separators (20-41758101-5, 20.41758101.5, 20417581015 all work for AR CUIT)."
+        ),
+        type: zod.z.enum([
+          "DNI",
+          "CUIT",
+          "CUIL",
+          "CPF",
+          "CNPJ",
+          "RFC",
+          "RUT_CL",
+          "NIT",
+          "RUT_UY",
+          "RUC"
+        ]).describe(
+          "TaxID type. AR: DNI/CUIT/CUIL. BR: CPF (persona f\xEDsica) / CNPJ (persona jur\xEDdica). MX: RFC. CL: RUT_CL. CO: NIT. UY: RUT_UY. PE: RUC."
+        )
+      }),
+      execute: async ({ tax_id, type }) => {
+        return validateTaxId(tax_id, type);
+      }
     })
   };
 }
@@ -5152,6 +5611,123 @@ function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// src/middleware.ts
+function compose(...middlewares) {
+  return (tool2) => {
+    return middlewares.reduceRight((wrapped, mw) => mw(wrapped), tool2);
+  };
+}
+function withAuditLog(logger, operation, actor) {
+  return (tool2) => {
+    const original = tool2.execute;
+    if (!original) return tool2;
+    return {
+      ...tool2,
+      execute: (async (input, opts) => {
+        return logger.record({
+          operation,
+          input,
+          ...actor !== void 0 ? { actor } : {},
+          fn: () => original(input, opts)
+        });
+      })
+    };
+  };
+}
+function withRateLimit(limiter) {
+  return (tool2) => {
+    const original = tool2.execute;
+    if (!original) return tool2;
+    return {
+      ...tool2,
+      execute: (async (input, opts) => {
+        await limiter.acquire();
+        return original(input, opts);
+      })
+    };
+  };
+}
+function withMetrics(toolName, hook) {
+  return (tool2) => {
+    const original = tool2.execute;
+    if (!original) return tool2;
+    return {
+      ...tool2,
+      execute: (async (input, opts) => {
+        const t0 = Date.now();
+        try {
+          const result = await original(input, opts);
+          hook.onMetric({
+            toolName,
+            durationMs: Date.now() - t0,
+            success: true
+          });
+          return result;
+        } catch (err) {
+          hook.onMetric({
+            toolName,
+            durationMs: Date.now() - t0,
+            success: false,
+            errorCode: extractErrorCode2(err)
+          });
+          throw err;
+        }
+      })
+    };
+  };
+}
+var defaultShouldRetry = (err) => {
+  if (err && typeof err === "object" && "status" in err) {
+    const status = err.status;
+    if (typeof status === "number" && status >= 400 && status < 500) {
+      return false;
+    }
+  }
+  return true;
+};
+function withRetry(opts = {}) {
+  const maxAttempts = opts.maxAttempts ?? 3;
+  const baseBackoff = opts.baseBackoffMs ?? 250;
+  const shouldRetry = opts.shouldRetry ?? defaultShouldRetry;
+  return (tool2) => {
+    const original = tool2.execute;
+    if (!original) return tool2;
+    return {
+      ...tool2,
+      execute: (async (input, opts2) => {
+        let attempt = 0;
+        while (true) {
+          try {
+            return await original(input, opts2);
+          } catch (err) {
+            attempt++;
+            if (attempt >= maxAttempts || !shouldRetry(err, attempt)) {
+              throw err;
+            }
+            const delayMs = baseBackoff * Math.pow(2, attempt - 1);
+            opts.onRetry?.({ attempt, error: err, delayMs });
+            await new Promise((r) => setTimeout(r, delayMs));
+          }
+        }
+      })
+    };
+  };
+}
+function applyToAllTools(tools, middleware) {
+  const out = {};
+  for (const [name, tool2] of Object.entries(tools)) {
+    out[name] = middleware(tool2);
+  }
+  return out;
+}
+function extractErrorCode2(err) {
+  if (err && typeof err === "object") {
+    const e = err;
+    return e.code ?? e.name ?? "unknown_error";
+  }
+  return "unknown_error";
+}
+
 exports.AHORA_PROGRAM_PROMOS = AHORA_PROGRAM_PROMOS;
 exports.AR_ISSUER_PROMOS = AR_ISSUER_PROMOS;
 exports.AuditLogger = AuditLogger;
@@ -5178,12 +5754,15 @@ exports.TEST_PAYERS_AR = TEST_PAYERS_AR;
 exports.TokenBucketRateLimiter = TokenBucketRateLimiter;
 exports.WebhookDedup = WebhookDedup;
 exports.analyze3DS = analyze3DS;
+exports.applyToAllTools = applyToAllTools;
 exports.buildAuthorizeUrl = buildAuthorizeUrl;
 exports.buildTestCardScenario = buildTestCardScenario;
 exports.classifyError = classifyError;
 exports.collect = collect;
+exports.compose = compose;
 exports.computeMarketplaceFee = computeMarketplaceFee;
 exports.confirmChallengeAndPoll = confirmChallengeAndPoll;
+exports.detectAndValidate = detectAndValidate;
 exports.exchangeCodeForToken = exchangeCodeForToken;
 exports.expirationTimeMs = expirationTimeMs;
 exports.explainPaymentStatus = explainPaymentStatus;
@@ -5200,6 +5779,11 @@ exports.paginateSubscriptionPlans = paginateSubscriptionPlans;
 exports.paginateSubscriptions = paginateSubscriptions;
 exports.parseWebhookEvent = parseWebhookEvent;
 exports.refreshAccessToken = refreshAccessToken;
+exports.validateTaxId = validateTaxId;
 exports.verifyWebhookSignature = verifyWebhookSignature;
+exports.withAuditLog = withAuditLog;
+exports.withMetrics = withMetrics;
+exports.withRateLimit = withRateLimit;
+exports.withRetry = withRetry;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map