@solvapay/server 1.0.0-preview.1

package/dist/edge.js

@@ -0,0 +1,847 @@
+import {
+  __require
+} from "./chunk-R5U7XKVJ.js";
+
+// src/edge.ts
+import { SolvaPayError as SolvaPayError3 } from "@solvapay/core";
+
+// src/client.ts
+import { SolvaPayError } from "@solvapay/core";
+function createSolvaPayClient(opts) {
+  const base = opts.apiBaseUrl ?? "https://api-dev.solvapay.com";
+  if (!opts.apiKey) throw new SolvaPayError("Missing apiKey");
+  const headers = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${opts.apiKey}`
+  };
+  console.log(`\u{1F50C} SolvaPay API Client initialized`);
+  console.log(`   Backend URL: ${base}`);
+  console.log(`   API Key: ${opts.apiKey.substring(0, 10)}...`);
+  return {
+    // POST: /v1/sdk/limits
+    async checkLimits(params) {
+      const url = `${base}/v1/sdk/limits`;
+      console.log(`\u{1F4E1} API Request: POST ${url}`);
+      console.log(`   Params:`, JSON.stringify(params, null, 2));
+      const res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(params)
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        console.error(`\u274C API Error: ${res.status} - ${error}`);
+        throw new SolvaPayError(`Check limits failed (${res.status}): ${error}`);
+      }
+      const result = await res.json();
+      console.log(`\u2705 API Response:`, JSON.stringify(result, null, 2));
+      console.log(`\u{1F50D} DEBUG - checkLimits breakdown:`);
+      console.log(`   - withinLimits: ${result.withinLimits}`);
+      console.log(`   - remaining: ${result.remaining}`);
+      console.log(`   - plan: ${result.plan || "N/A"}`);
+      console.log(`   - checkoutUrl: ${result.checkoutUrl || "N/A"}`);
+      console.log(`   - Full response keys:`, Object.keys(result));
+      return result;
+    },
+    // POST: /v1/sdk/usages
+    async trackUsage(params) {
+      const url = `${base}/v1/sdk/usages`;
+      console.log(`\u{1F4E1} API Request: POST ${url}`);
+      console.log(`   Params:`, JSON.stringify(params, null, 2));
+      const res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(params)
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        console.error(`\u274C API Error: ${res.status} - ${error}`);
+        throw new SolvaPayError(`Track usage failed (${res.status}): ${error}`);
+      }
+      console.log(`\u2705 Usage tracked successfully`);
+    },
+    // POST: /v1/sdk/customers
+    async createCustomer(params) {
+      const url = `${base}/v1/sdk/customers`;
+      console.log(`\u{1F4E1} API Request: POST ${url}`);
+      console.log(`   Params:`, JSON.stringify(params, null, 2));
+      const res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(params)
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        console.error(`\u274C API Error: ${res.status} - ${error}`);
+        throw new SolvaPayError(`Create customer failed (${res.status}): ${error}`);
+      }
+      const result = await res.json();
+      console.log(`\u2705 API Response:`, JSON.stringify(result, null, 2));
+      console.log(`\u{1F50D} DEBUG - createCustomer response:`);
+      console.log(`   - reference/customerRef: ${result.reference || result.customerRef}`);
+      console.log(`   - Has plan info: ${result.plan ? "YES" : "NO"}`);
+      console.log(`   - Has subscription info: ${result.subscription ? "YES" : "NO"}`);
+      console.log(`   - Full response keys:`, Object.keys(result));
+      return result;
+    },
+    // GET: /v1/sdk/customers/{reference}
+    async getCustomer(params) {
+      const url = `${base}/v1/sdk/customers/${params.customerRef}`;
+      console.log(`\u{1F4E1} API Request: GET ${url}`);
+      const res = await fetch(url, {
+        method: "GET",
+        headers
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        console.error(`\u274C API Error: ${res.status} - ${error}`);
+        throw new SolvaPayError(`Get customer failed (${res.status}): ${error}`);
+      }
+      const result = await res.json();
+      console.log(`\u2705 API Response:`, JSON.stringify(result, null, 2));
+      return result;
+    },
+    // Management methods (primarily for integration tests)
+    // GET: /v1/sdk/agents
+    async listAgents() {
+      const url = `${base}/v1/sdk/agents`;
+      console.log(`\u{1F4E1} API Request: GET ${url}`);
+      const res = await fetch(url, {
+        method: "GET",
+        headers
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        console.error(`\u274C API Error: ${res.status} - ${error}`);
+        throw new SolvaPayError(`List agents failed (${res.status}): ${error}`);
+      }
+      const result = await res.json();
+      console.log(`\u2705 API Response:`, JSON.stringify(result, null, 2));
+      const agents = Array.isArray(result) ? result : result.agents || [];
+      return agents.map((agent) => ({
+        ...agent,
+        ...agent.data || {}
+      }));
+    },
+    // POST: /v1/sdk/agents
+    async createAgent(params) {
+      const url = `${base}/v1/sdk/agents`;
+      console.log(`\u{1F4E1} API Request: POST ${url}`);
+      console.log(`   Params:`, JSON.stringify(params, null, 2));
+      const res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(params)
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        console.error(`\u274C API Error: ${res.status} - ${error}`);
+        throw new SolvaPayError(`Create agent failed (${res.status}): ${error}`);
+      }
+      const result = await res.json();
+      console.log(`\u2705 API Response:`, JSON.stringify(result, null, 2));
+      return result;
+    },
+    // DELETE: /v1/sdk/agents/{agentRef}
+    async deleteAgent(agentRef) {
+      const url = `${base}/v1/sdk/agents/${agentRef}`;
+      console.log(`\u{1F4E1} API Request: DELETE ${url}`);
+      const res = await fetch(url, {
+        method: "DELETE",
+        headers
+      });
+      if (!res.ok && res.status !== 404) {
+        const error = await res.text();
+        console.error(`\u274C API Error: ${res.status} - ${error}`);
+        throw new SolvaPayError(`Delete agent failed (${res.status}): ${error}`);
+      }
+      console.log(`\u2705 Agent deleted successfully`);
+    },
+    // GET: /v1/sdk/agents/{agentRef}/plans
+    async listPlans(agentRef) {
+      const url = `${base}/v1/sdk/agents/${agentRef}/plans`;
+      console.log(`\u{1F4E1} API Request: GET ${url}`);
+      const res = await fetch(url, {
+        method: "GET",
+        headers
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        console.error(`\u274C API Error: ${res.status} - ${error}`);
+        throw new SolvaPayError(`List plans failed (${res.status}): ${error}`);
+      }
+      const result = await res.json();
+      console.log(`\u2705 API Response:`, JSON.stringify(result, null, 2));
+      const plans = Array.isArray(result) ? result : result.plans || [];
+      return plans.map((plan) => ({
+        ...plan,
+        ...plan.data || {}
+      }));
+    },
+    // POST: /v1/sdk/agents/{agentRef}/plans
+    async createPlan(params) {
+      const url = `${base}/v1/sdk/agents/${params.agentRef}/plans`;
+      console.log(`\u{1F4E1} API Request: POST ${url}`);
+      console.log(`   Params:`, JSON.stringify(params, null, 2));
+      const res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(params)
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        console.error(`\u274C API Error: ${res.status} - ${error}`);
+        throw new SolvaPayError(`Create plan failed (${res.status}): ${error}`);
+      }
+      const result = await res.json();
+      console.log(`\u2705 API Response:`, JSON.stringify(result, null, 2));
+      return result;
+    },
+    // DELETE: /v1/sdk/agents/{agentRef}/plans/{planRef}
+    async deletePlan(agentRef, planRef) {
+      const url = `${base}/v1/sdk/agents/${agentRef}/plans/${planRef}`;
+      console.log(`\u{1F4E1} API Request: DELETE ${url}`);
+      const res = await fetch(url, {
+        method: "DELETE",
+        headers
+      });
+      if (!res.ok && res.status !== 404) {
+        const error = await res.text();
+        console.error(`\u274C API Error: ${res.status} - ${error}`);
+        throw new SolvaPayError(`Delete plan failed (${res.status}): ${error}`);
+      }
+      console.log(`\u2705 Plan deleted successfully`);
+    },
+    // POST: /payment-intents
+    async createPaymentIntent(params) {
+      const idempotencyKey = params.idempotencyKey || `payment-${params.planRef}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const url = `${base}/v1/sdk/payment-intents`;
+      console.log(`\u{1F4E1} API Request: POST ${url}`);
+      console.log(`   Agent Ref: ${params.agentRef}`);
+      console.log(`   Plan Ref: ${params.planRef}`);
+      console.log(`   Customer Ref: ${params.customerRef}`);
+      console.log(`   Idempotency Key: ${idempotencyKey}`);
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          ...headers,
+          "Idempotency-Key": idempotencyKey
+        },
+        body: JSON.stringify({
+          agentRef: params.agentRef,
+          planRef: params.planRef,
+          customerReference: params.customerRef
+        })
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        console.error(`\u274C API Error: ${res.status} - ${error}`);
+        throw new SolvaPayError(`Create payment intent failed (${res.status}): ${error}`);
+      }
+      const result = await res.json();
+      console.log(`\u2705 Payment intent created:`, {
+        id: result.id,
+        hasClientSecret: !!result.clientSecret,
+        hasPublishableKey: !!result.publishableKey,
+        accountId: result.accountId
+      });
+      return result;
+    }
+  };
+}
+
+// src/utils.ts
+async function withRetry(fn, options = {}) {
+  const {
+    maxRetries = 2,
+    initialDelay = 500,
+    backoffStrategy = "fixed",
+    shouldRetry,
+    onRetry
+  } = options;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      const isLastAttempt = attempt === maxRetries;
+      if (isLastAttempt) {
+        throw lastError;
+      }
+      if (shouldRetry && !shouldRetry(lastError, attempt)) {
+        throw lastError;
+      }
+      const delay = calculateDelay(initialDelay, attempt, backoffStrategy);
+      if (onRetry) {
+        onRetry(lastError, attempt);
+      }
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+function calculateDelay(initialDelay, attempt, strategy) {
+  switch (strategy) {
+    case "fixed":
+      return initialDelay;
+    case "linear":
+      return initialDelay * (attempt + 1);
+    case "exponential":
+      return initialDelay * Math.pow(2, attempt);
+    default:
+      return initialDelay;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/paywall.ts
+var PaywallError = class extends Error {
+  constructor(message, structuredContent) {
+    super(message);
+    this.structuredContent = structuredContent;
+    this.name = "PaywallError";
+  }
+};
+var SolvaPayPaywall = class {
+  constructor(apiClient, options = {}) {
+    this.apiClient = apiClient;
+    this.debug = options.debug ?? process.env.SOLVAPAY_DEBUG !== "false";
+  }
+  customerCreationAttempts = /* @__PURE__ */ new Set();
+  customerRefMapping = /* @__PURE__ */ new Map();
+  // input ref -> backend ref
+  debug;
+  log(...args) {
+    if (this.debug) {
+      console.log(...args);
+    }
+  }
+  resolveAgent(metadata) {
+    return metadata.agent || process.env.SOLVAPAY_AGENT || this.getPackageJsonName() || "default-agent";
+  }
+  getPackageJsonName() {
+    try {
+      const pkg = __require(process.cwd() + "/package.json");
+      return pkg.name;
+    } catch {
+      return void 0;
+    }
+  }
+  generateRequestId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 11);
+    return `solvapay_${timestamp}_${random}`;
+  }
+  /**
+   * Core protection method - works for both MCP and HTTP
+   */
+  async protect(handler, metadata = {}, getCustomerRef) {
+    const agent = this.resolveAgent(metadata);
+    const toolName = handler.name || "anonymous";
+    return async (args) => {
+      const startTime = Date.now();
+      const requestId = this.generateRequestId();
+      const inputCustomerRef = getCustomerRef ? getCustomerRef(args) : args.auth?.customer_ref || "anonymous";
+      const backendCustomerRef = await this.ensureCustomer(inputCustomerRef);
+      try {
+        const planRef = metadata.plan || toolName;
+        this.log(`\u{1F50D} Checking limits for customer: ${backendCustomerRef}, agent: ${agent}, plan: ${planRef}`);
+        const limitsCheck = await this.apiClient.checkLimits({
+          customerRef: backendCustomerRef,
+          agentRef: agent
+        });
+        this.log(`\u2713 Limits check passed:`, limitsCheck);
+        if (!limitsCheck.withinLimits) {
+          const latencyMs2 = Date.now() - startTime;
+          this.log(`\u{1F6AB} Paywall triggered - tracking usage`);
+          await this.trackUsage(backendCustomerRef, agent, planRef, toolName, "paywall", requestId, latencyMs2);
+          throw new PaywallError("Payment required", {
+            kind: "payment_required",
+            agent,
+            checkoutUrl: limitsCheck.checkoutUrl || "",
+            message: `Plan subscription required. Remaining: ${limitsCheck.remaining}`
+          });
+        }
+        this.log(`\u26A1 Executing handler: ${toolName}`);
+        const result = await handler(args);
+        this.log(`\u2713 Handler completed successfully`);
+        const latencyMs = Date.now() - startTime;
+        this.log(`\u{1F4CA} Tracking successful usage`);
+        await this.trackUsage(backendCustomerRef, agent, planRef, toolName, "success", requestId, latencyMs);
+        this.log(`\u2705 Request completed successfully`);
+        return result;
+      } catch (error) {
+        this.log(`\u274C Error in paywall:`, error);
+        const latencyMs = Date.now() - startTime;
+        const outcome = error instanceof PaywallError ? "paywall" : "fail";
+        const planRef = metadata.plan || toolName;
+        await this.trackUsage(backendCustomerRef, agent, planRef, toolName, outcome, requestId, latencyMs);
+        throw error;
+      }
+    };
+  }
+  /**
+   * Ensures a customer exists in the backend, creating them if necessary.
+   * This is a public helper for testing, pre-creating customers, and internal use.
+   * Only attempts creation once per customer (idempotent).
+   * Returns the backend customer reference to use in API calls.
+   */
+  async ensureCustomer(customerRef) {
+    if (this.customerRefMapping.has(customerRef)) {
+      return this.customerRefMapping.get(customerRef);
+    }
+    if (customerRef === "anonymous") {
+      return customerRef;
+    }
+    if (this.customerCreationAttempts.has(customerRef)) {
+      return customerRef;
+    }
+    if (!this.apiClient.createCustomer) {
+      console.warn(`\u26A0\uFE0F  Cannot auto-create customer ${customerRef}: createCustomer method not available on API client`);
+      return customerRef;
+    }
+    this.customerCreationAttempts.add(customerRef);
+    try {
+      this.log(`\u{1F527} Auto-creating customer: ${customerRef}`);
+      const result = await this.apiClient.createCustomer({
+        email: `${customerRef}@auto-created.local`,
+        name: customerRef
+      });
+      const backendRef = result.customerRef || result.reference || customerRef;
+      this.log(`\u2705 Successfully created customer: ${customerRef} -> ${backendRef}`, result);
+      this.log(`\u{1F50D} DEBUG - ensureCustomer analysis:`);
+      this.log(`   - Input customerRef: ${customerRef}`);
+      this.log(`   - Backend customerRef: ${backendRef}`);
+      this.log(`   - Has plan in response: ${result.plan ? "YES - " + result.plan : "NO"}`);
+      this.log(`   - Has subscription in response: ${result.subscription ? "YES" : "NO"}`);
+      this.customerRefMapping.set(customerRef, backendRef);
+      return backendRef;
+    } catch (error) {
+      this.log(`\u274C Failed to auto-create customer ${customerRef}:`, error instanceof Error ? error.message : error);
+      return customerRef;
+    }
+  }
+  async trackUsage(customerRef, agentRef, planRef, toolName, outcome, requestId, actionDuration) {
+    await withRetry(
+      () => this.apiClient.trackUsage({
+        customerRef,
+        agentRef,
+        planRef,
+        outcome,
+        action: toolName,
+        requestId,
+        actionDuration,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }),
+      {
+        maxRetries: 2,
+        initialDelay: 500,
+        shouldRetry: (error) => error.message.includes("Customer not found"),
+        // TODO: review if this is needed and what to check for 
+        onRetry: (error, attempt) => {
+          console.warn(`\u26A0\uFE0F  Customer not found (attempt ${attempt + 1}/3), retrying in 500ms...`);
+        }
+      }
+    ).catch((error) => {
+      console.error("Usage tracking failed:", error);
+    });
+  }
+};
+
+// src/adapters/base.ts
+var AdapterUtils = class {
+  /**
+   * Ensure customer reference is properly formatted
+   */
+  static ensureCustomerRef(customerRef) {
+    if (!customerRef || customerRef === "anonymous") {
+      return "anonymous";
+    }
+    if (!customerRef.startsWith("customer_") && !customerRef.startsWith("demo_")) {
+      return `customer_${customerRef.replace(/[^a-zA-Z0-9]/g, "_")}`;
+    }
+    return customerRef;
+  }
+  /**
+   * Extract customer ref from JWT token
+   */
+  static async extractFromJWT(token, options) {
+    try {
+      const { jwtVerify } = await import("./esm-5GYCIXIY.js");
+      const jwtSecret = new TextEncoder().encode(
+        options?.secret || process.env.OAUTH_JWKS_SECRET || "test-jwt-secret"
+      );
+      const { payload } = await jwtVerify(token, jwtSecret, {
+        issuer: options?.issuer || process.env.OAUTH_ISSUER || "http://localhost:3000",
+        audience: options?.audience || process.env.OAUTH_CLIENT_ID || "test-client-id"
+      });
+      return payload.sub || null;
+    } catch (error) {
+      return null;
+    }
+  }
+};
+async function createAdapterHandler(adapter, paywall, metadata, businessLogic) {
+  return async (context) => {
+    try {
+      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 protectedHandler = await paywall.protect(businessLogic, metadata, getCustomerRef);
+      const result = await protectedHandler(args);
+      return adapter.formatResponse(result, context);
+    } catch (error) {
+      return adapter.formatError(error, context);
+    }
+  };
+}
+
+// src/adapters/http.ts
+var HttpAdapter = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  extractArgs([req, _reply]) {
+    if (this.options.extractArgs) {
+      return this.options.extractArgs(req);
+    }
+    return {
+      ...req.body || {},
+      ...req.params || {},
+      ...req.query || {}
+    };
+  }
+  async getCustomerRef([req, _reply]) {
+    if (this.options.getCustomerRef) {
+      const ref = await this.options.getCustomerRef(req);
+      return AdapterUtils.ensureCustomerRef(ref);
+    }
+    const headerRef = req.headers?.["x-customer-ref"];
+    if (headerRef) {
+      return AdapterUtils.ensureCustomerRef(headerRef);
+    }
+    const authHeader = req.headers?.["authorization"];
+    if (authHeader && authHeader.startsWith("Bearer ")) {
+      const token = authHeader.substring(7);
+      const jwtSub = await AdapterUtils.extractFromJWT(token);
+      if (jwtSub) {
+        return AdapterUtils.ensureCustomerRef(jwtSub);
+      }
+    }
+    return "anonymous";
+  }
+  formatResponse(result, [_req, reply]) {
+    if (this.options.transformResponse) {
+      return this.options.transformResponse(result, reply);
+    }
+    if (reply && reply.status && typeof reply.json === "function") {
+      reply.json(result);
+      return;
+    }
+    return result;
+  }
+  formatError(error, [_req, reply]) {
+    if (error instanceof PaywallError) {
+      const errorResponse2 = {
+        success: false,
+        error: "Payment required",
+        agent: error.structuredContent.agent,
+        checkoutUrl: error.structuredContent.checkoutUrl,
+        message: error.structuredContent.message
+      };
+      if (reply && reply.status && typeof reply.json === "function") {
+        reply.status(402).json(errorResponse2);
+        return;
+      }
+      if (reply && reply.code) {
+        reply.code(402);
+      }
+      return errorResponse2;
+    }
+    const errorResponse = {
+      success: false,
+      error: error instanceof Error ? error.message : "Internal server error"
+    };
+    if (reply && reply.status && typeof reply.json === "function") {
+      reply.status(500).json(errorResponse);
+      return;
+    }
+    if (reply && reply.code) {
+      reply.code(500);
+    }
+    return errorResponse;
+  }
+};
+
+// src/adapters/next.ts
+var NextAdapter = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async extractArgs([request, context]) {
+    if (this.options.extractArgs) {
+      return await this.options.extractArgs(request, context);
+    }
+    const url = new URL(request.url);
+    const query = Object.fromEntries(url.searchParams.entries());
+    let body = {};
+    try {
+      if (request.method !== "GET" && request.headers.get("content-type")?.includes("application/json")) {
+        body = await request.json();
+      }
+    } catch (error) {
+    }
+    let routeParams = {};
+    if (context?.params) {
+      if (typeof context.params === "object" && "then" in context.params) {
+        routeParams = await context.params;
+      } else {
+        routeParams = context.params;
+      }
+    }
+    return {
+      ...body,
+      ...query,
+      ...routeParams
+    };
+  }
+  async getCustomerRef([request]) {
+    if (this.options.getCustomerRef) {
+      const ref = await this.options.getCustomerRef(request);
+      return AdapterUtils.ensureCustomerRef(ref);
+    }
+    const authHeader = request.headers.get("authorization");
+    if (authHeader && authHeader.startsWith("Bearer ")) {
+      const token = authHeader.substring(7);
+      const jwtSub = await AdapterUtils.extractFromJWT(token);
+      if (jwtSub) {
+        return AdapterUtils.ensureCustomerRef(jwtSub);
+      }
+    }
+    const headerRef = request.headers.get("x-customer-ref");
+    if (headerRef) {
+      return AdapterUtils.ensureCustomerRef(headerRef);
+    }
+    return "demo_user";
+  }
+  formatResponse(result, _context) {
+    const transformed = this.options.transformResponse ? this.options.transformResponse(result) : result;
+    return new Response(JSON.stringify(transformed), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  formatError(error, _context) {
+    if (error instanceof PaywallError) {
+      return new Response(JSON.stringify({
+        success: false,
+        error: "Payment required",
+        agent: error.structuredContent.agent,
+        checkoutUrl: error.structuredContent.checkoutUrl,
+        message: error.structuredContent.message
+      }), {
+        status: 402,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    return new Response(JSON.stringify({
+      success: false,
+      error: error instanceof Error ? error.message : "Internal server error"
+    }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+};
+
+// src/adapters/mcp.ts
+var McpAdapter = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  extractArgs(args) {
+    return args;
+  }
+  async getCustomerRef(args) {
+    if (this.options.getCustomerRef) {
+      const ref = await this.options.getCustomerRef(args);
+      return AdapterUtils.ensureCustomerRef(ref);
+    }
+    const customerRef = args?.auth?.customer_ref || "anonymous";
+    return AdapterUtils.ensureCustomerRef(customerRef);
+  }
+  formatResponse(result, _context) {
+    const transformed = this.options.transformResponse ? this.options.transformResponse(result) : result;
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(transformed, null, 2)
+      }]
+    };
+  }
+  formatError(error, _context) {
+    if (error instanceof PaywallError) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: false,
+            error: "Payment required",
+            agent: error.structuredContent.agent,
+            checkoutUrl: error.structuredContent.checkoutUrl,
+            message: error.structuredContent.message
+          }, null, 2)
+        }],
+        isError: true,
+        structuredContent: error.structuredContent
+      };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : "Unknown error occurred"
+        }, null, 2)
+      }],
+      isError: true
+    };
+  }
+};
+
+// src/factory.ts
+import { SolvaPayError as SolvaPayError2 } from "@solvapay/core";
+function createSolvaPay(config) {
+  const apiClient = config.apiClient || createSolvaPayClient({
+    apiKey: config.apiKey,
+    apiBaseUrl: config.apiBaseUrl
+  });
+  const paywall = new SolvaPayPaywall(apiClient, {
+    debug: process.env.SOLVAPAY_DEBUG !== "false"
+  });
+  return {
+    // Direct access to API client for advanced operations
+    apiClient,
+    // Common API methods exposed directly for convenience
+    ensureCustomer(customerRef) {
+      return paywall.ensureCustomer(customerRef);
+    },
+    createPaymentIntent(params) {
+      if (!apiClient.createPaymentIntent) {
+        throw new SolvaPayError2("createPaymentIntent is not available on this API client");
+      }
+      return apiClient.createPaymentIntent(params);
+    },
+    checkLimits(params) {
+      return apiClient.checkLimits(params);
+    },
+    trackUsage(params) {
+      return apiClient.trackUsage(params);
+    },
+    createCustomer(params) {
+      if (!apiClient.createCustomer) {
+        throw new SolvaPayError2("createCustomer is not available on this API client");
+      }
+      return apiClient.createCustomer(params);
+    },
+    getCustomer(params) {
+      if (!apiClient.getCustomer) {
+        throw new SolvaPayError2("getCustomer is not available on this API client");
+      }
+      return apiClient.getCustomer(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 };
+      return {
+        // HTTP adapter for Express/Fastify
+        http(businessLogic, adapterOptions) {
+          const adapter = new HttpAdapter(adapterOptions);
+          return async (req, reply) => {
+            const handler = await createAdapterHandler(
+              adapter,
+              paywall,
+              metadata,
+              businessLogic
+            );
+            return handler([req, reply]);
+          };
+        },
+        // Next.js adapter for App Router
+        next(businessLogic, adapterOptions) {
+          const adapter = new NextAdapter(adapterOptions);
+          return async (request, context) => {
+            const handler = await createAdapterHandler(
+              adapter,
+              paywall,
+              metadata,
+              businessLogic
+            );
+            return handler([request, context]);
+          };
+        },
+        // MCP adapter for Model Context Protocol
+        mcp(businessLogic, adapterOptions) {
+          const adapter = new McpAdapter(adapterOptions);
+          return async (args) => {
+            const handler = await createAdapterHandler(
+              adapter,
+              paywall,
+              metadata,
+              businessLogic
+            );
+            return handler(args);
+          };
+        },
+        // Pure function adapter for direct protection
+        async function(businessLogic) {
+          const getCustomerRef = (args) => args.auth?.customer_ref || "anonymous";
+          return paywall.protect(businessLogic, metadata, getCustomerRef);
+        }
+      };
+    }
+  };
+}
+function getPackageJsonName() {
+  try {
+    const pkg = __require(process.cwd() + "/package.json");
+    return pkg.name;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/edge.ts
+async function verifyWebhook({
+  body,
+  signature,
+  secret
+}) {
+  const enc = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    enc.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sigBuf = await crypto.subtle.sign("HMAC", key, enc.encode(body));
+  const hex = Array.from(new Uint8Array(sigBuf)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  if (hex !== signature) {
+    throw new SolvaPayError3("Invalid webhook signature");
+  }
+  return JSON.parse(body);
+}
+export {
+  PaywallError,
+  createSolvaPay,
+  createSolvaPayClient,
+  verifyWebhook,
+  withRetry
+};