@solvapay/server 1.0.5 → 1.0.7

package/dist/index.cjs

@@ -4314,6 +4314,7 @@ __export(index_exports, {
   McpBearerAuthError: () => McpBearerAuthError,
   PaywallError: () => PaywallError,
   VIRTUAL_TOOL_DEFINITIONS: () => VIRTUAL_TOOL_DEFINITIONS,
+  activatePlanCore: () => activatePlanCore,
   buildAuthInfoFromBearer: () => buildAuthInfoFromBearer,
   cancelPurchaseCore: () => cancelPurchaseCore,
   createCheckoutSessionCore: () => createCheckoutSessionCore,
@@ -4322,10 +4323,12 @@ __export(index_exports, {
   createPaymentIntentCore: () => createPaymentIntentCore,
   createSolvaPay: () => createSolvaPay,
   createSolvaPayClient: () => createSolvaPayClient,
+  createTopupPaymentIntentCore: () => createTopupPaymentIntentCore,
   createVirtualTools: () => createVirtualTools,
   decodeJwtPayload: () => decodeJwtPayload,
   extractBearerToken: () => extractBearerToken,
   getAuthenticatedUserCore: () => getAuthenticatedUserCore,
+  getCustomerBalanceCore: () => getCustomerBalanceCore,
   getCustomerRefFromBearerAuthHeader: () => getCustomerRefFromBearerAuthHeader,
   getCustomerRefFromJwtPayload: () => getCustomerRefFromJwtPayload,
   getOAuthAuthorizationServerResponse: () => getOAuthAuthorizationServerResponse,
@@ -4334,7 +4337,9 @@ __export(index_exports, {
   isErrorResult: () => isErrorResult,
   jsonSchemaToZodRawShape: () => jsonSchemaToZodRawShape,
   listPlansCore: () => listPlansCore,
+  paywallErrorToClientPayload: () => paywallErrorToClientPayload,
   processPaymentIntentCore: () => processPaymentIntentCore,
+  reactivatePurchaseCore: () => reactivatePurchaseCore,
   registerVirtualToolsMcpImpl: () => registerVirtualToolsMcpImpl,
   syncCustomerCore: () => syncCustomerCore,
   verifyWebhook: () => verifyWebhook,
@@ -4379,12 +4384,10 @@ function createSolvaPayClient(opts) {
     // POST: /v1/sdk/usages
     async trackUsage(params) {
       const url = `${base}/v1/sdk/usages`;
-      const { customerRef, ...rest } = params;
-      const body = { ...rest, customerId: customerRef };
       const res = await fetch(url, {
         method: "POST",
         headers,
-        body: JSON.stringify(body)
+        body: JSON.stringify(params)
       });
       if (!res.ok) {
         const error = await res.text();
@@ -4629,7 +4632,7 @@ function createSolvaPayClient(opts) {
         body: JSON.stringify({
           productRef: params.productRef,
           planRef: params.planRef,
-          customerReference: params.customerRef
+          customerRef: params.customerRef
         })
       });
       if (!res.ok) {
@@ -4637,8 +4640,32 @@ function createSolvaPayClient(opts) {
         log(`\u274C API Error: ${res.status} - ${error}`);
         throw new import_core.SolvaPayError(`Create payment intent failed (${res.status}): ${error}`);
       }
-      const result = await res.json();
-      return result;
+      return await res.json();
+    },
+    // POST: /v1/sdk/payment-intents (purpose: credit_topup)
+    async createTopupPaymentIntent(params) {
+      const idempotencyKey = params.idempotencyKey || `topup-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const url = `${base}/v1/sdk/payment-intents`;
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          ...headers,
+          "Idempotency-Key": idempotencyKey
+        },
+        body: JSON.stringify({
+          customerRef: params.customerRef,
+          purpose: "credit_topup",
+          amount: params.amount,
+          currency: params.currency,
+          description: params.description
+        })
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        log(`\u274C API Error: ${res.status} - ${error}`);
+        throw new import_core.SolvaPayError(`Create topup payment intent failed (${res.status}): ${error}`);
+      }
+      return await res.json();
     },
     // POST: /v1/sdk/payment-intents/{paymentIntentId}/process
     async processPaymentIntent(params) {
@@ -4715,6 +4742,54 @@ function createSolvaPayClient(opts) {
       }
       return result;
     },
+    // POST: /v1/sdk/purchases/{purchaseRef}/reactivate
+    async reactivatePurchase(params) {
+      const url = `${base}/v1/sdk/purchases/${params.purchaseRef}/reactivate`;
+      const res = await fetch(url, {
+        method: "POST",
+        headers
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        log(`\u274C API Error: ${res.status} - ${error}`);
+        if (res.status === 404) {
+          throw new import_core.SolvaPayError(`Purchase not found: ${error}`);
+        }
+        if (res.status === 400) {
+          throw new import_core.SolvaPayError(
+            `Purchase cannot be reactivated: ${error}`
+          );
+        }
+        throw new import_core.SolvaPayError(`Reactivate purchase failed (${res.status}): ${error}`);
+      }
+      const responseText = await res.text();
+      let responseData;
+      try {
+        responseData = JSON.parse(responseText);
+      } catch (parseError) {
+        log(`\u274C Failed to parse response as JSON: ${parseError}`);
+        throw new import_core.SolvaPayError(
+          `Invalid JSON response from reactivate purchase endpoint: ${responseText.substring(0, 200)}`
+        );
+      }
+      if (!responseData || typeof responseData !== "object") {
+        log(`\u274C Invalid response structure: ${JSON.stringify(responseData)}`);
+        throw new import_core.SolvaPayError(`Invalid response structure from reactivate purchase endpoint`);
+      }
+      let result;
+      if (responseData.purchase && typeof responseData.purchase === "object") {
+        result = responseData.purchase;
+      } else if (responseData.reference) {
+        result = responseData;
+      } else {
+        result = responseData.purchase || responseData;
+      }
+      if (!result || typeof result !== "object") {
+        log(`\u274C Invalid purchase data in response. Full response:`, responseData);
+        throw new import_core.SolvaPayError(`Invalid purchase data in reactivate purchase response`);
+      }
+      return result;
+    },
     // POST: /v1/sdk/user-info
     async getUserInfo(params) {
       const url = `${base}/v1/sdk/user-info`;
@@ -4730,6 +4805,20 @@ function createSolvaPayClient(opts) {
       }
       return await res.json();
     },
+    // GET: /v1/sdk/customers/:customerRef/balance
+    async getCustomerBalance(params) {
+      const url = `${base}/v1/sdk/customers/${params.customerRef}/balance`;
+      const res = await fetch(url, {
+        method: "GET",
+        headers
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        log(`\u274C API Error: ${res.status} - ${error}`);
+        throw new import_core.SolvaPayError(`Get customer balance failed (${res.status}): ${error}`);
+      }
+      return await res.json();
+    },
     // POST: /v1/sdk/checkout-sessions
     async createCheckoutSession(params) {
       const url = `${base}/v1/sdk/checkout-sessions`;
@@ -4761,6 +4850,21 @@ function createSolvaPayClient(opts) {
       }
       const result = await res.json();
       return result;
+    },
+    // POST: /v1/sdk/activate
+    async activatePlan(params) {
+      const url = `${base}/v1/sdk/activate`;
+      const res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(params)
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        log(`\u274C API Error: ${res.status} - ${error}`);
+        throw new import_core.SolvaPayError(`Activate plan failed (${res.status}): ${error}`);
+      }
+      return await res.json();
     }
   };
 }
@@ -4916,6 +5020,24 @@ var PaywallError = class extends Error {
     this.name = "PaywallError";
   }
 };
+function paywallErrorToClientPayload(error) {
+  const sc = error.structuredContent;
+  const base = {
+    success: false,
+    error: sc.kind === "activation_required" ? "Activation required" : "Payment required",
+    product: sc.product,
+    checkoutUrl: sc.checkoutUrl,
+    message: sc.message
+  };
+  if (sc.kind === "activation_required") {
+    base.kind = "activation_required";
+    if (sc.plans !== void 0) base.plans = sc.plans;
+    if (sc.balance !== void 0) base.balance = sc.balance;
+    if (sc.productDetails !== void 0) base.productDetails = sc.productDetails;
+    if (sc.confirmationUrl !== void 0) base.confirmationUrl = sc.confirmationUrl;
+  }
+  return base;
+}
 var sharedCustomerLookupDeduplicator = createRequestDeduplicator({
   cacheTTL: 6e4,
   // Cache results for 60 seconds (reduces API calls significantly)
@@ -4954,8 +5076,6 @@ var SolvaPayPaywall = class {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   async protect(handler, metadata = {}, getCustomerRef) {
     const product = this.resolveProduct(metadata);
-    const configuredPlanRef = metadata.plan?.trim();
-    const usagePlanRef = configuredPlanRef || "unspecified";
     const usageType = metadata.usageType || "requests";
     return async (args) => {
       const startTime = Date.now();
@@ -4969,12 +5089,13 @@ var SolvaPayPaywall = class {
       }
       let resolvedMeterName;
       try {
-        const limitsCacheKey = `${backendCustomerRef}:${product}:${configuredPlanRef || ""}:${usageType}`;
+        const limitsCacheKey = `${backendCustomerRef}:${product}:${usageType}`;
         const cachedLimits = this.limitsCache.get(limitsCacheKey);
         const now = Date.now();
         let withinLimits;
         let remaining;
         let checkoutUrl;
+        let lastLimitsCheck;
         const hasFreshCachedLimits = cachedLimits && now - cachedLimits.timestamp < this.limitsCacheTTL;
         if (hasFreshCachedLimits) {
           checkoutUrl = cachedLimits.checkoutUrl;
@@ -4998,9 +5119,9 @@ var SolvaPayPaywall = class {
           const limitsCheck = await this.apiClient.checkLimits({
             customerRef: backendCustomerRef,
             productRef: product,
-            ...configuredPlanRef ? { planRef: configuredPlanRef } : {},
             meterName: usageType
           });
+          lastLimitsCheck = limitsCheck;
           withinLimits = limitsCheck.withinLimits;
           remaining = limitsCheck.remaining;
           checkoutUrl = limitsCheck.checkoutUrl;
@@ -5023,12 +5144,25 @@ var SolvaPayPaywall = class {
           this.trackUsage(
             backendCustomerRef,
             product,
-            usagePlanRef,
             resolvedMeterName || usageType,
             "paywall",
             requestId,
             latencyMs2
           );
+          if (lastLimitsCheck?.activationRequired) {
+            const confirmationUrl = lastLimitsCheck.confirmationUrl;
+            const payCheckoutUrl = confirmationUrl || lastLimitsCheck.checkoutUrl || checkoutUrl || "";
+            throw new PaywallError("Activation required", {
+              kind: "activation_required",
+              product,
+              message: "Product activation is required before this tool can be used.",
+              checkoutUrl: payCheckoutUrl,
+              confirmationUrl,
+              plans: lastLimitsCheck.plans,
+              balance: lastLimitsCheck.balance,
+              productDetails: lastLimitsCheck.product
+            });
+          }
           throw new PaywallError("Payment required", {
             kind: "payment_required",
             product,
@@ -5041,7 +5175,6 @@ var SolvaPayPaywall = class {
         this.trackUsage(
           backendCustomerRef,
           product,
-          usagePlanRef,
           resolvedMeterName || usageType,
           "success",
           requestId,
@@ -5060,7 +5193,6 @@ var SolvaPayPaywall = class {
           this.trackUsage(
             backendCustomerRef,
             product,
-            usagePlanRef,
             resolvedMeterName || usageType,
             "fail",
             requestId,
@@ -5131,7 +5263,8 @@ var SolvaPayPaywall = class {
       this.customerCreationAttempts.add(customerRef);
       try {
         const createParams = {
-          email: options?.email || `${customerRef}-${Date.now()}@auto-created.local`
+          email: options?.email || `${customerRef}-${Date.now()}@auto-created.local`,
+          metadata: {}
         };
         if (options?.name) {
           createParams.name = options.name;
@@ -5155,7 +5288,10 @@ var SolvaPayPaywall = class {
                 return searchResult.customerRef;
               }
             } catch (lookupError) {
-              this.log(`\u26A0\uFE0F Failed to lookup existing customer by externalRef after 409:`, lookupError instanceof Error ? lookupError.message : lookupError);
+              this.log(
+                `\u26A0\uFE0F Failed to lookup existing customer by externalRef after 409:`,
+                lookupError instanceof Error ? lookupError.message : lookupError
+              );
             }
           }
           const isEmailConflict = errorMessage.includes("email") || errorMessage.includes("identifier email");
@@ -5178,7 +5314,8 @@ var SolvaPayPaywall = class {
             try {
               const retryParams = {
                 email: `${customerRef}-${Date.now()}@auto-created.local`,
-                externalRef
+                externalRef,
+                metadata: {}
               };
               if (options?.name) {
                 retryParams.name = options.name;
@@ -5215,14 +5352,14 @@ var SolvaPayPaywall = class {
     }
     return backendRef;
   }
-  async trackUsage(customerRef, _productRef, _planRef, action, outcome, requestId, actionDuration) {
+  async trackUsage(customerRef, productRef, action, outcome, requestId, actionDuration) {
     await withRetry(
       () => this.apiClient.trackUsage({
         customerRef,
         actionType: "api_call",
         units: 1,
         outcome,
-        productReference: _productRef,
+        productRef,
         duration: actionDuration,
         metadata: { action: action || "api_requests", requestId },
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -5474,8 +5611,10 @@ var McpAdapter = class {
       const ref = await this.options.getCustomerRef(args, extra);
       return AdapterUtils.ensureCustomerRef(ref);
     }
-    const customerRefFromExtra = extra?.authInfo?.extra?.customer_ref;
-    const customerRef = typeof customerRefFromExtra === "string" && customerRefFromExtra.trim() ? customerRefFromExtra.trim() : "anonymous";
+    const customerRefFromExtra = typeof extra?.authInfo?.extra?.customer_ref === "string" ? String(extra.authInfo.extra.customer_ref) : void 0;
+    const customerRefFromArgs = typeof args.auth === "object" && args.auth !== null && typeof args.auth.customer_ref === "string" ? String(args.auth.customer_ref) : void 0;
+    const directCustomerRef = typeof args.customer_ref === "string" ? args.customer_ref : void 0;
+    const customerRef = (customerRefFromExtra || customerRefFromArgs || directCustomerRef || "anonymous").trim();
     return AdapterUtils.ensureCustomerRef(customerRef);
   }
   formatResponse(result, _context) {
@@ -5499,17 +5638,7 @@ var McpAdapter = class {
         content: [
           {
             type: "text",
-            text: JSON.stringify(
-              {
-                success: false,
-                error: "Payment required",
-                product: error.structuredContent.product,
-                checkoutUrl: error.structuredContent.checkoutUrl,
-                message: error.structuredContent.message
-              },
-              null,
-              2
-            )
+            text: JSON.stringify(paywallErrorToClientPayload(error), null, 2)
           }
         ],
         isError: true,
@@ -5796,6 +5925,12 @@ function createSolvaPay(config) {
       }
       return apiClient.createPaymentIntent(params);
     },
+    createTopupPaymentIntent(params) {
+      if (!apiClient.createTopupPaymentIntent) {
+        throw new import_core2.SolvaPayError("createTopupPaymentIntent is not available on this API client");
+      }
+      return apiClient.createTopupPaymentIntent(params);
+    },
     processPaymentIntent(params) {
       if (!apiClient.processPaymentIntent) {
         throw new import_core2.SolvaPayError("processPaymentIntent is not available on this API client");
@@ -5812,11 +5947,17 @@ function createSolvaPay(config) {
       if (!apiClient.createCustomer) {
         throw new import_core2.SolvaPayError("createCustomer is not available on this API client");
       }
-      return apiClient.createCustomer(params);
+      return apiClient.createCustomer({ ...params, metadata: params.metadata ?? {} });
     },
     getCustomer(params) {
       return apiClient.getCustomer(params);
     },
+    getCustomerBalance(params) {
+      if (!apiClient.getCustomerBalance) {
+        throw new import_core2.SolvaPayError("getCustomerBalance is not available on this API client");
+      }
+      return apiClient.getCustomerBalance(params);
+    },
     createCheckoutSession(params) {
       return apiClient.createCheckoutSession({
         customerRef: params.customerRef,
@@ -5827,6 +5968,12 @@ function createSolvaPay(config) {
     createCustomerSession(params) {
       return apiClient.createCustomerSession(params);
     },
+    activatePlan(params) {
+      if (!apiClient.activatePlan) {
+        throw new import_core2.SolvaPayError("activatePlan is not available on this API client");
+      }
+      return apiClient.activatePlan(params);
+    },
     bootstrapMcpProduct(params) {
       if (!apiClient.bootstrapMcpProduct) {
         throw new import_core2.SolvaPayError("bootstrapMcpProduct is not available on this API client");
@@ -5848,9 +5995,8 @@ function createSolvaPay(config) {
     // Payable API for framework-specific handlers
     payable(options = {}) {
       const product = options.productRef || options.product || process.env.SOLVAPAY_PRODUCT || "default-product";
-      const plan = options.planRef || options.plan;
       const usageType = options.usageType || "requests";
-      const metadata = { product, plan, usageType };
+      const metadata = { product, usageType };
       return {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         http(businessLogic, adapterOptions) {
@@ -6188,6 +6334,24 @@ async function syncCustomerCore(request, options = {}) {
     return handleRouteError(error, "Sync customer", "Failed to sync customer");
   }
 }
+async function getCustomerBalanceCore(request, options = {}) {
+  try {
+    const userResult = await getAuthenticatedUserCore(request);
+    if (isErrorResult(userResult)) {
+      return userResult;
+    }
+    const { userId, email, name } = userResult;
+    const solvaPay = options.solvaPay || createSolvaPay();
+    const customerRef = await solvaPay.ensureCustomer(userId, userId, {
+      email: email || void 0,
+      name: name || void 0
+    });
+    const result = await solvaPay.getCustomerBalance({ customerRef });
+    return result;
+  } catch (error) {
+    return handleRouteError(error, "Get customer credits", "Failed to get customer credits");
+  }
+}
 
 // src/helpers/payment.ts
 async function createPaymentIntentCore(request, body, options = {}) {
@@ -6214,7 +6378,7 @@ async function createPaymentIntentCore(request, body, options = {}) {
       customerRef
     });
     return {
-      id: paymentIntent.id,
+      processorPaymentId: paymentIntent.processorPaymentId,
       clientSecret: paymentIntent.clientSecret,
       publishableKey: paymentIntent.publishableKey,
       accountId: paymentIntent.accountId,
@@ -6224,6 +6388,57 @@ async function createPaymentIntentCore(request, body, options = {}) {
     return handleRouteError(error, "Create payment intent", "Payment intent creation failed");
   }
 }
+async function createTopupPaymentIntentCore(request, body, options = {}) {
+  try {
+    if (!body.amount || body.amount <= 0) {
+      return {
+        error: "Missing or invalid amount: must be a positive number",
+        status: 400
+      };
+    }
+    if (!body.currency) {
+      return {
+        error: "Missing required parameter: currency",
+        status: 400
+      };
+    }
+    if (body.currency !== body.currency.toUpperCase()) {
+      return {
+        error: `Invalid currency "${body.currency}": must be an uppercase ISO 4217 code (e.g. "USD", "EUR")`,
+        status: 400
+      };
+    }
+    const customerResult = await syncCustomerCore(request, {
+      solvaPay: options.solvaPay,
+      includeEmail: options.includeEmail,
+      includeName: options.includeName
+    });
+    if (isErrorResult(customerResult)) {
+      return customerResult;
+    }
+    const customerRef = customerResult;
+    const solvaPay = options.solvaPay || createSolvaPay();
+    const paymentIntent = await solvaPay.createTopupPaymentIntent({
+      customerRef,
+      amount: body.amount,
+      currency: body.currency,
+      description: body.description
+    });
+    return {
+      processorPaymentId: paymentIntent.processorPaymentId,
+      clientSecret: paymentIntent.clientSecret,
+      publishableKey: paymentIntent.publishableKey,
+      accountId: paymentIntent.accountId,
+      customerRef
+    };
+  } catch (error) {
+    return handleRouteError(
+      error,
+      "Create topup payment intent",
+      "Topup payment intent creation failed"
+    );
+  }
+}
 async function processPaymentIntentCore(request, body, options = {}) {
   try {
     if (!body.paymentIntentId || !body.productRef) {
@@ -6386,6 +6601,103 @@ async function cancelPurchaseCore(request, body, options = {}) {
     return handleRouteError(error, "Cancel purchase", "Failed to cancel purchase");
   }
 }
+async function reactivatePurchaseCore(request, body, options = {}) {
+  try {
+    if (!body.purchaseRef) {
+      return {
+        error: "Missing required parameter: purchaseRef is required",
+        status: 400
+      };
+    }
+    const solvaPay = options.solvaPay || createSolvaPay();
+    if (!solvaPay.apiClient.reactivatePurchase) {
+      return {
+        error: "Reactivate purchase method not available on SDK client",
+        status: 500
+      };
+    }
+    let reactivatedPurchase = await solvaPay.apiClient.reactivatePurchase({
+      purchaseRef: body.purchaseRef
+    });
+    if (!reactivatedPurchase || typeof reactivatedPurchase !== "object") {
+      return {
+        error: "Invalid response from reactivate purchase endpoint",
+        status: 500
+      };
+    }
+    const responseObj = reactivatedPurchase;
+    if (responseObj.purchase && typeof responseObj.purchase === "object") {
+      reactivatedPurchase = responseObj.purchase;
+    }
+    if (!reactivatedPurchase.reference) {
+      return {
+        error: "Reactivate purchase response missing required fields",
+        status: 500
+      };
+    }
+    if (reactivatedPurchase.cancelledAt) {
+      return {
+        error: `Purchase reactivation failed: cancelledAt is still set`,
+        status: 500
+      };
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    return reactivatedPurchase;
+  } catch (error) {
+    if (error instanceof import_core4.SolvaPayError) {
+      const errorMessage = error.message;
+      if (errorMessage.includes("not found")) {
+        return {
+          error: "Purchase not found",
+          status: 404,
+          details: errorMessage
+        };
+      }
+      if (errorMessage.includes("cannot be reactivated") || errorMessage.includes("not pending cancellation") || errorMessage.includes("already been fully cancelled") || errorMessage.includes("already ended")) {
+        return {
+          error: "Purchase cannot be reactivated",
+          status: 400,
+          details: errorMessage
+        };
+      }
+      return {
+        error: errorMessage,
+        status: 500,
+        details: errorMessage
+      };
+    }
+    return handleRouteError(error, "Reactivate purchase", "Failed to reactivate purchase");
+  }
+}
+
+// src/helpers/activation.ts
+async function activatePlanCore(request, body, options = {}) {
+  try {
+    if (!body.productRef || !body.planRef) {
+      return {
+        error: "Missing required parameters: productRef and planRef are required",
+        status: 400
+      };
+    }
+    const customerResult = await syncCustomerCore(request, {
+      solvaPay: options.solvaPay,
+      includeEmail: options.includeEmail,
+      includeName: options.includeName
+    });
+    if (isErrorResult(customerResult)) {
+      return customerResult;
+    }
+    const customerRef = customerResult;
+    const solvaPay = options.solvaPay || createSolvaPay();
+    return await solvaPay.activatePlan({
+      customerRef,
+      productRef: body.productRef,
+      planRef: body.planRef
+    });
+  } catch (error) {
+    return handleRouteError(error, "Activate plan", "Plan activation failed");
+  }
+}
 
 // src/helpers/plans.ts
 var import_core5 = require("@solvapay/core");
@@ -6470,6 +6782,7 @@ function verifyWebhook({
   McpBearerAuthError,
   PaywallError,
   VIRTUAL_TOOL_DEFINITIONS,
+  activatePlanCore,
   buildAuthInfoFromBearer,
   cancelPurchaseCore,
   createCheckoutSessionCore,
@@ -6478,10 +6791,12 @@ function verifyWebhook({
   createPaymentIntentCore,
   createSolvaPay,
   createSolvaPayClient,
+  createTopupPaymentIntentCore,
   createVirtualTools,
   decodeJwtPayload,
   extractBearerToken,
   getAuthenticatedUserCore,
+  getCustomerBalanceCore,
   getCustomerRefFromBearerAuthHeader,
   getCustomerRefFromJwtPayload,
   getOAuthAuthorizationServerResponse,
@@ -6490,7 +6805,9 @@ function verifyWebhook({
   isErrorResult,
   jsonSchemaToZodRawShape,
   listPlansCore,
+  paywallErrorToClientPayload,
   processPaymentIntentCore,
+  reactivatePurchaseCore,
   registerVirtualToolsMcpImpl,
   syncCustomerCore,
   verifyWebhook,