@solvapay/server 1.0.0-preview.19 → 1.0.0-preview.20

package/dist/edge.js

@@ -65,17 +65,21 @@ function createSolvaPayClient(opts) {
       const result = await res.json();
       return result;
     },
-    // GET: /v1/sdk/customers/{reference} or /v1/sdk/customers?externalRef={externalRef}
+    // GET: /v1/sdk/customers/{reference} or /v1/sdk/customers?externalRef={externalRef}|email={email}
     async getCustomer(params) {
       let url;
       let isByExternalRef = false;
+      let isByEmail = false;
       if (params.externalRef) {
         url = `${base}/v1/sdk/customers?externalRef=${encodeURIComponent(params.externalRef)}`;
         isByExternalRef = true;
+      } else if (params.email) {
+        url = `${base}/v1/sdk/customers?email=${encodeURIComponent(params.email)}`;
+        isByEmail = true;
       } else if (params.customerRef) {
         url = `${base}/v1/sdk/customers/${params.customerRef}`;
       } else {
-        throw new SolvaPayError("Either customerRef or externalRef must be provided");
+        throw new SolvaPayError("One of customerRef, externalRef, or email must be provided");
       }
       const res = await fetch(url, {
         method: "GET",
@@ -88,25 +92,27 @@ function createSolvaPayClient(opts) {
       }
       const result = await res.json();
       let customer = result;
-      if (isByExternalRef) {
-        const customers = Array.isArray(result) ? result : result.customers || [];
-        if (customers.length === 0) {
+      if (isByExternalRef || isByEmail) {
+        const directCustomer = result && typeof result === "object" && (result.reference || result.customerRef || result.externalRef) ? result : void 0;
+        const wrappedCustomer = result && typeof result === "object" && result.customer ? result.customer : void 0;
+        const customers = Array.isArray(result) ? result : result && typeof result === "object" && Array.isArray(result.customers) ? result.customers : [];
+        customer = directCustomer || wrappedCustomer || customers[0];
+        if (!customer) {
           throw new SolvaPayError(`No customer found with externalRef: ${params.externalRef}`);
         }
-        customer = customers[0];
       }
       return {
         customerRef: customer.reference || customer.customerRef,
         email: customer.email,
         name: customer.name,
         externalRef: customer.externalRef,
-        subscriptions: customer.subscriptions || []
+        purchases: customer.purchases || []
       };
     },
-    // Management methods (primarily for integration tests)
-    // GET: /v1/sdk/agents
-    async listAgents() {
-      const url = `${base}/v1/sdk/agents`;
+    // Product management methods (primarily for integration tests)
+    // GET: /v1/sdk/products
+    async listProducts() {
+      const url = `${base}/v1/sdk/products`;
       const res = await fetch(url, {
         method: "GET",
         headers
@@ -114,18 +120,18 @@ function createSolvaPayClient(opts) {
       if (!res.ok) {
         const error = await res.text();
         log(`\u274C API Error: ${res.status} - ${error}`);
-        throw new SolvaPayError(`List agents failed (${res.status}): ${error}`);
+        throw new SolvaPayError(`List products failed (${res.status}): ${error}`);
       }
       const result = await res.json();
-      const agents = Array.isArray(result) ? result : result.agents || [];
-      return agents.map((agent) => ({
-        ...agent,
-        ...agent.data || {}
+      const products = Array.isArray(result) ? result : result.products || [];
+      return products.map((product) => ({
+        ...product,
+        ...product.data || {}
       }));
     },
-    // POST: /v1/sdk/agents
-    async createAgent(params) {
-      const url = `${base}/v1/sdk/agents`;
+    // POST: /v1/sdk/products
+    async createProduct(params) {
+      const url = `${base}/v1/sdk/products`;
       const res = await fetch(url, {
         method: "POST",
         headers,
@@ -134,14 +140,14 @@ function createSolvaPayClient(opts) {
       if (!res.ok) {
         const error = await res.text();
         log(`\u274C API Error: ${res.status} - ${error}`);
-        throw new SolvaPayError(`Create agent failed (${res.status}): ${error}`);
+        throw new SolvaPayError(`Create product failed (${res.status}): ${error}`);
       }
       const result = await res.json();
       return result;
     },
-    // DELETE: /v1/sdk/agents/{agentRef}
-    async deleteAgent(agentRef) {
-      const url = `${base}/v1/sdk/agents/${agentRef}`;
+    // DELETE: /v1/sdk/products/{productRef}
+    async deleteProduct(productRef) {
+      const url = `${base}/v1/sdk/products/${productRef}`;
       const res = await fetch(url, {
         method: "DELETE",
         headers
@@ -149,12 +155,12 @@ function createSolvaPayClient(opts) {
       if (!res.ok && res.status !== 404) {
         const error = await res.text();
         log(`\u274C API Error: ${res.status} - ${error}`);
-        throw new SolvaPayError(`Delete agent failed (${res.status}): ${error}`);
+        throw new SolvaPayError(`Delete product failed (${res.status}): ${error}`);
       }
     },
-    // GET: /v1/sdk/agents/{agentRef}/plans
-    async listPlans(agentRef) {
-      const url = `${base}/v1/sdk/agents/${agentRef}/plans`;
+    // GET: /v1/sdk/products/{productRef}/plans
+    async listPlans(productRef) {
+      const url = `${base}/v1/sdk/products/${productRef}/plans`;
       const res = await fetch(url, {
         method: "GET",
         headers
@@ -167,20 +173,20 @@ function createSolvaPayClient(opts) {
       const result = await res.json();
       const plans = Array.isArray(result) ? result : result.plans || [];
       return plans.map((plan) => {
-        const price = plan.price ?? plan.data?.price;
+        const data = plan.data || {};
+        const price = plan.price ?? data.price;
         const unwrapped = {
-          ...plan.data || {},
+          ...data,
           ...plan,
-          // Explicitly preserve price field to ensure it's not lost
           ...price !== void 0 && { price }
         };
         delete unwrapped.data;
         return unwrapped;
       });
     },
-    // POST: /v1/sdk/agents/{agentRef}/plans
+    // POST: /v1/sdk/products/{productRef}/plans
     async createPlan(params) {
-      const url = `${base}/v1/sdk/agents/${params.agentRef}/plans`;
+      const url = `${base}/v1/sdk/products/${params.productRef}/plans`;
       const res = await fetch(url, {
         method: "POST",
         headers,
@@ -194,9 +200,9 @@ function createSolvaPayClient(opts) {
       const result = await res.json();
       return result;
     },
-    // DELETE: /v1/sdk/agents/{agentRef}/plans/{planRef}
-    async deletePlan(agentRef, planRef) {
-      const url = `${base}/v1/sdk/agents/${agentRef}/plans/${planRef}`;
+    // DELETE: /v1/sdk/products/{productRef}/plans/{planRef}
+    async deletePlan(productRef, planRef) {
+      const url = `${base}/v1/sdk/products/${productRef}/plans/${planRef}`;
       const res = await fetch(url, {
         method: "DELETE",
         headers
@@ -218,7 +224,7 @@ function createSolvaPayClient(opts) {
           "Idempotency-Key": idempotencyKey
         },
         body: JSON.stringify({
-          agentRef: params.agentRef,
+          productRef: params.productRef,
           planRef: params.planRef,
           customerReference: params.customerRef
         })
@@ -232,7 +238,7 @@ function createSolvaPayClient(opts) {
       return result;
     },
     // POST: /v1/sdk/payment-intents/{paymentIntentId}/process
-    async processPayment(params) {
+    async processPaymentIntent(params) {
       const url = `${base}/v1/sdk/payment-intents/${params.paymentIntentId}/process`;
       const res = await fetch(url, {
         method: "POST",
@@ -241,7 +247,7 @@ function createSolvaPayClient(opts) {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          agentRef: params.agentRef,
+          productRef: params.productRef,
           customerRef: params.customerRef,
           planRef: params.planRef
         })
@@ -254,9 +260,9 @@ function createSolvaPayClient(opts) {
       const result = await res.json();
       return result;
     },
-    // POST: /v1/sdk/subscriptions/{subscriptionRef}/cancel
-    async cancelSubscription(params) {
-      const url = `${base}/v1/sdk/subscriptions/${params.subscriptionRef}/cancel`;
+    // POST: /v1/sdk/purchases/{purchaseRef}/cancel
+    async cancelPurchase(params) {
+      const url = `${base}/v1/sdk/purchases/${params.purchaseRef}/cancel`;
       const requestOptions = {
         method: "POST",
         headers
@@ -269,14 +275,14 @@ function createSolvaPayClient(opts) {
         const error = await res.text();
         log(`\u274C API Error: ${res.status} - ${error}`);
         if (res.status === 404) {
-          throw new SolvaPayError(`Subscription not found: ${error}`);
+          throw new SolvaPayError(`Purchase not found: ${error}`);
         }
         if (res.status === 400) {
           throw new SolvaPayError(
-            `Subscription cannot be cancelled or does not belong to provider: ${error}`
+            `Purchase cannot be cancelled or does not belong to provider: ${error}`
           );
         }
-        throw new SolvaPayError(`Cancel subscription failed (${res.status}): ${error}`);
+        throw new SolvaPayError(`Cancel purchase failed (${res.status}): ${error}`);
       }
       const responseText = await res.text();
       let responseData;
@@ -285,24 +291,24 @@ function createSolvaPayClient(opts) {
       } catch (parseError) {
         log(`\u274C Failed to parse response as JSON: ${parseError}`);
         throw new SolvaPayError(
-          `Invalid JSON response from cancel subscription endpoint: ${responseText.substring(0, 200)}`
+          `Invalid JSON response from cancel purchase endpoint: ${responseText.substring(0, 200)}`
         );
       }
       if (!responseData || typeof responseData !== "object") {
         log(`\u274C Invalid response structure: ${JSON.stringify(responseData)}`);
-        throw new SolvaPayError(`Invalid response structure from cancel subscription endpoint`);
+        throw new SolvaPayError(`Invalid response structure from cancel purchase endpoint`);
       }
       let result;
-      if (responseData.subscription && typeof responseData.subscription === "object") {
-        result = responseData.subscription;
+      if (responseData.purchase && typeof responseData.purchase === "object") {
+        result = responseData.purchase;
       } else if (responseData.reference) {
         result = responseData;
       } else {
-        result = responseData.subscription || responseData;
+        result = responseData.purchase || responseData;
       }
       if (!result || typeof result !== "object") {
-        log(`\u274C Invalid subscription data in response. Full response:`, responseData);
-        throw new SolvaPayError(`Invalid subscription data in cancel subscription response`);
+        log(`\u274C Invalid purchase data in response. Full response:`, responseData);
+        throw new SolvaPayError(`Invalid purchase data in cancel purchase response`);
       }
       return result;
     },
@@ -479,8 +485,6 @@ function createRequestDeduplicator(options = {}) {
 }
 
 // src/paywall.ts
-import { readFileSync } from "fs";
-import { join } from "path";
 var PaywallError = class extends Error {
   /**
    * Creates a new PaywallError instance.
@@ -516,21 +520,8 @@ var SolvaPayPaywall = class {
       console.log(...args);
     }
   }
-  resolveAgent(metadata) {
-    return metadata.agent || process.env.SOLVAPAY_AGENT || this.getPackageJsonName() || "default-agent";
-  }
-  getPackageJsonName() {
-    try {
-      if (typeof process === "undefined" || typeof process.cwd !== "function") {
-        return void 0;
-      }
-      const packageJsonPath = join(process.cwd(), "package.json");
-      const pkgContent = readFileSync(packageJsonPath, "utf-8");
-      const pkg = JSON.parse(pkgContent);
-      return pkg.name;
-    } catch {
-      return void 0;
-    }
+  resolveProduct(metadata) {
+    return metadata.product || process.env.SOLVAPAY_PRODUCT || "default-product";
   }
   generateRequestId() {
     const timestamp = Date.now();
@@ -540,8 +531,9 @@ var SolvaPayPaywall = class {
   /**
    * Core protection method - works for both MCP and HTTP
    */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   async protect(handler, metadata = {}, getCustomerRef) {
-    const agent = this.resolveAgent(metadata);
+    const product = this.resolveProduct(metadata);
     const toolName = handler.name || "anonymous";
     return async (args) => {
       const startTime = Date.now();
@@ -557,13 +549,13 @@ var SolvaPayPaywall = class {
         const planRef = metadata.plan || toolName;
         const limitsCheck = await this.apiClient.checkLimits({
           customerRef: backendCustomerRef,
-          agentRef: agent
+          productRef: product
         });
         if (!limitsCheck.withinLimits) {
           const latencyMs2 = Date.now() - startTime;
           await this.trackUsage(
             backendCustomerRef,
-            agent,
+            product,
             planRef,
             toolName,
             "paywall",
@@ -572,16 +564,16 @@ var SolvaPayPaywall = class {
           );
           throw new PaywallError("Payment required", {
             kind: "payment_required",
-            agent,
+            product,
             checkoutUrl: limitsCheck.checkoutUrl || "",
-            message: `Plan subscription required. Remaining: ${limitsCheck.remaining}`
+            message: `Plan purchase required. Remaining: ${limitsCheck.remaining}`
           });
         }
         const result = await handler(args);
         const latencyMs = Date.now() - startTime;
         await this.trackUsage(
           backendCustomerRef,
-          agent,
+          product,
           planRef,
           toolName,
           "success",
@@ -601,7 +593,7 @@ var SolvaPayPaywall = class {
         const planRef = metadata.plan || toolName;
         await this.trackUsage(
           backendCustomerRef,
-          agent,
+          product,
           planRef,
           toolName,
           outcome,
@@ -681,11 +673,13 @@ var SolvaPayPaywall = class {
           createParams.externalRef = externalRef;
         }
         const result = await this.apiClient.createCustomer(createParams);
-        const ref = result.customerRef || result.reference || customerRef;
+        const resultObj = result;
+        const ref = resultObj.customerRef || resultObj.reference || customerRef;
         this.customerRefMapping.set(customerRef, ref);
         return ref;
       } catch (error) {
-        if (error.message && (error.message.includes("409") || error.message.includes("already exists"))) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("409") || errorMessage.includes("already exists")) {
           if (externalRef) {
             try {
               const searchResult = await this.apiClient.getCustomer({ externalRef });
@@ -697,12 +691,56 @@ var SolvaPayPaywall = class {
               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");
+          if (externalRef && isEmailConflict && options?.email) {
+            try {
+              const byEmail = await this.apiClient.getCustomer({ email: options.email });
+              if (byEmail && byEmail.customerRef) {
+                this.customerRefMapping.set(customerRef, byEmail.customerRef);
+                this.log(
+                  `\u26A0\uFE0F Resolved customer ${customerRef} by email after conflict; using existing customer ${byEmail.customerRef}`
+                );
+                return byEmail.customerRef;
+              }
+            } catch (emailLookupError) {
+              this.log(
+                `\u26A0\uFE0F Email lookup failed after customer conflict for ${customerRef}:`,
+                emailLookupError instanceof Error ? emailLookupError.message : emailLookupError
+              );
+            }
+            try {
+              const retryParams = {
+                email: `${customerRef}-${Date.now()}@auto-created.local`,
+                externalRef
+              };
+              if (options?.name) {
+                retryParams.name = options.name;
+              }
+              const retryResult = await this.apiClient.createCustomer(retryParams);
+              const retryObj = retryResult;
+              const retryRef = retryObj.customerRef || retryObj.reference || customerRef;
+              this.customerRefMapping.set(customerRef, retryRef);
+              this.log(
+                `\u26A0\uFE0F Retried customer creation for ${customerRef} with generated email after email conflict`
+              );
+              return retryRef;
+            } catch (retryError) {
+              this.log(
+                `\u26A0\uFE0F Retry create customer with generated email failed for ${customerRef}:`,
+                retryError instanceof Error ? retryError.message : retryError
+              );
+            }
+          }
+          const unresolvedMessage = errorMessage || "Customer already exists but could not be resolved";
+          throw new Error(
+            `Failed to resolve existing customer for ${customerRef} after conflict: ${unresolvedMessage}. Ensure the existing customer is linked to this externalRef.`
+          );
         }
         this.log(
           `\u274C Failed to auto-create customer ${customerRef}:`,
           error instanceof Error ? error.message : error
         );
-        return customerRef;
+        throw error;
       }
     });
     if (backendRef !== customerRef) {
@@ -710,11 +748,11 @@ var SolvaPayPaywall = class {
     }
     return backendRef;
   }
-  async trackUsage(customerRef, agentRef, planRef, toolName, outcome, requestId, actionDuration) {
+  async trackUsage(customerRef, productRef, planRef, toolName, outcome, requestId, actionDuration) {
     await withRetry(
       () => this.apiClient.trackUsage({
         customerRef,
-        agentRef,
+        productRef,
         planRef,
         outcome,
         action: toolName,
@@ -773,7 +811,7 @@ async function createAdapterHandler(adapter, paywall, metadata, businessLogic) {
       const args = await adapter.extractArgs(context);
       const customerRef = await adapter.getCustomerRef(context);
       args.auth = { customer_ref: customerRef };
-      const getCustomerRef = (args2) => args2.auth.customer_ref;
+      const getCustomerRef = (args2) => args2.auth?.customer_ref || "anonymous";
       const protectedHandler = await paywall.protect(businessLogic, metadata, getCustomerRef);
       const result = await protectedHandler(args);
       return adapter.formatResponse(result, context);
@@ -832,7 +870,7 @@ var HttpAdapter = class {
       const errorResponse2 = {
         success: false,
         error: "Payment required",
-        agent: error.structuredContent.agent,
+        product: error.structuredContent.product,
         checkoutUrl: error.structuredContent.checkoutUrl,
         message: error.structuredContent.message
       };
@@ -928,7 +966,7 @@ var NextAdapter = class {
         JSON.stringify({
           success: false,
           error: "Payment required",
-          agent: error.structuredContent.agent,
+          product: error.structuredContent.product,
           checkoutUrl: error.structuredContent.checkoutUrl,
           message: error.structuredContent.message
         }),
@@ -964,7 +1002,8 @@ var McpAdapter = class {
       const ref = await this.options.getCustomerRef(args);
       return AdapterUtils.ensureCustomerRef(ref);
     }
-    const customerRef = args?.auth?.customer_ref || "anonymous";
+    const auth = args?.auth;
+    const customerRef = auth?.customer_ref || "anonymous";
     return AdapterUtils.ensureCustomerRef(customerRef);
   }
   formatResponse(result, _context) {
@@ -988,7 +1027,7 @@ var McpAdapter = class {
               {
                 success: false,
                 error: "Payment required",
-                agent: error.structuredContent.agent,
+                product: error.structuredContent.product,
                 checkoutUrl: error.structuredContent.checkoutUrl,
                 message: error.structuredContent.message
               },
@@ -1022,8 +1061,6 @@ var McpAdapter = class {
 
 // src/factory.ts
 import { SolvaPayError as SolvaPayError2, getSolvaPayConfig } from "@solvapay/core";
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
 function createSolvaPay(config) {
   let resolvedConfig;
   if (!config) {
@@ -1055,11 +1092,11 @@ function createSolvaPay(config) {
       }
       return apiClient.createPaymentIntent(params);
     },
-    processPayment(params) {
-      if (!apiClient.processPayment) {
-        throw new SolvaPayError2("processPayment is not available on this API client");
+    processPaymentIntent(params) {
+      if (!apiClient.processPaymentIntent) {
+        throw new SolvaPayError2("processPaymentIntent is not available on this API client");
       }
-      return apiClient.processPayment(params);
+      return apiClient.processPaymentIntent(params);
     },
     checkLimits(params) {
       return apiClient.checkLimits(params);
@@ -1077,18 +1114,22 @@ function createSolvaPay(config) {
       return apiClient.getCustomer(params);
     },
     createCheckoutSession(params) {
-      return apiClient.createCheckoutSession(params);
+      return apiClient.createCheckoutSession({
+        customerReference: params.customerRef,
+        productRef: params.productRef,
+        planRef: params.planRef
+      });
     },
     createCustomerSession(params) {
       return apiClient.createCustomerSession(params);
     },
     // Payable API for framework-specific handlers
     payable(options = {}) {
-      const agent = options.agentRef || options.agent || process.env.SOLVAPAY_AGENT || getPackageJsonName() || "default-agent";
-      const plan = options.planRef || options.plan || agent;
-      const metadata = { agent, plan };
+      const product = options.productRef || options.product || process.env.SOLVAPAY_PRODUCT || "default-product";
+      const plan = options.planRef || options.plan || product;
+      const metadata = { product, plan };
       return {
-        // HTTP adapter for Express/Fastify
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         http(businessLogic, adapterOptions) {
           const adapter = new HttpAdapter(adapterOptions);
           return async (req, reply) => {
@@ -1096,7 +1137,7 @@ function createSolvaPay(config) {
             return handler([req, reply]);
           };
         },
-        // Next.js adapter for App Router
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         next(businessLogic, adapterOptions) {
           const adapter = new NextAdapter(adapterOptions);
           return async (request, context) => {
@@ -1104,7 +1145,7 @@ function createSolvaPay(config) {
             return handler([request, context]);
           };
         },
-        // MCP adapter for Model Context Protocol
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         mcp(businessLogic, adapterOptions) {
           const adapter = new McpAdapter(adapterOptions);
           return async (args) => {
@@ -1112,7 +1153,7 @@ function createSolvaPay(config) {
             return handler(args);
           };
         },
-        // Pure function adapter for direct protection
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         async function(businessLogic) {
           const getCustomerRef = (args) => args.auth?.customer_ref || "anonymous";
           return paywall.protect(businessLogic, metadata, getCustomerRef);
@@ -1121,19 +1162,6 @@ function createSolvaPay(config) {
     }
   };
 }
-function getPackageJsonName() {
-  try {
-    if (typeof process === "undefined" || typeof process.cwd !== "function") {
-      return void 0;
-    }
-    const packageJsonPath = join2(process.cwd(), "package.json");
-    const pkgContent = readFileSync2(packageJsonPath, "utf-8");
-    const pkg = JSON.parse(pkgContent);
-    return pkg.name;
-  } catch {
-    return void 0;
-  }
-}
 
 // src/helpers/error.ts
 import { SolvaPayError as SolvaPayError3 } from "@solvapay/core";
@@ -1211,9 +1239,9 @@ async function syncCustomerCore(request, options = {}) {
 // src/helpers/payment.ts
 async function createPaymentIntentCore(request, body, options = {}) {
   try {
-    if (!body.planRef || !body.agentRef) {
+    if (!body.planRef || !body.productRef) {
       return {
-        error: "Missing required parameters: planRef and agentRef are required",
+        error: "Missing required parameters: planRef and productRef are required",
         status: 400
       };
     }
@@ -1228,7 +1256,7 @@ async function createPaymentIntentCore(request, body, options = {}) {
     const customerRef = customerResult;
     const solvaPay = options.solvaPay || createSolvaPay();
     const paymentIntent = await solvaPay.createPaymentIntent({
-      agentRef: body.agentRef,
+      productRef: body.productRef,
       planRef: body.planRef,
       customerRef
     });
@@ -1238,17 +1266,16 @@ async function createPaymentIntentCore(request, body, options = {}) {
       publishableKey: paymentIntent.publishableKey,
       accountId: paymentIntent.accountId,
       customerRef
-      // Return the backend customer reference
     };
   } catch (error) {
     return handleRouteError(error, "Create payment intent", "Payment intent creation failed");
   }
 }
-async function processPaymentCore(request, body, options = {}) {
+async function processPaymentIntentCore(request, body, options = {}) {
   try {
-    if (!body.paymentIntentId || !body.agentRef) {
+    if (!body.paymentIntentId || !body.productRef) {
       return {
-        error: "paymentIntentId and agentRef are required",
+        error: "paymentIntentId and productRef are required",
         status: 400
       };
     }
@@ -1260,24 +1287,24 @@ async function processPaymentCore(request, body, options = {}) {
     }
     const customerRef = customerResult;
     const solvaPay = options.solvaPay || createSolvaPay();
-    const result = await solvaPay.processPayment({
+    const result = await solvaPay.processPaymentIntent({
       paymentIntentId: body.paymentIntentId,
-      agentRef: body.agentRef,
+      productRef: body.productRef,
       customerRef,
       planRef: body.planRef
     });
     return result;
   } catch (error) {
-    return handleRouteError(error, "Process payment", "Payment processing failed");
+    return handleRouteError(error, "Process payment intent", "Payment processing failed");
   }
 }
 
 // src/helpers/checkout.ts
 async function createCheckoutSessionCore(request, body, options = {}) {
   try {
-    if (!body.agentRef) {
+    if (!body.productRef) {
       return {
-        error: "Missing required parameter: agentRef is required",
+        error: "Missing required parameter: productRef is required",
         status: 400
       };
     }
@@ -1300,7 +1327,7 @@ async function createCheckoutSessionCore(request, body, options = {}) {
     }
     const solvaPay = options.solvaPay || createSolvaPay();
     const session = await solvaPay.createCheckoutSession({
-      agentRef: body.agentRef,
+      productRef: body.productRef,
       customerRef,
       planRef: body.planRef || void 0,
       returnUrl
@@ -1334,65 +1361,65 @@ async function createCustomerSessionCore(request, options = {}) {
   }
 }
 
-// src/helpers/subscription.ts
+// src/helpers/renewal.ts
 import { SolvaPayError as SolvaPayError4 } from "@solvapay/core";
-async function cancelSubscriptionCore(request, body, options = {}) {
+async function cancelPurchaseCore(request, body, options = {}) {
   try {
-    if (!body.subscriptionRef) {
+    if (!body.purchaseRef) {
       return {
-        error: "Missing required parameter: subscriptionRef is required",
+        error: "Missing required parameter: purchaseRef is required",
         status: 400
       };
     }
     const solvaPay = options.solvaPay || createSolvaPay();
-    if (!solvaPay.apiClient.cancelSubscription) {
+    if (!solvaPay.apiClient.cancelPurchase) {
       return {
-        error: "Cancel subscription method not available on SDK client",
+        error: "Cancel purchase method not available on SDK client",
         status: 500
       };
     }
-    let cancelledSubscription = await solvaPay.apiClient.cancelSubscription({
-      subscriptionRef: body.subscriptionRef,
+    let cancelledPurchase = await solvaPay.apiClient.cancelPurchase({
+      purchaseRef: body.purchaseRef,
       reason: body.reason
     });
-    if (!cancelledSubscription || typeof cancelledSubscription !== "object") {
+    if (!cancelledPurchase || typeof cancelledPurchase !== "object") {
       return {
-        error: "Invalid response from cancel subscription endpoint",
+        error: "Invalid response from cancel purchase endpoint",
         status: 500
       };
     }
-    const responseAny = cancelledSubscription;
-    if (responseAny.subscription && typeof responseAny.subscription === "object") {
-      cancelledSubscription = responseAny.subscription;
+    const responseObj = cancelledPurchase;
+    if (responseObj.purchase && typeof responseObj.purchase === "object") {
+      cancelledPurchase = responseObj.purchase;
     }
-    if (!cancelledSubscription.reference) {
+    if (!cancelledPurchase.reference) {
       return {
-        error: "Cancel subscription response missing required fields",
+        error: "Cancel purchase response missing required fields",
         status: 500
       };
     }
-    const isCancelled = cancelledSubscription.status === "cancelled" || cancelledSubscription.cancelledAt;
+    const isCancelled = cancelledPurchase.status === "cancelled" || cancelledPurchase.cancelledAt;
     if (!isCancelled) {
       return {
-        error: `Subscription cancellation failed: backend returned status '${cancelledSubscription.status}' without cancelledAt timestamp`,
+        error: `Purchase cancellation failed: backend returned status '${cancelledPurchase.status}' without cancelledAt timestamp`,
         status: 500
       };
     }
     await new Promise((resolve) => setTimeout(resolve, 500));
-    return cancelledSubscription;
+    return cancelledPurchase;
   } catch (error) {
     if (error instanceof SolvaPayError4) {
       const errorMessage = error.message;
-      if (errorMessage.includes("Subscription not found")) {
+      if (errorMessage.includes("not found")) {
         return {
-          error: "Subscription not found",
+          error: "Purchase not found",
           status: 404,
           details: errorMessage
         };
       }
       if (errorMessage.includes("cannot be cancelled") || errorMessage.includes("does not belong to provider")) {
         return {
-          error: "Subscription cannot be cancelled or does not belong to provider",
+          error: "Purchase cannot be cancelled or does not belong to provider",
           status: 400,
           details: errorMessage
         };
@@ -1403,7 +1430,7 @@ async function cancelSubscriptionCore(request, body, options = {}) {
         details: errorMessage
       };
     }
-    return handleRouteError(error, "Cancel subscription", "Failed to cancel subscription");
+    return handleRouteError(error, "Cancel purchase", "Failed to cancel purchase");
   }
 }
 
@@ -1412,10 +1439,10 @@ import { getSolvaPayConfig as getSolvaPayConfig2 } from "@solvapay/core";
 async function listPlansCore(request) {
   try {
     const url = new URL(request.url);
-    const agentRef = url.searchParams.get("agentRef");
-    if (!agentRef) {
+    const productRef = url.searchParams.get("productRef");
+    if (!productRef) {
       return {
-        error: "Missing required parameter: agentRef",
+        error: "Missing required parameter: productRef",
         status: 400
       };
     }
@@ -1438,10 +1465,10 @@ async function listPlansCore(request) {
         status: 500
       };
     }
-    const plans = await apiClient.listPlans(agentRef);
+    const plans = await apiClient.listPlans(productRef);
     return {
       plans: plans || [],
-      agentRef
+      productRef
     };
   } catch (error) {
     return handleRouteError(error, "List plans", "Failed to fetch plans");
@@ -1471,7 +1498,7 @@ async function verifyWebhook({
 }
 export {
   PaywallError,
-  cancelSubscriptionCore,
+  cancelPurchaseCore,
   createCheckoutSessionCore,
   createCustomerSessionCore,
   createPaymentIntentCore,
@@ -1481,7 +1508,7 @@ export {
   handleRouteError,
   isErrorResult,
   listPlansCore,
-  processPaymentCore,
+  processPaymentIntentCore,
   syncCustomerCore,
   verifyWebhook,
   withRetry