@sly_ai/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,2709 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config.ts
+function inferEnvironmentFromKey(apiKey) {
+  if (apiKey.startsWith("pk_test_") || apiKey.startsWith("pk_sandbox_")) {
+    return "sandbox";
+  }
+  if (apiKey.startsWith("pk_live_")) {
+    return "production";
+  }
+  return void 0;
+}
+function getEnvironmentConfig(environment) {
+  return exports.ENVIRONMENT_CONFIGS[environment];
+}
+function validateEnvironment(environment, evmPrivateKey) {
+  if (environment !== "sandbox" && !evmPrivateKey) {
+    throw new Error(
+      `EVM private key is required for ${environment} environment. Use sandbox mode for local development without blockchain.`
+    );
+  }
+}
+exports.ENVIRONMENT_CONFIGS = void 0;
+var init_config = __esm({
+  "src/config.ts"() {
+    exports.ENVIRONMENT_CONFIGS = {
+      sandbox: {
+        apiUrl: "https://sandbox.getsly.ai",
+        facilitatorUrl: "https://facilitator.x402.org"
+        // x402.org Base Sepolia
+      },
+      testnet: {
+        apiUrl: "https://sandbox.getsly.ai",
+        facilitatorUrl: "https://facilitator.x402.org"
+        // x402.org Base Sepolia
+      },
+      production: {
+        apiUrl: "https://api.getsly.ai",
+        facilitatorUrl: "https://facilitator.coinbase.com"
+        // Coinbase CDP Base mainnet
+      }
+    };
+  }
+});
+
+// src/client.ts
+exports.SlyClient = void 0;
+var init_client = __esm({
+  "src/client.ts"() {
+    init_config();
+    exports.SlyClient = class {
+      constructor(config) {
+        this.apiKey = config.apiKey;
+        const environment = config.environment ?? inferEnvironmentFromKey(config.apiKey) ?? "sandbox";
+        const envConfig = getEnvironmentConfig(environment);
+        this.apiUrl = config.apiUrl || envConfig.apiUrl;
+      }
+      /**
+       * Make an authenticated API request
+       */
+      async request(path, options = {}) {
+        const url = `${this.apiUrl}${path}`;
+        const response = await fetch(url, {
+          ...options,
+          headers: {
+            "Authorization": `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+            ...options.headers
+          }
+        });
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({
+            message: response.statusText
+          }));
+          const error = new Error(errorData.error || errorData.message || `HTTP ${response.status}`);
+          error.status = response.status;
+          error.data = errorData;
+          throw error;
+        }
+        return response.json();
+      }
+      /**
+       * Get a settlement quote
+       */
+      async getSettlementQuote(request) {
+        return this.request("/v1/settlements/quote", {
+          method: "POST",
+          body: JSON.stringify(request)
+        });
+      }
+      /**
+       * Create a settlement
+       */
+      async createSettlement(request) {
+        return this.request("/v1/settlements", {
+          method: "POST",
+          body: JSON.stringify(request)
+        });
+      }
+      /**
+       * Get settlement status
+       */
+      async getSettlement(settlementId) {
+        return this.request(`/v1/settlements/${settlementId}`);
+      }
+      /**
+       * Check compliance for a recipient
+       */
+      async checkCompliance(request) {
+        return this.request("/v1/compliance/check", {
+          method: "POST",
+          body: JSON.stringify(request)
+        });
+      }
+      /**
+       * Get API capabilities
+       */
+      async getCapabilities() {
+        return this.request("/v1/capabilities");
+      }
+    };
+  }
+});
+
+// src/facilitator/sandbox-facilitator.ts
+var SandboxFacilitator;
+var init_sandbox_facilitator = __esm({
+  "src/facilitator/sandbox-facilitator.ts"() {
+    SandboxFacilitator = class {
+      constructor(config) {
+        this.config = {
+          apiUrl: config.apiUrl,
+          apiKey: config.apiKey,
+          settlementDelayMs: config.settlementDelayMs ?? 0,
+          failureRate: config.failureRate ?? 0,
+          debug: config.debug ?? false,
+          supportedSchemes: config.supportedSchemes ?? [
+            {
+              scheme: "exact-evm",
+              networks: ["eip155:8453", "eip155:84532"]
+              // Base mainnet and Sepolia
+            }
+          ]
+        };
+        if (this.config.debug) {
+          console.log("[SandboxFacilitator] Initialized with config:", {
+            apiUrl: this.config.apiUrl,
+            settlementDelayMs: this.config.settlementDelayMs,
+            failureRate: this.config.failureRate
+          });
+        }
+      }
+      /**
+       * Verify a payment payload
+       * 
+       * In sandbox mode, this validates the structure but skips signature verification
+       */
+      async verify(request) {
+        const { payment } = request;
+        if (this.config.debug) {
+          console.log("[SandboxFacilitator] Verifying payment:", payment);
+        }
+        const requiredFields = ["scheme", "network", "amount", "token", "from", "to"];
+        for (const field of requiredFields) {
+          if (!payment[field]) {
+            return {
+              valid: false,
+              reason: `Missing required field: ${field}`
+            };
+          }
+        }
+        const schemeSupported = this.config.supportedSchemes.some(
+          (s) => s.scheme === payment.scheme
+        );
+        if (!schemeSupported) {
+          return {
+            valid: false,
+            reason: `Unsupported scheme: ${payment.scheme}`,
+            details: {
+              supportedSchemes: this.config.supportedSchemes.map((s) => s.scheme)
+            }
+          };
+        }
+        const scheme = this.config.supportedSchemes.find(
+          (s) => s.scheme === payment.scheme
+        );
+        if (scheme && !scheme.networks.includes(payment.network)) {
+          return {
+            valid: false,
+            reason: `Unsupported network: ${payment.network} for scheme: ${payment.scheme}`,
+            details: {
+              supportedNetworks: scheme.networks
+            }
+          };
+        }
+        const amount = parseFloat(payment.amount);
+        if (isNaN(amount) || amount <= 0) {
+          return {
+            valid: false,
+            reason: `Invalid amount: ${payment.amount}`
+          };
+        }
+        return {
+          valid: true
+        };
+      }
+      /**
+       * Settle a payment
+       * 
+       * In sandbox mode, this generates a mock transaction hash and
+       * optionally records the payment in PayOS
+       */
+      async settle(request) {
+        const { payment } = request;
+        if (this.config.debug) {
+          console.log("[SandboxFacilitator] Settling payment:", payment);
+        }
+        const verification = await this.verify({ payment });
+        if (!verification.valid) {
+          throw new Error(`Payment verification failed: ${verification.reason}`);
+        }
+        if (this.config.failureRate > 0) {
+          const random = Math.random() * 100;
+          if (random < this.config.failureRate) {
+            throw new Error("Simulated settlement failure");
+          }
+        }
+        if (this.config.settlementDelayMs > 0) {
+          await new Promise(
+            (resolve) => setTimeout(resolve, this.config.settlementDelayMs)
+          );
+        }
+        const txHash = this.generateMockTxHash();
+        if (this.config.debug) {
+          console.log("[SandboxFacilitator] Settlement complete:", {
+            txHash,
+            amount: payment.amount,
+            from: payment.from,
+            to: payment.to
+          });
+        }
+        return {
+          transactionHash: txHash,
+          settled: true,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      /**
+       * Get supported schemes and networks
+       */
+      async supported() {
+        return {
+          schemes: this.config.supportedSchemes
+        };
+      }
+      /**
+       * Generate a realistic-looking mock transaction hash
+       */
+      generateMockTxHash() {
+        const chars = "0123456789abcdef";
+        let hash = "0x";
+        for (let i = 0; i < 64; i++) {
+          hash += chars[Math.floor(Math.random() * chars.length)];
+        }
+        return hash;
+      }
+    };
+  }
+});
+
+// src/protocols/x402/client.ts
+var SlyX402Client;
+var init_client2 = __esm({
+  "src/protocols/x402/client.ts"() {
+    init_config();
+    init_sandbox_facilitator();
+    SlyX402Client = class {
+      constructor(config) {
+        this.dailySpent = 0;
+        validateEnvironment(config.environment, config.evmPrivateKey);
+        const envConfig = getEnvironmentConfig(config.environment);
+        this.config = {
+          apiKey: config.apiKey,
+          environment: config.environment,
+          evmPrivateKey: config.evmPrivateKey,
+          facilitatorUrl: config.facilitatorUrl || envConfig.facilitatorUrl || "",
+          maxAutoPayAmount: config.maxAutoPayAmount || "1.00",
+          maxDailySpend: config.maxDailySpend || "100.00",
+          onPayment: config.onPayment,
+          onSettlement: config.onSettlement,
+          settleToRail: config.settleToRail
+        };
+        this.lastResetDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        if (this.config.environment === "sandbox") {
+          this.sandboxFacilitator = new SandboxFacilitator({
+            apiUrl: envConfig.apiUrl,
+            apiKey: this.config.apiKey
+          });
+        }
+      }
+      /**
+       * Fetch a resource with automatic 402 payment handling
+       */
+      async fetch(url, options = {}) {
+        const { maxPayment, ...fetchOptions } = options;
+        let response = await fetch(url, fetchOptions);
+        if (response.status !== 402) {
+          return response;
+        }
+        const paymentRequired = await this.parse402Response(response);
+        const acceptedOption = paymentRequired.accepts[0];
+        if (!acceptedOption) {
+          throw new Error("No acceptable payment options in 402 response");
+        }
+        const amount = parseFloat(acceptedOption.amount);
+        const maxAmount = parseFloat(maxPayment || this.config.maxAutoPayAmount);
+        if (amount > maxAmount) {
+          throw new Error(
+            `Payment amount ${acceptedOption.amount} exceeds max auto-pay amount ${maxPayment || this.config.maxAutoPayAmount}`
+          );
+        }
+        this.resetDailySpendIfNeeded();
+        if (this.dailySpent + amount > parseFloat(this.config.maxDailySpend)) {
+          throw new Error(
+            `Payment would exceed daily limit. Spent: ${this.dailySpent}, Limit: ${this.config.maxDailySpend}`
+          );
+        }
+        const payment = await this.createPayment(acceptedOption);
+        if (this.config.onPayment) {
+          await this.config.onPayment({
+            amount: acceptedOption.amount,
+            currency: acceptedOption.token,
+            from: payment.from,
+            to: payment.to,
+            scheme: acceptedOption.scheme,
+            network: acceptedOption.network,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        this.dailySpent += amount;
+        response = await fetch(url, {
+          ...fetchOptions,
+          headers: {
+            ...fetchOptions.headers,
+            "X-Payment": JSON.stringify(payment)
+          }
+        });
+        if (this.config.onSettlement && payment.transactionHash) {
+          await this.config.onSettlement({
+            transactionHash: payment.transactionHash,
+            amount: acceptedOption.amount,
+            currency: acceptedOption.token,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        return response;
+      }
+      /**
+       * Get client status
+       */
+      getStatus() {
+        this.resetDailySpendIfNeeded();
+        return {
+          environment: this.config.environment,
+          dailySpent: this.dailySpent.toFixed(2),
+          dailyLimit: this.config.maxDailySpend,
+          walletAddress: this.getWalletAddress()
+        };
+      }
+      /**
+       * Parse 402 response
+       */
+      async parse402Response(response) {
+        const body = await response.json();
+        if (!body.accepts || !Array.isArray(body.accepts)) {
+          throw new Error("Invalid 402 response: missing accepts array");
+        }
+        return {
+          statusCode: 402,
+          accepts: body.accepts
+        };
+      }
+      /**
+       * Create payment based on environment
+       */
+      async createPayment(option) {
+        if (this.config.environment === "sandbox") {
+          return this.createSandboxPayment(option);
+        } else {
+          return this.createBlockchainPayment(option);
+        }
+      }
+      /**
+       * Create sandbox payment (mock)
+       */
+      async createSandboxPayment(option) {
+        if (!this.sandboxFacilitator) {
+          throw new Error("Sandbox facilitator not initialized");
+        }
+        const payment = {
+          scheme: option.scheme,
+          network: option.network,
+          amount: option.amount,
+          token: option.token,
+          from: "0x0000000000000000000000000000000000000001",
+          // Mock address
+          to: "0x0000000000000000000000000000000000000002"
+          // Mock address
+        };
+        const settlement = await this.sandboxFacilitator.settle({ payment });
+        return {
+          ...payment,
+          transactionHash: settlement.transactionHash
+        };
+      }
+      /**
+       * Create blockchain payment (real EVM)
+       */
+      async createBlockchainPayment(_option) {
+        if (!this.config.evmPrivateKey) {
+          throw new Error("EVM private key required for blockchain payments");
+        }
+        throw new Error("Blockchain payments not yet implemented - use sandbox mode");
+      }
+      /**
+       * Get wallet address based on environment
+       */
+      getWalletAddress() {
+        if (this.config.environment === "sandbox") {
+          return "0x0000000000000000000000000000000000000001";
+        }
+        return void 0;
+      }
+      /**
+       * Reset daily spend if date has changed
+       */
+      resetDailySpendIfNeeded() {
+        const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        if (today !== this.lastResetDate) {
+          this.dailySpent = 0;
+          this.lastResetDate = today;
+        }
+      }
+    };
+  }
+});
+
+// src/protocols/x402/provider.ts
+var SlyX402Provider;
+var init_provider = __esm({
+  "src/protocols/x402/provider.ts"() {
+    init_config();
+    init_sandbox_facilitator();
+    SlyX402Provider = class {
+      constructor(config) {
+        const envConfig = getEnvironmentConfig(config.environment);
+        this.config = {
+          apiKey: config.apiKey,
+          environment: config.environment,
+          routes: config.routes,
+          facilitatorUrl: config.facilitatorUrl || envConfig.facilitatorUrl
+        };
+        if (this.config.environment === "sandbox") {
+          this.sandboxFacilitator = new SandboxFacilitator({
+            apiUrl: envConfig.apiUrl,
+            apiKey: this.config.apiKey
+          });
+        }
+      }
+      /**
+       * Create Express middleware
+       */
+      middleware() {
+        return async (req, res, next) => {
+          try {
+            const routeConfig = this.getRouteConfig(req);
+            if (!routeConfig) {
+              return next();
+            }
+            const paymentHeader = req.headers["x-payment"];
+            if (!paymentHeader) {
+              return this.return402(req, res, routeConfig);
+            }
+            const isValid = await this.verifyPayment(paymentHeader, routeConfig);
+            if (!isValid) {
+              return this.return402(req, res, routeConfig);
+            }
+            next();
+          } catch (error) {
+            res.status(500).json({
+              error: "Payment verification failed",
+              message: error.message
+            });
+          }
+        };
+      }
+      /**
+       * Get route configuration for request
+       */
+      getRouteConfig(req) {
+        const routeKey = `${req.method} ${req.path}`;
+        if (this.config.routes[routeKey]) {
+          return this.config.routes[routeKey];
+        }
+        for (const [pattern, config] of Object.entries(this.config.routes)) {
+          if (this.matchRoute(pattern, routeKey)) {
+            return config;
+          }
+        }
+        return null;
+      }
+      /**
+       * Simple route pattern matching
+       */
+      matchRoute(pattern, route) {
+        const regexPattern = pattern.replace(/\*/g, ".*").replace(/\//g, "\\/");
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(route);
+      }
+      /**
+       * Return 402 Payment Required response
+       */
+      return402(_req, res, routeConfig) {
+        const scheme = "exact-evm";
+        const network = this.config.environment === "sandbox" ? "eip155:8453" : "eip155:8453";
+        res.status(402).json({
+          statusCode: 402,
+          message: "Payment Required",
+          accepts: [
+            {
+              scheme,
+              network,
+              token: routeConfig.token || "USDC",
+              amount: routeConfig.price,
+              facilitator: this.config.facilitatorUrl,
+              description: routeConfig.description
+            }
+          ]
+        });
+      }
+      /**
+       * Verify payment
+       */
+      async verifyPayment(paymentHeader, routeConfig) {
+        try {
+          const payment = JSON.parse(paymentHeader);
+          if (payment.amount !== routeConfig.price) {
+            return false;
+          }
+          const expectedToken = routeConfig.token || "USDC";
+          if (payment.token !== expectedToken) {
+            return false;
+          }
+          if (this.config.environment === "sandbox") {
+            return this.verifySandboxPayment(payment);
+          } else {
+            return this.verifyBlockchainPayment(payment);
+          }
+        } catch (error) {
+          return false;
+        }
+      }
+      /**
+       * Verify sandbox payment
+       */
+      async verifySandboxPayment(payment) {
+        if (!this.sandboxFacilitator) {
+          return false;
+        }
+        const result = await this.sandboxFacilitator.verify({ payment });
+        return result.valid;
+      }
+      /**
+       * Verify blockchain payment
+       */
+      async verifyBlockchainPayment(_payment) {
+        throw new Error("Blockchain payment verification not yet implemented - use sandbox mode");
+      }
+    };
+  }
+});
+
+// src/protocols/ap2/client.ts
+var AP2Client;
+var init_client3 = __esm({
+  "src/protocols/ap2/client.ts"() {
+    AP2Client = class {
+      constructor(client) {
+        this.client = client;
+      }
+      /**
+       * Create a new AP2 mandate
+       * 
+       * @example
+       * ```typescript
+       * const mandate = await payos.ap2.createMandate({
+       *   mandate_id: 'mdt_unique_123',
+       *   mandate_type: 'payment',
+       *   agent_id: 'agent_ai_assistant',
+       *   account_id: 'acct_uuid',
+       *   authorized_amount: 100.00,
+       *   currency: 'USD',
+       * });
+       * ```
+       */
+      async createMandate(request) {
+        const response = await this.client.request(
+          "/v1/ap2/mandates",
+          {
+            method: "POST",
+            body: JSON.stringify(request)
+          }
+        );
+        return response.data;
+      }
+      /**
+       * List mandates with optional filtering
+       * 
+       * @example
+       * ```typescript
+       * const { data, pagination } = await payos.ap2.listMandates({
+       *   status: 'active',
+       *   agent_id: 'agent_ai_assistant',
+       *   limit: 50,
+       * });
+       * ```
+       */
+      async listMandates(options = {}) {
+        const params = new URLSearchParams();
+        if (options.status) params.append("status", options.status);
+        if (options.agent_id) params.append("agent_id", options.agent_id);
+        if (options.account_id) params.append("account_id", options.account_id);
+        if (options.page) params.append("page", options.page.toString());
+        if (options.limit) params.append("limit", options.limit.toString());
+        const queryString = params.toString();
+        const path = queryString ? `/v1/ap2/mandates?${queryString}` : "/v1/ap2/mandates";
+        return this.client.request(path);
+      }
+      /**
+       * Get mandate details with execution history
+       * 
+       * @example
+       * ```typescript
+       * const mandate = await payos.ap2.getMandate('mdt_id');
+       * console.log(mandate.remaining_amount);
+       * console.log(mandate.executions.length);
+       * ```
+       */
+      async getMandate(mandateId) {
+        const response = await this.client.request(
+          `/v1/ap2/mandates/${mandateId}`
+        );
+        return response.data;
+      }
+      /**
+       * Execute a payment against a mandate
+       * 
+       * @example
+       * ```typescript
+       * const result = await payos.ap2.executeMandate('mdt_id', {
+       *   amount: 25.00,
+       *   currency: 'USD',
+       *   description: 'Monthly subscription',
+       * });
+       * 
+       * console.log(result.transfer_id);
+       * console.log(result.mandate.remaining_amount);
+       * ```
+       */
+      async executeMandate(mandateId, request) {
+        const response = await this.client.request(
+          `/v1/ap2/mandates/${mandateId}/execute`,
+          {
+            method: "POST",
+            body: JSON.stringify(request)
+          }
+        );
+        return response.data;
+      }
+      /**
+       * Cancel an active mandate
+       * 
+       * @example
+       * ```typescript
+       * const result = await payos.ap2.cancelMandate('mdt_id');
+       * console.log(result.status); // 'cancelled'
+       * ```
+       */
+      async cancelMandate(mandateId) {
+        const response = await this.client.request(
+          `/v1/ap2/mandates/${mandateId}/cancel`,
+          {
+            method: "PATCH"
+          }
+        );
+        return response.data;
+      }
+      /**
+       * Get AP2 analytics
+       * 
+       * @example
+       * ```typescript
+       * const analytics = await payos.ap2.getAnalytics('30d');
+       * console.log(analytics.summary.totalRevenue);
+       * console.log(analytics.summary.activeMandates);
+       * ```
+       */
+      async getAnalytics(period = "30d") {
+        const response = await this.client.request(
+          `/v1/ap2/analytics?period=${period}`
+        );
+        return response.data;
+      }
+    };
+  }
+});
+
+// src/protocols/acp/client.ts
+var ACPClient;
+var init_client4 = __esm({
+  "src/protocols/acp/client.ts"() {
+    ACPClient = class {
+      constructor(client) {
+        this.client = client;
+      }
+      /**
+       * Create a new ACP checkout session
+       * 
+       * @example
+       * ```typescript
+       * const checkout = await payos.acp.createCheckout({
+       *   checkout_id: 'checkout_unique_123',
+       *   agent_id: 'agent_shopping_assistant',
+       *   account_id: 'acct_uuid',
+       *   merchant_id: 'merchant_store',
+       *   items: [
+       *     {
+       *       name: 'Product 1',
+       *       quantity: 2,
+       *       unit_price: 50.00,
+       *       total_price: 100.00,
+       *     },
+       *   ],
+       *   tax_amount: 10.00,
+       *   shipping_amount: 5.00,
+       * });
+       * ```
+       */
+      async createCheckout(request) {
+        const response = await this.client.request(
+          "/v1/acp/checkouts",
+          {
+            method: "POST",
+            body: JSON.stringify(request)
+          }
+        );
+        return response.data;
+      }
+      /**
+       * List checkouts with optional filtering
+       * 
+       * @example
+       * ```typescript
+       * const { data, pagination } = await payos.acp.listCheckouts({
+       *   status: 'pending',
+       *   agent_id: 'agent_shopping_assistant',
+       *   limit: 20,
+       * });
+       * ```
+       */
+      async listCheckouts(options = {}) {
+        const params = new URLSearchParams();
+        if (options.status) params.append("status", options.status);
+        if (options.agent_id) params.append("agent_id", options.agent_id);
+        if (options.merchant_id) params.append("merchant_id", options.merchant_id);
+        if (options.customer_id) params.append("customer_id", options.customer_id);
+        if (options.limit) params.append("limit", options.limit.toString());
+        if (options.offset) params.append("offset", options.offset.toString());
+        const queryString = params.toString();
+        const path = queryString ? `/v1/acp/checkouts?${queryString}` : "/v1/acp/checkouts";
+        return this.client.request(path);
+      }
+      /**
+       * Get checkout details with items
+       * 
+       * @example
+       * ```typescript
+       * const checkout = await payos.acp.getCheckout('checkout_id');
+       * console.log(checkout.items);
+       * console.log(checkout.total_amount);
+       * ```
+       */
+      async getCheckout(checkoutId) {
+        const response = await this.client.request(
+          `/v1/acp/checkouts/${checkoutId}`
+        );
+        return response.data;
+      }
+      /**
+       * Complete a checkout with SharedPaymentToken
+       * 
+       * @example
+       * ```typescript
+       * const result = await payos.acp.completeCheckout('checkout_id', {
+       *   shared_payment_token: 'spt_...',
+       *   payment_method: 'card',
+       * });
+       * 
+       * console.log(result.transfer_id);
+       * console.log(result.status); // 'completed'
+       * ```
+       */
+      async completeCheckout(checkoutId, request) {
+        const response = await this.client.request(
+          `/v1/acp/checkouts/${checkoutId}/complete`,
+          {
+            method: "POST",
+            body: JSON.stringify(request)
+          }
+        );
+        return response.data;
+      }
+      /**
+       * Cancel a checkout
+       * 
+       * @example
+       * ```typescript
+       * const result = await payos.acp.cancelCheckout('checkout_id');
+       * console.log(result.status); // 'cancelled'
+       * ```
+       */
+      async cancelCheckout(checkoutId) {
+        const response = await this.client.request(
+          `/v1/acp/checkouts/${checkoutId}/cancel`,
+          {
+            method: "PATCH"
+          }
+        );
+        return response.data;
+      }
+      /**
+       * Get ACP analytics
+       * 
+       * @example
+       * ```typescript
+       * const analytics = await payos.acp.getAnalytics('30d');
+       * console.log(analytics.summary.totalRevenue);
+       * console.log(analytics.summary.averageOrderValue);
+       * ```
+       */
+      async getAnalytics(period = "30d") {
+        const response = await this.client.request(
+          `/v1/acp/analytics?period=${period}`
+        );
+        return response.data;
+      }
+    };
+  }
+});
+
+// src/protocols/ucp/client.ts
+var profileCache, PROFILE_CACHE_TTL_MS, UCPClient;
+var init_client5 = __esm({
+  "src/protocols/ucp/client.ts"() {
+    profileCache = /* @__PURE__ */ new Map();
+    PROFILE_CACHE_TTL_MS = 60 * 60 * 1e3;
+    UCPClient = class {
+      constructor(client) {
+        this.client = client;
+      }
+      // ===========================================================================
+      // Discovery
+      // ===========================================================================
+      /**
+       * Discover a UCP merchant's capabilities
+       *
+       * Fetches and caches the merchant's UCP profile from /.well-known/ucp
+       *
+       * @example
+       * ```typescript
+       * const merchant = await payos.ucp.discover('https://shop.example.com');
+       * console.log(merchant.ucp.version);
+       * console.log(merchant.payment?.handlers);
+       * ```
+       */
+      async discover(merchantUrl) {
+        const baseUrl = merchantUrl.replace(/\/$/, "");
+        const profileUrl = `${baseUrl}/.well-known/ucp`;
+        const cached = profileCache.get(profileUrl);
+        if (cached && Date.now() - cached.fetchedAt < PROFILE_CACHE_TTL_MS) {
+          return cached.profile;
+        }
+        const response = await fetch(profileUrl, {
+          headers: {
+            Accept: "application/json",
+            "User-Agent": "PayOS-SDK/1.0"
+          }
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to discover UCP profile: ${response.status} ${response.statusText}`);
+        }
+        const profile = await response.json();
+        if (!profile.ucp?.version) {
+          throw new Error("Invalid UCP profile: missing ucp.version");
+        }
+        profileCache.set(profileUrl, {
+          profile,
+          fetchedAt: Date.now()
+        });
+        return profile;
+      }
+      /**
+       * Get PayOS's own UCP profile
+       *
+       * @example
+       * ```typescript
+       * const profile = await payos.ucp.getProfile();
+       * console.log(profile.payment?.handlers);
+       * ```
+       */
+      async getProfile() {
+        return this.client.request("/.well-known/ucp");
+      }
+      /**
+       * Get available settlement corridors
+       *
+       * @example
+       * ```typescript
+       * const corridors = await payos.ucp.getCorridors();
+       * console.log(corridors.find(c => c.rail === 'pix'));
+       * ```
+       */
+      async getCorridors() {
+        const response = await this.client.request(
+          "/v1/ucp/corridors"
+        );
+        return response.corridors;
+      }
+      /**
+       * Get UCP handler info
+       *
+       * @example
+       * ```typescript
+       * const info = await payos.ucp.getHandlerInfo();
+       * console.log(info.handler.name); // com.payos.latam_settlement
+       * ```
+       */
+      async getHandlerInfo() {
+        return this.client.request("/v1/ucp/info");
+      }
+      // ===========================================================================
+      // Quotes
+      // ===========================================================================
+      /**
+       * Get an FX quote for a settlement corridor
+       *
+       * @example
+       * ```typescript
+       * const quote = await payos.ucp.getQuote({
+       *   corridor: 'pix',
+       *   amount: 100,
+       *   currency: 'USD',
+       * });
+       * console.log(`${quote.from_amount} USD = ${quote.to_amount} BRL`);
+       * ```
+       */
+      async getQuote(request) {
+        return this.client.request("/v1/ucp/quote", {
+          method: "POST",
+          body: JSON.stringify(request)
+        });
+      }
+      // ===========================================================================
+      // Token Acquisition (Payment Handler flow)
+      // ===========================================================================
+      /**
+       * Acquire a settlement token for completing a UCP checkout
+       *
+       * Tokens are valid for 15 minutes and lock in the FX rate.
+       *
+       * @example
+       * ```typescript
+       * const token = await payos.ucp.acquireToken({
+       *   corridor: 'pix',
+       *   amount: 100,
+       *   currency: 'USD',
+       *   recipient: {
+       *     type: 'pix',
+       *     pix_key: '12345678901',
+       *     pix_key_type: 'cpf',
+       *     name: 'Maria Silva',
+       *   },
+       * });
+       *
+       * console.log(token.token); // ucp_tok_...
+       * console.log(token.quote.to_amount); // 595.00 BRL
+       * ```
+       */
+      async acquireToken(request) {
+        return this.client.request("/v1/ucp/tokens", {
+          method: "POST",
+          body: JSON.stringify(request)
+        });
+      }
+      // ===========================================================================
+      // Settlement Execution
+      // ===========================================================================
+      /**
+       * Complete settlement using a previously acquired token
+       *
+       * @example
+       * ```typescript
+       * const settlement = await payos.ucp.settle({
+       *   token: 'ucp_tok_...',
+       *   idempotency_key: 'checkout_12345',
+       * });
+       *
+       * console.log(settlement.status); // pending
+       * console.log(settlement.id); // Use this to track status
+       * ```
+       */
+      async settle(request) {
+        return this.client.request("/v1/ucp/settle", {
+          method: "POST",
+          body: JSON.stringify(request)
+        });
+      }
+      /**
+       * Get settlement status by ID
+       *
+       * @example
+       * ```typescript
+       * const settlement = await payos.ucp.getSettlement('uuid');
+       * if (settlement.status === 'completed') {
+       *   console.log(`Completed at ${settlement.completed_at}`);
+       * }
+       * ```
+       */
+      async getSettlement(settlementId) {
+        return this.client.request(`/v1/ucp/settlements/${settlementId}`);
+      }
+      /**
+       * List settlements with optional filtering
+       *
+       * @example
+       * ```typescript
+       * const { data, pagination } = await payos.ucp.listSettlements({
+       *   status: 'completed',
+       *   corridor: 'pix',
+       *   limit: 50,
+       * });
+       * ```
+       */
+      async listSettlements(options = {}) {
+        const params = new URLSearchParams();
+        if (options.status) params.append("status", options.status);
+        if (options.corridor) params.append("corridor", options.corridor);
+        if (options.limit) params.append("limit", options.limit.toString());
+        if (options.offset) params.append("offset", options.offset.toString());
+        const queryString = params.toString();
+        const path = queryString ? `/v1/ucp/settlements?${queryString}` : "/v1/ucp/settlements";
+        return this.client.request(path);
+      }
+      // ===========================================================================
+      // Checkout (Consuming UCP Merchants)
+      // ===========================================================================
+      /**
+       * Create a checkout session with a UCP merchant
+       *
+       * @example
+       * ```typescript
+       * const checkout = await payos.ucp.createCheckout('https://shop.example.com', {
+       *   line_items: [
+       *     { product_id: 'prod_123', quantity: 2 },
+       *   ],
+       *   buyer: { email: 'buyer@example.com' },
+       * });
+       *
+       * console.log(checkout.totals.total);
+       * ```
+       */
+      async createCheckout(merchantUrl, request) {
+        const profile = await this.discover(merchantUrl);
+        if (!profile.checkout?.endpoint) {
+          throw new Error("Merchant does not support UCP checkout");
+        }
+        const response = await fetch(profile.checkout.endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "User-Agent": "PayOS-SDK/1.0"
+          },
+          body: JSON.stringify(request)
+        });
+        if (!response.ok) {
+          const error = await response.json().catch(() => ({}));
+          throw new Error(`Failed to create checkout: ${response.status} - ${JSON.stringify(error)}`);
+        }
+        return await response.json();
+      }
+      /**
+       * Complete a checkout with PayOS LATAM settlement
+       *
+       * This is a convenience method that:
+       * 1. Acquires a settlement token
+       * 2. Completes the checkout with the merchant
+       *
+       * @example
+       * ```typescript
+       * const order = await payos.ucp.completeCheckout(
+       *   'https://shop.example.com',
+       *   checkout.id,
+       *   {
+       *     corridor: 'pix',
+       *     recipient: {
+       *       type: 'pix',
+       *       pix_key: '12345678901',
+       *       pix_key_type: 'cpf',
+       *       name: 'Maria Silva',
+       *     },
+       *   }
+       * );
+       *
+       * console.log(order.id);
+       * console.log(order.payment.settlement_id);
+       * ```
+       */
+      async completeCheckout(merchantUrl, checkoutId, settlement) {
+        const profile = await this.discover(merchantUrl);
+        if (!profile.checkout?.endpoint) {
+          throw new Error("Merchant does not support UCP checkout");
+        }
+        const checkoutResponse = await fetch(`${profile.checkout.endpoint}/${checkoutId}`, {
+          headers: {
+            "User-Agent": "PayOS-SDK/1.0"
+          }
+        });
+        if (!checkoutResponse.ok) {
+          throw new Error(`Failed to fetch checkout: ${checkoutResponse.status}`);
+        }
+        const checkout = await checkoutResponse.json();
+        const token = await this.acquireToken({
+          corridor: settlement.corridor,
+          amount: checkout.totals.total,
+          currency: checkout.totals.currency,
+          recipient: settlement.recipient
+        });
+        const completeRequest = {
+          payment_handler: "payos_latam",
+          payment_data: {
+            token: token.token
+          }
+        };
+        const completeResponse = await fetch(`${profile.checkout.endpoint}/${checkoutId}/complete`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "User-Agent": "PayOS-SDK/1.0"
+          },
+          body: JSON.stringify(completeRequest)
+        });
+        if (!completeResponse.ok) {
+          const error = await completeResponse.json().catch(() => ({}));
+          throw new Error(`Failed to complete checkout: ${completeResponse.status} - ${JSON.stringify(error)}`);
+        }
+        return await completeResponse.json();
+      }
+      // ===========================================================================
+      // Utilities
+      // ===========================================================================
+      /**
+       * Clear the profile cache (useful for testing)
+       */
+      clearCache() {
+        profileCache.clear();
+      }
+      /**
+       * Check if PayOS supports a specific corridor
+       *
+       * @example
+       * ```typescript
+       * if (await payos.ucp.supportsCorridors('USD', 'BRL', 'pix')) {
+       *   // Can settle via Pix
+       * }
+       * ```
+       */
+      async supportsCorridor(sourceCurrency, destinationCurrency, rail) {
+        const corridors = await this.getCorridors();
+        return corridors.some(
+          (c) => c.source_currency === sourceCurrency && c.destination_currency === destinationCurrency && c.rail === rail
+        );
+      }
+      /**
+       * Create Pix recipient helper
+       *
+       * @example
+       * ```typescript
+       * const recipient = payos.ucp.createPixRecipient({
+       *   pix_key: '12345678901',
+       *   pix_key_type: 'cpf',
+       *   name: 'Maria Silva',
+       * });
+       * ```
+       */
+      createPixRecipient(params) {
+        return {
+          type: "pix",
+          ...params
+        };
+      }
+      /**
+       * Create SPEI recipient helper
+       *
+       * @example
+       * ```typescript
+       * const recipient = payos.ucp.createSpeiRecipient({
+       *   clabe: '012345678901234567',
+       *   name: 'Juan Garcia',
+       * });
+       * ```
+       */
+      createSpeiRecipient(params) {
+        return {
+          type: "spei",
+          ...params
+        };
+      }
+      // ===========================================================================
+      // PayOS-Hosted Checkout Sessions (Phase 2)
+      // ===========================================================================
+      /**
+       * Create a PayOS-hosted checkout session
+       *
+       * @example
+       * ```typescript
+       * const checkout = await payos.ucp.checkouts.create({
+       *   currency: 'USD',
+       *   line_items: [
+       *     { id: 'item_1', name: 'Product', quantity: 1, unit_price: 1000, total_price: 1000, currency: 'USD' }
+       *   ],
+       *   buyer: { email: 'buyer@example.com' },
+       * });
+       * ```
+       */
+      get checkouts() {
+        return {
+          create: async (request) => {
+            return this.client.request("/v1/ucp/checkouts", {
+              method: "POST",
+              body: JSON.stringify(request)
+            });
+          },
+          get: async (checkoutId) => {
+            return this.client.request(`/v1/ucp/checkouts/${checkoutId}`);
+          },
+          update: async (checkoutId, request) => {
+            return this.client.request(`/v1/ucp/checkouts/${checkoutId}`, {
+              method: "PUT",
+              body: JSON.stringify(request)
+            });
+          },
+          complete: async (checkoutId) => {
+            return this.client.request(`/v1/ucp/checkouts/${checkoutId}/complete`, {
+              method: "POST"
+            });
+          },
+          cancel: async (checkoutId) => {
+            return this.client.request(`/v1/ucp/checkouts/${checkoutId}/cancel`, {
+              method: "POST"
+            });
+          },
+          addPaymentInstrument: async (checkoutId, instrument) => {
+            return this.client.request(`/v1/ucp/checkouts/${checkoutId}/instruments`, {
+              method: "POST",
+              body: JSON.stringify(instrument)
+            });
+          }
+        };
+      }
+      // ===========================================================================
+      // PayOS Orders (Phase 3)
+      // ===========================================================================
+      /**
+       * Manage PayOS orders
+       *
+       * @example
+       * ```typescript
+       * const order = await payos.ucp.orders.get('ord_123');
+       * const orders = await payos.ucp.orders.list({ status: 'processing' });
+       * ```
+       */
+      get orders() {
+        return {
+          get: async (orderId) => {
+            return this.client.request(`/v1/ucp/orders/${orderId}`);
+          },
+          list: async (options = {}) => {
+            const params = new URLSearchParams();
+            if (options.status) params.append("status", options.status);
+            if (options.limit) params.append("limit", options.limit.toString());
+            if (options.offset) params.append("offset", options.offset.toString());
+            const queryString = params.toString();
+            const path = queryString ? `/v1/ucp/orders?${queryString}` : "/v1/ucp/orders";
+            return this.client.request(path);
+          },
+          updateStatus: async (orderId, status) => {
+            return this.client.request(`/v1/ucp/orders/${orderId}/status`, {
+              method: "PUT",
+              body: JSON.stringify({ status })
+            });
+          },
+          cancel: async (orderId, reason) => {
+            return this.client.request(`/v1/ucp/orders/${orderId}/cancel`, {
+              method: "POST",
+              body: JSON.stringify({ reason })
+            });
+          },
+          addExpectation: async (orderId, expectation) => {
+            return this.client.request(`/v1/ucp/orders/${orderId}/expectations`, {
+              method: "POST",
+              body: JSON.stringify(expectation)
+            });
+          },
+          updateExpectation: async (orderId, expectationId, updates) => {
+            return this.client.request(
+              `/v1/ucp/orders/${orderId}/expectations/${expectationId}`,
+              {
+                method: "PUT",
+                body: JSON.stringify(updates)
+              }
+            );
+          },
+          addEvent: async (orderId, event) => {
+            return this.client.request(`/v1/ucp/orders/${orderId}/events`, {
+              method: "POST",
+              body: JSON.stringify(event)
+            });
+          },
+          getEvents: async (orderId) => {
+            return this.client.request(
+              `/v1/ucp/orders/${orderId}/events`
+            );
+          },
+          addAdjustment: async (orderId, adjustment) => {
+            return this.client.request(`/v1/ucp/orders/${orderId}/adjustments`, {
+              method: "POST",
+              body: JSON.stringify(adjustment)
+            });
+          }
+        };
+      }
+      // ===========================================================================
+      // Identity Linking (Phase 4)
+      // ===========================================================================
+      /**
+       * OAuth 2.0 identity linking for AI agents/platforms
+       *
+       * @example
+       * ```typescript
+       * // Register an OAuth client
+       * const { client, client_secret } = await payos.ucp.identity.registerClient({
+       *   name: 'My AI Agent',
+       *   redirect_uris: ['https://myagent.com/callback'],
+       * });
+       *
+       * // List linked accounts
+       * const accounts = await payos.ucp.identity.listLinkedAccounts({ buyer_id: 'buyer_123' });
+       * ```
+       */
+      get identity() {
+        return {
+          /**
+           * Register an OAuth client (platform/agent)
+           */
+          registerClient: async (request) => {
+            return this.client.request("/v1/ucp/identity/clients", {
+              method: "POST",
+              body: JSON.stringify(request)
+            });
+          },
+          /**
+           * Get authorization info for consent screen
+           */
+          getAuthorizationInfo: async (params) => {
+            const searchParams = new URLSearchParams();
+            searchParams.append("response_type", params.response_type);
+            searchParams.append("client_id", params.client_id);
+            searchParams.append("redirect_uri", params.redirect_uri);
+            searchParams.append("scope", params.scope);
+            searchParams.append("state", params.state);
+            if (params.code_challenge) {
+              searchParams.append("code_challenge", params.code_challenge);
+            }
+            if (params.code_challenge_method) {
+              searchParams.append("code_challenge_method", params.code_challenge_method);
+            }
+            return this.client.request(
+              `/v1/ucp/identity/authorize?${searchParams.toString()}`
+            );
+          },
+          /**
+           * Submit consent decision (after user authenticates)
+           */
+          submitConsent: async (request) => {
+            return this.client.request("/v1/ucp/identity/authorize/consent", {
+              method: "POST",
+              body: JSON.stringify(request)
+            });
+          },
+          /**
+           * Exchange authorization code for tokens
+           */
+          exchangeCode: async (params) => {
+            return this.client.request("/v1/ucp/identity/token", {
+              method: "POST",
+              body: JSON.stringify({
+                grant_type: "authorization_code",
+                ...params
+              })
+            });
+          },
+          /**
+           * Refresh tokens
+           */
+          refreshTokens: async (params) => {
+            return this.client.request("/v1/ucp/identity/token", {
+              method: "POST",
+              body: JSON.stringify({
+                grant_type: "refresh_token",
+                ...params
+              })
+            });
+          },
+          /**
+           * Revoke a token
+           */
+          revokeToken: async (params) => {
+            return this.client.request("/v1/ucp/identity/revoke", {
+              method: "POST",
+              body: JSON.stringify(params)
+            });
+          },
+          /**
+           * List linked accounts
+           */
+          listLinkedAccounts: async (params) => {
+            const searchParams = new URLSearchParams();
+            if (params.buyer_id) searchParams.append("buyer_id", params.buyer_id);
+            if (params.platform_id) searchParams.append("platform_id", params.platform_id);
+            if (params.limit) searchParams.append("limit", params.limit.toString());
+            if (params.offset) searchParams.append("offset", params.offset.toString());
+            return this.client.request(
+              `/v1/ucp/identity/linked-accounts?${searchParams.toString()}`
+            );
+          },
+          /**
+           * Unlink an account
+           */
+          unlinkAccount: async (accountId, buyerId) => {
+            return this.client.request(
+              `/v1/ucp/identity/linked-accounts/${accountId}?buyer_id=${buyerId}`,
+              { method: "DELETE" }
+            );
+          },
+          /**
+           * Get available scopes
+           */
+          getScopes: async () => {
+            return this.client.request("/v1/ucp/identity/scopes");
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/capabilities/formatters.ts
+var formatters_exports = {};
+__export(formatters_exports, {
+  getClaudeSystemMessage: () => getClaudeSystemMessage,
+  getOpenAISystemMessage: () => getOpenAISystemMessage,
+  toClaudeTool: () => toClaudeTool,
+  toClaudeTools: () => toClaudeTools,
+  toLangChainTool: () => toLangChainTool,
+  toLangChainTools: () => toLangChainTools,
+  toOpenAIFunction: () => toOpenAIFunction,
+  toOpenAIFunctions: () => toOpenAIFunctions
+});
+function createSchemaFromParameterType(paramType) {
+  return {
+    properties: {
+      data: {
+        type: "object",
+        description: `${paramType} object`
+      }
+    },
+    required: ["data"]
+  };
+}
+function toOpenAIFunction(capability) {
+  const schema = typeof capability.parameters === "string" ? createSchemaFromParameterType(capability.parameters) : { properties: {}, required: [] };
+  return {
+    name: capability.name,
+    description: `${capability.description}. Endpoint: ${capability.endpoint}. Errors: ${capability.errors.join(", ")}`,
+    parameters: {
+      type: "object",
+      properties: schema.properties,
+      required: schema.required
+    }
+  };
+}
+function toClaudeTool(capability) {
+  const schema = typeof capability.parameters === "string" ? createSchemaFromParameterType(capability.parameters) : { properties: {}, required: [] };
+  return {
+    name: capability.name,
+    description: `${capability.description}. Endpoint: ${capability.endpoint}. Possible errors: ${capability.errors.join(", ")}`,
+    input_schema: {
+      type: "object",
+      properties: schema.properties,
+      required: schema.required
+    }
+  };
+}
+function toLangChainTool(capability) {
+  const schema = typeof capability.parameters === "string" ? createSchemaFromParameterType(capability.parameters) : { properties: {}, required: [] };
+  return {
+    name: capability.name,
+    description: `${capability.description}. Endpoint: ${capability.endpoint}`,
+    schema: {
+      type: "object",
+      properties: schema.properties,
+      required: schema.required
+    }
+  };
+}
+function toOpenAIFunctions(capabilities) {
+  const caps = Array.isArray(capabilities) ? capabilities : capabilities.capabilities;
+  return caps.map(toOpenAIFunction);
+}
+function toClaudeTools(capabilities) {
+  const caps = Array.isArray(capabilities) ? capabilities : capabilities.capabilities;
+  return caps.map(toClaudeTool);
+}
+function toLangChainTools(capabilities) {
+  const caps = Array.isArray(capabilities) ? capabilities : capabilities.capabilities;
+  return caps.map(toLangChainTool);
+}
+function getOpenAISystemMessage() {
+  return `You are a helpful AI assistant with access to PayOS payment operations. You can help users:
+- Get settlement quotes for cross-border payments
+- Create settlements and transfers
+- Check account balances
+- Verify compliance for recipients
+
+When a user asks about payments or transfers, use the available functions to help them. Always confirm important actions before executing them.`;
+}
+function getClaudeSystemMessage() {
+  return `You are a helpful AI assistant with access to PayOS payment operations. You can help users:
+- Get settlement quotes for cross-border payments
+- Create settlements and transfers
+- Check account balances
+- Verify compliance for recipients
+
+When a user asks about payments or transfers, use the available tools to help them. Always confirm important actions before executing them.`;
+}
+var init_formatters = __esm({
+  "src/capabilities/formatters.ts"() {
+  }
+});
+
+// src/capabilities/client.ts
+var CapabilitiesClient;
+var init_client6 = __esm({
+  "src/capabilities/client.ts"() {
+    CapabilitiesClient = class {
+      // 1 hour
+      constructor(client) {
+        this.cachedCapabilities = null;
+        this.cacheTimestamp = 0;
+        this.cacheTTL = 36e5;
+        this.client = client;
+      }
+      /**
+       * Get all PayOS capabilities
+       * Results are cached for 1 hour by default
+       */
+      async getAll(forceFresh = false) {
+        const now = Date.now();
+        if (!forceFresh && this.cachedCapabilities && now - this.cacheTimestamp < this.cacheTTL) {
+          return this.cachedCapabilities;
+        }
+        const capabilities = await this.client.getCapabilities();
+        this.cachedCapabilities = capabilities;
+        this.cacheTimestamp = now;
+        return capabilities;
+      }
+      /**
+       * Get capabilities filtered by category or name
+       */
+      async filter(filter) {
+        const all = await this.getAll();
+        return all.capabilities.filter((cap) => {
+          if (filter.category && cap.category !== filter.category) {
+            return false;
+          }
+          if (filter.name && cap.name !== filter.name) {
+            return false;
+          }
+          return true;
+        });
+      }
+      /**
+       * Get a single capability by name
+       */
+      async get(name) {
+        const all = await this.getAll();
+        return all.capabilities.find((cap) => cap.name === name);
+      }
+      /**
+       * Get all available categories
+       */
+      async getCategories() {
+        const all = await this.getAll();
+        const categories = new Set(all.capabilities.map((cap) => cap.category));
+        return Array.from(categories);
+      }
+      /**
+       * Clear the capabilities cache
+       */
+      clearCache() {
+        this.cachedCapabilities = null;
+        this.cacheTimestamp = 0;
+      }
+      /**
+       * Get capabilities in OpenAI function-calling format
+       */
+      async toOpenAI() {
+        const response = await this.getAll();
+        const { toOpenAIFunctions: toOpenAIFunctions2, getOpenAISystemMessage: getOpenAISystemMessage2 } = await Promise.resolve().then(() => (init_formatters(), formatters_exports));
+        return {
+          functions: toOpenAIFunctions2(response.capabilities),
+          systemMessage: getOpenAISystemMessage2()
+        };
+      }
+      /**
+       * Get capabilities in OpenAI function-calling format (alias)
+       */
+      async toOpenAIFunctions() {
+        const response = await this.getAll();
+        const { toOpenAIFunctions: toOpenAIFunctions2 } = await Promise.resolve().then(() => (init_formatters(), formatters_exports));
+        return toOpenAIFunctions2(response.capabilities);
+      }
+      /**
+       * Get capabilities in Claude tool format
+       */
+      async toClaude() {
+        const response = await this.getAll();
+        const { toClaudeTools: toClaudeTools2, getClaudeSystemMessage: getClaudeSystemMessage2 } = await Promise.resolve().then(() => (init_formatters(), formatters_exports));
+        return {
+          tools: toClaudeTools2(response.capabilities),
+          systemMessage: getClaudeSystemMessage2()
+        };
+      }
+      /**
+       * Get capabilities in Claude tool format (alias)
+       */
+      async toClaudeTools() {
+        const response = await this.getAll();
+        const { toClaudeTools: toClaudeTools2 } = await Promise.resolve().then(() => (init_formatters(), formatters_exports));
+        return toClaudeTools2(response.capabilities);
+      }
+      /**
+       * Get capabilities in LangChain tool format
+       */
+      async toLangChain() {
+        const response = await this.getAll();
+        const { toLangChainTools: toLangChainTools2 } = await Promise.resolve().then(() => (init_formatters(), formatters_exports));
+        return toLangChainTools2(response.capabilities);
+      }
+    };
+  }
+});
+
+// src/capabilities/types.ts
+var init_types = __esm({
+  "src/capabilities/types.ts"() {
+  }
+});
+
+// src/capabilities/index.ts
+var init_capabilities = __esm({
+  "src/capabilities/index.ts"() {
+    init_client6();
+    init_types();
+    init_formatters();
+  }
+});
+
+// src/langchain/tools.ts
+var LangChainTools;
+var init_tools = __esm({
+  "src/langchain/tools.ts"() {
+    LangChainTools = class {
+      constructor(payos) {
+        this.payos = payos;
+      }
+      /**
+       * Get all PayOS capabilities as LangChain tools
+       */
+      async getTools() {
+        return this.payos.capabilities.toLangChain();
+      }
+      /**
+       * Get a specific tool by name
+       */
+      async getTool(name) {
+        const tools = await this.getTools();
+        return tools.find((tool) => tool.name === name);
+      }
+    };
+  }
+});
+
+// src/cards/types.ts
+var init_types2 = __esm({
+  "src/cards/types.ts"() {
+  }
+});
+
+// src/cards/index.ts
+var VisaClient, MastercardClient, CardsClient;
+var init_cards = __esm({
+  "src/cards/index.ts"() {
+    init_types2();
+    VisaClient = class {
+      constructor(client) {
+        this.client = client;
+      }
+      /**
+       * Create a Visa VIC payment instruction
+       */
+      async createInstruction(params) {
+        return this.client.request("/v1/cards/visa/instructions", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      /**
+       * Get a specific Visa payment instruction
+       */
+      async getInstruction(instructionId) {
+        return this.client.request(
+          `/v1/cards/visa/instructions/${instructionId}`
+        );
+      }
+      /**
+       * List Visa payment instructions
+       */
+      async listInstructions(options) {
+        const params = new URLSearchParams();
+        if (options?.status) params.set("status", options.status);
+        if (options?.limit) params.set("limit", String(options.limit));
+        if (options?.offset) params.set("offset", String(options.offset));
+        const query = params.toString();
+        return this.client.request(
+          `/v1/cards/visa/instructions${query ? `?${query}` : ""}`
+        );
+      }
+      /**
+       * Provision a VTS token for an instruction
+       */
+      async createToken(params) {
+        return this.client.request("/v1/cards/visa/tokens", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      /**
+       * Get a specific Visa token
+       */
+      async getToken(tokenId) {
+        return this.client.request(`/v1/cards/visa/tokens/${tokenId}`);
+      }
+      /**
+       * List Visa tokens
+       */
+      async listTokens(options) {
+        const params = new URLSearchParams();
+        if (options?.status) params.set("status", options.status);
+        if (options?.limit) params.set("limit", String(options.limit));
+        if (options?.offset) params.set("offset", String(options.offset));
+        const query = params.toString();
+        return this.client.request(
+          `/v1/cards/visa/tokens${query ? `?${query}` : ""}`
+        );
+      }
+      /**
+       * Suspend a Visa token
+       */
+      async suspendToken(tokenId) {
+        return this.client.request(
+          `/v1/cards/visa/tokens/${tokenId}`,
+          { method: "DELETE" }
+        );
+      }
+    };
+    MastercardClient = class {
+      constructor(client) {
+        this.client = client;
+      }
+      /**
+       * Register an agent with Mastercard Agent Pay
+       */
+      async registerAgent(params) {
+        return this.client.request("/v1/cards/mastercard/agents", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      /**
+       * Get a specific Mastercard agent registration
+       */
+      async getAgent(agentId) {
+        return this.client.request(
+          `/v1/cards/mastercard/agents/${agentId}`
+        );
+      }
+      /**
+       * List registered Mastercard agents
+       */
+      async listAgents() {
+        return this.client.request(
+          "/v1/cards/mastercard/agents"
+        );
+      }
+      /**
+       * Create a Mastercard agentic token with DTVC
+       */
+      async createToken(params) {
+        return this.client.request("/v1/cards/mastercard/tokens", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      /**
+       * Get a Mastercard token, optionally refreshing the DTVC
+       */
+      async getToken(tokenReference, options) {
+        const query = options?.refresh ? "?refresh=true" : "";
+        return this.client.request(
+          `/v1/cards/mastercard/tokens/${tokenReference}${query}`
+        );
+      }
+      /**
+       * List Mastercard tokens
+       */
+      async listTokens(options) {
+        const params = new URLSearchParams();
+        if (options?.status) params.set("status", options.status);
+        if (options?.limit) params.set("limit", String(options.limit));
+        if (options?.offset) params.set("offset", String(options.offset));
+        const query = params.toString();
+        return this.client.request(
+          `/v1/cards/mastercard/tokens${query ? `?${query}` : ""}`
+        );
+      }
+      /**
+       * Revoke a Mastercard token
+       */
+      async revokeToken(tokenReference) {
+        return this.client.request(
+          `/v1/cards/mastercard/tokens/${tokenReference}`,
+          { method: "DELETE" }
+        );
+      }
+    };
+    CardsClient = class {
+      constructor(client) {
+        this.client = client;
+        this.visa = new VisaClient(client);
+        this.mastercard = new MastercardClient(client);
+      }
+      /**
+       * Verify an AI agent's Web Bot Auth signature
+       *
+       * @example
+       * ```typescript
+       * const result = await payos.cards.verifyAgentSignature({
+       *   method: 'POST',
+       *   path: '/checkout',
+       *   headers: req.headers,
+       *   signatureInput: req.headers['signature-input'],
+       *   signature: req.headers['signature'],
+       * });
+       *
+       * if (result.valid) {
+       *   console.log(`Verified ${result.network} agent from ${result.agentProvider}`);
+       * }
+       * ```
+       */
+      async verifyAgentSignature(params) {
+        return this.client.request("/v1/cards/verify", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      /**
+       * Get configured card networks and their status
+       *
+       * @example
+       * ```typescript
+       * const { networks, capabilities } = await payos.cards.getNetworks();
+       *
+       * if (networks.visa.configured) {
+       *   console.log(`Visa: ${networks.visa.status}`);
+       * }
+       * ```
+       */
+      async getNetworks() {
+        return this.client.request("/v1/cards/networks");
+      }
+      /**
+       * Test connection to a card network
+       */
+      async testNetwork(network) {
+        return this.client.request(`/v1/cards/networks/${network}/test`, {
+          method: "POST"
+        });
+      }
+      /**
+       * Configure Visa VIC credentials
+       */
+      async configureVisa(params) {
+        return this.client.request("/v1/cards/networks/visa/configure", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      /**
+       * Configure Mastercard Agent Pay credentials
+       */
+      async configureMastercard(params) {
+        return this.client.request("/v1/cards/networks/mastercard/configure", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+      }
+      /**
+       * Disconnect a card network
+       */
+      async disconnectNetwork(network) {
+        return this.client.request(
+          `/v1/cards/networks/${network}/disconnect`,
+          { method: "DELETE" }
+        );
+      }
+      /**
+       * Get comprehensive card network analytics
+       *
+       * @param days - Number of days to analyze (default: 30)
+       *
+       * @example
+       * ```typescript
+       * const analytics = await payos.cards.getAnalytics(30);
+       *
+       * console.log(`Success rate: ${analytics.verifications.successRate}%`);
+       * console.log(`Total volume: $${analytics.transactions.volume}`);
+       * ```
+       */
+      async getAnalytics(days = 30) {
+        return this.client.request(`/v1/cards/analytics?days=${days}`);
+      }
+      /**
+       * Get verification statistics
+       *
+       * @param days - Number of days to analyze (default: 30)
+       */
+      async getVerificationStats(days = 30) {
+        return this.client.request(`/v1/cards/verifications/stats?days=${days}`);
+      }
+      /**
+       * List card network transactions
+       */
+      async listTransactions(options) {
+        const params = new URLSearchParams();
+        if (options?.network) params.set("network", options.network);
+        if (options?.status) params.set("status", options.status);
+        if (options?.limit) params.set("limit", String(options.limit));
+        if (options?.offset) params.set("offset", String(options.offset));
+        const query = params.toString();
+        return this.client.request(
+          `/v1/cards/transactions${query ? `?${query}` : ""}`
+        );
+      }
+      /**
+       * Get a specific transaction
+       */
+      async getTransaction(transactionId) {
+        return this.client.request(`/v1/cards/transactions/${transactionId}`);
+      }
+      // ============================================
+      // Agent Signing Methods
+      // ============================================
+      /**
+       * Generate a signing key for an agent
+       *
+       * Creates an Ed25519 or RSA-SHA256 key pair for the agent to sign
+       * payment requests according to RFC 9421 (HTTP Message Signatures).
+       *
+       * @example
+       * ```typescript
+       * const key = await payos.cards.generateSigningKey('agent_123');
+       * console.log(`Public key: ${key.publicKey}`);
+       * // Register this public key with card networks (Visa TAP, MC Agent Pay)
+       * ```
+       */
+      async generateSigningKey(agentId, options) {
+        return this.client.request(
+          `/v1/agents/${agentId}/signing-keys`,
+          {
+            method: "POST",
+            body: JSON.stringify(options || {})
+          }
+        );
+      }
+      /**
+       * Get the signing key status for an agent
+       *
+       * @example
+       * ```typescript
+       * const status = await payos.cards.getSigningKey('agent_123');
+       * if (status.hasKey) {
+       *   console.log(`Key: ${status.keyId}, Uses: ${status.stats.useCount}`);
+       * }
+       * ```
+       */
+      async getSigningKey(agentId) {
+        return this.client.request(`/v1/agents/${agentId}/signing-keys`);
+      }
+      /**
+       * Revoke an agent's signing key
+       *
+       * After revocation, the agent will need a new key to sign requests.
+       */
+      async revokeSigningKey(agentId) {
+        return this.client.request(
+          `/v1/agents/${agentId}/signing-keys`,
+          { method: "DELETE" }
+        );
+      }
+      /**
+       * Sign a payment request for an agent
+       *
+       * Signs an HTTP request according to RFC 9421 so the agent can
+       * authenticate with merchants and card networks.
+       *
+       * Requirements:
+       * - Agent must have KYA tier >= 1
+       * - Agent must be active
+       * - Agent must have a signing key
+       * - Payment must be within spending limits
+       *
+       * @example
+       * ```typescript
+       * // Sign a payment request
+       * const signed = await payos.cards.signRequest('agent_123', {
+       *   method: 'POST',
+       *   path: '/api/checkout',
+       *   host: 'merchant.com',
+       *   body: JSON.stringify({ items: [...], total: 99.99 }),
+       *   payment: {
+       *     amount: 99.99,
+       *     currency: 'USD',
+       *     merchantName: 'Acme Store',
+       *   },
+       * });
+       *
+       * // Agent uses signed headers to call merchant
+       * const response = await fetch('https://merchant.com/api/checkout', {
+       *   method: 'POST',
+       *   headers: {
+       *     ...signed.headers,
+       *     'Content-Type': 'application/json',
+       *   },
+       *   body: JSON.stringify({ items: [...], total: 99.99 }),
+       * });
+       * ```
+       */
+      async signRequest(agentId, request) {
+        return this.client.request(
+          `/v1/agents/${agentId}/sign-request`,
+          {
+            method: "POST",
+            body: JSON.stringify(request)
+          }
+        );
+      }
+    };
+  }
+});
+
+// src/protocols/a2a/client.ts
+var A2AClient;
+var init_client7 = __esm({
+  "src/protocols/a2a/client.ts"() {
+    A2AClient = class {
+      constructor(client) {
+        this.client = client;
+      }
+      /**
+       * Discover an agent's capabilities via its Agent Card.
+       *
+       * @example
+       * ```typescript
+       * const card = await sly.a2a.discover('agent-uuid');
+       * console.log(card.skills);
+       * ```
+       */
+      async discover(agentId) {
+        return this.client.request(
+          `/v1/a2a/${agentId}/.well-known/agent.json`
+        );
+      }
+      /**
+       * Send a message to an agent, creating or continuing a task.
+       *
+       * @example
+       * ```typescript
+       * const task = await sly.a2a.sendMessage('agent-uuid', {
+       *   message: 'Check my wallet balance',
+       * });
+       * console.log(task.status.state); // 'submitted' or 'completed'
+       * ```
+       */
+      async sendMessage(agentId, params) {
+        const parts = typeof params.message === "string" ? [{ text: params.message }] : params.message;
+        const body = {
+          jsonrpc: "2.0",
+          method: "message/send",
+          params: {
+            message: { role: "user", parts, metadata: params.metadata },
+            ...params.contextId && { contextId: params.contextId },
+            ...params.configuration && { configuration: params.configuration },
+            ...params.skillId && { skill_id: params.skillId }
+          },
+          id: crypto.randomUUID()
+        };
+        const response = await this.client.request(
+          `/v1/a2a/${agentId}`,
+          { method: "POST", body: JSON.stringify(body) }
+        );
+        return response.result;
+      }
+      /**
+       * Get a task by ID.
+       *
+       * @example
+       * ```typescript
+       * const task = await sly.a2a.getTask('agent-uuid', 'task-uuid');
+       * console.log(task.status.state);
+       * ```
+       */
+      async getTask(agentId, taskId, historyLength) {
+        const body = {
+          jsonrpc: "2.0",
+          method: "tasks/get",
+          params: { id: taskId, ...historyLength && { historyLength } },
+          id: crypto.randomUUID()
+        };
+        const response = await this.client.request(
+          `/v1/a2a/${agentId}`,
+          { method: "POST", body: JSON.stringify(body) }
+        );
+        return response.result;
+      }
+      /**
+       * Cancel a task.
+       */
+      async cancelTask(agentId, taskId) {
+        const body = {
+          jsonrpc: "2.0",
+          method: "tasks/cancel",
+          params: { id: taskId },
+          id: crypto.randomUUID()
+        };
+        const response = await this.client.request(
+          `/v1/a2a/${agentId}`,
+          { method: "POST", body: JSON.stringify(body) }
+        );
+        return response.result;
+      }
+      /**
+       * List tasks for an agent (REST endpoint).
+       *
+       * @example
+       * ```typescript
+       * const { data, pagination } = await sly.a2a.listTasks({
+       *   agentId: 'agent-uuid',
+       *   state: 'completed',
+       *   limit: 20,
+       * });
+       * ```
+       */
+      async listTasks(options = {}) {
+        const params = new URLSearchParams();
+        if (options.agentId) params.append("agent_id", options.agentId);
+        if (options.state) params.append("state", options.state);
+        if (options.direction) params.append("direction", options.direction);
+        if (options.contextId) params.append("context_id", options.contextId);
+        if (options.page) params.append("page", options.page.toString());
+        if (options.limit) params.append("limit", options.limit.toString());
+        const qs = params.toString();
+        return this.client.request(
+          qs ? `/v1/a2a/tasks?${qs}` : "/v1/a2a/tasks"
+        );
+      }
+      /**
+       * Respond to a task in input-required state (human-in-the-loop).
+       */
+      async respond(taskId, message) {
+        return this.client.request(
+          `/v1/a2a/tasks/${taskId}/respond`,
+          { method: "POST", body: JSON.stringify({ message }) }
+        );
+      }
+      // =========================================================================
+      // Custom Tools (Story 58.15)
+      // =========================================================================
+      /**
+       * Register a custom tool for an agent.
+       *
+       * @example
+       * ```typescript
+       * const tool = await sly.a2a.createCustomTool('agent-uuid', {
+       *   toolName: 'lookup_inventory',
+       *   description: 'Check product inventory levels',
+       *   inputSchema: {
+       *     type: 'object',
+       *     properties: { sku: { type: 'string' } },
+       *     required: ['sku'],
+       *   },
+       *   handlerUrl: 'https://api.example.com/inventory',
+       * });
+       * ```
+       */
+      async createCustomTool(agentId, request) {
+        const response = await this.client.request(
+          `/v1/a2a/agents/${agentId}/tools`,
+          { method: "POST", body: JSON.stringify(request) }
+        );
+        return response.data;
+      }
+      /**
+       * List custom tools for an agent.
+       */
+      async listCustomTools(agentId) {
+        const response = await this.client.request(
+          `/v1/a2a/agents/${agentId}/tools`
+        );
+        return response.data;
+      }
+      /**
+       * Delete a custom tool.
+       */
+      async deleteCustomTool(agentId, toolId) {
+        await this.client.request(
+          `/v1/a2a/agents/${agentId}/tools/${toolId}`,
+          { method: "DELETE" }
+        );
+      }
+    };
+  }
+});
+
+// src/protocols/agent-wallets/client.ts
+var AgentWalletsClient;
+var init_client8 = __esm({
+  "src/protocols/agent-wallets/client.ts"() {
+    AgentWalletsClient = class {
+      constructor(client) {
+        this.client = client;
+      }
+      /**
+       * Evaluate a contract policy in dry-run mode (negotiation guardrails).
+       *
+       * @example
+       * ```typescript
+       * const result = await sly.agentWallets.evaluatePolicy('agent-uuid', {
+       *   amount: 150,
+       *   actionType: 'payment',
+       *   counterpartyAgentId: 'other-agent-uuid',
+       * });
+       * console.log(result.decision); // 'approve' | 'escalate' | 'deny'
+       * ```
+       */
+      async evaluatePolicy(agentId, request) {
+        const response = await this.client.request(
+          `/v1/agents/${agentId}/wallet/policy/evaluate`,
+          {
+            method: "POST",
+            body: JSON.stringify({
+              amount: request.amount,
+              currency: request.currency || "USDC",
+              action_type: request.actionType,
+              contract_type: request.contractType,
+              counterparty_agent_id: request.counterpartyAgentId,
+              counterparty_address: request.counterpartyAddress,
+              protocol: request.protocol
+            })
+          }
+        );
+        const d = response.data || response;
+        return {
+          decision: d.decision,
+          reasons: d.reasons,
+          checks: d.checks,
+          suggestedCounterOffer: d.suggested_counter_offer ? {
+            maxAmount: d.suggested_counter_offer.max_amount,
+            reason: d.suggested_counter_offer.reason
+          } : null,
+          evaluationMs: d.evaluation_ms
+        };
+      }
+      /**
+       * List counterparty exposures for an agent's wallet.
+       *
+       * @example
+       * ```typescript
+       * const exposures = await sly.agentWallets.getExposures('agent-uuid');
+       * for (const exp of exposures) {
+       *   console.log(`${exp.counterpartyAgentId}: ${exp.exposure24h} (24h)`);
+       * }
+       * ```
+       */
+      async getExposures(agentId) {
+        const response = await this.client.request(
+          `/v1/agents/${agentId}/wallet/exposures`
+        );
+        const items = response.data || [];
+        return items.map((e) => ({
+          id: e.id,
+          walletId: e.wallet_id,
+          counterpartyAgentId: e.counterparty_agent_id,
+          counterpartyAddress: e.counterparty_address,
+          exposure24h: e.exposure_24h,
+          exposure7d: e.exposure_7d,
+          exposure30d: e.exposure_30d,
+          activeContracts: e.active_contracts,
+          activeEscrows: e.active_escrows,
+          totalVolume: e.total_volume,
+          transactionCount: e.transaction_count,
+          currency: e.currency
+        }));
+      }
+      /**
+       * Get policy evaluation audit log for an agent's wallet.
+       */
+      async getEvaluations(agentId, options) {
+        const params = new URLSearchParams();
+        if (options?.page) params.set("page", options.page.toString());
+        if (options?.limit) params.set("limit", options.limit.toString());
+        const qs = params.toString();
+        const response = await this.client.request(
+          `/v1/agents/${agentId}/wallet/policy/evaluations${qs ? `?${qs}` : ""}`
+        );
+        return {
+          data: (response.data || []).map((e) => ({
+            id: e.id,
+            actionType: e.action_type,
+            amount: e.amount,
+            currency: e.currency,
+            contractType: e.contract_type,
+            counterpartyAgentId: e.counterparty_agent_id,
+            counterpartyAddress: e.counterparty_address,
+            decision: e.decision,
+            decisionReasons: e.decision_reasons,
+            suggestedCounterOffer: e.suggested_counter_offer,
+            checksPerformed: e.checks_performed,
+            evaluationMs: e.evaluation_ms,
+            createdAt: e.created_at
+          })),
+          pagination: response.pagination
+        };
+      }
+      /**
+       * Get an agent's wallet details.
+       */
+      async getWallet(agentId) {
+        const response = await this.client.request(
+          `/v1/agents/${agentId}/wallet`
+        );
+        return response.data || response;
+      }
+      /**
+       * Freeze an agent's wallet (disables all payments).
+       */
+      async freezeWallet(agentId) {
+        const response = await this.client.request(
+          `/v1/agents/${agentId}/wallet/freeze`,
+          { method: "POST" }
+        );
+        return response.data || response;
+      }
+      /**
+       * Unfreeze an agent's wallet (re-enables payments).
+       */
+      async unfreezeWallet(agentId) {
+        const response = await this.client.request(
+          `/v1/agents/${agentId}/wallet/unfreeze`,
+          { method: "POST" }
+        );
+        return response.data || response;
+      }
+      /**
+       * Set or update the contract policy on an agent's wallet.
+       *
+       * @example
+       * ```typescript
+       * await sly.agentWallets.setContractPolicy('agent-uuid', {
+       *   dailySpendLimit: 500,
+       *   contractPolicy: {
+       *     counterpartyBlocklist: ['bad-agent-id'],
+       *     maxExposure24h: 200,
+       *     escalateAbove: 100,
+       *   },
+       * });
+       * ```
+       */
+      async setContractPolicy(agentId, policy) {
+        const response = await this.client.request(
+          `/v1/agents/${agentId}/wallet/policy`,
+          {
+            method: "PUT",
+            body: JSON.stringify(policy)
+          }
+        );
+        return response.data || response;
+      }
+    };
+  }
+});
+
+// src/protocols/mpp/client.ts
+var MPPClient;
+var init_client9 = __esm({
+  "src/protocols/mpp/client.ts"() {
+    MPPClient = class {
+      constructor(client) {
+        this.client = client;
+      }
+      /**
+       * Make a one-shot MPP payment to a service
+       *
+       * @example
+       * ```typescript
+       * const result = await sly.mpp.pay({
+       *   service_url: 'https://api.example.com',
+       *   amount: 0.50,
+       *   agent_id: 'agent-uuid',
+       * });
+       * ```
+       */
+      async pay(request) {
+        return this.client.request("/v1/mpp/pay", {
+          method: "POST",
+          body: JSON.stringify(request)
+        });
+      }
+      /**
+       * Open a streaming payment session
+       *
+       * @example
+       * ```typescript
+       * const session = await sly.mpp.openSession({
+       *   service_url: 'https://api.example.com',
+       *   deposit_amount: 10.00,
+       *   agent_id: 'agent-uuid',
+       *   wallet_id: 'wallet-uuid',
+       * });
+       * ```
+       */
+      async openSession(request) {
+        return this.client.request("/v1/mpp/sessions", {
+          method: "POST",
+          body: JSON.stringify(request)
+        });
+      }
+      /**
+       * Get session details with voucher history
+       */
+      async getSession(sessionId) {
+        return this.client.request(`/v1/mpp/sessions/${sessionId}`);
+      }
+      /**
+       * List MPP sessions with optional filtering
+       */
+      async listSessions(options = {}) {
+        const params = new URLSearchParams();
+        if (options.agent_id) params.append("agent_id", options.agent_id);
+        if (options.status) params.append("status", options.status);
+        if (options.limit) params.append("limit", options.limit.toString());
+        if (options.offset) params.append("offset", options.offset.toString());
+        const queryString = params.toString();
+        const path = queryString ? `/v1/mpp/sessions?${queryString}` : "/v1/mpp/sessions";
+        return this.client.request(path);
+      }
+      /**
+       * Close an active session
+       */
+      async closeSession(sessionId) {
+        return this.client.request(`/v1/mpp/sessions/${sessionId}/close`, {
+          method: "POST"
+        });
+      }
+      /**
+       * List MPP payment transfers
+       */
+      async listTransfers(options = {}) {
+        const params = new URLSearchParams();
+        if (options.service_url) params.append("service_url", options.service_url);
+        if (options.session_id) params.append("session_id", options.session_id);
+        if (options.limit) params.append("limit", options.limit.toString());
+        if (options.offset) params.append("offset", options.offset.toString());
+        const queryString = params.toString();
+        const path = queryString ? `/v1/mpp/transfers?${queryString}` : "/v1/mpp/transfers";
+        return this.client.request(path);
+      }
+      /**
+       * Verify an MPP payment receipt
+       */
+      async verifyReceipt(receiptId) {
+        return this.client.request("/v1/mpp/receipts/verify", {
+          method: "POST",
+          body: JSON.stringify({ receipt_id: receiptId })
+        });
+      }
+      /**
+       * Provision a wallet for MPP payments
+       */
+      async provisionWallet(request) {
+        return this.client.request("/v1/mpp/wallets/provision", {
+          method: "POST",
+          body: JSON.stringify(request)
+        });
+      }
+      /**
+       * Browse the MPP service directory
+       */
+      async browseServices(options) {
+        const params = new URLSearchParams();
+        if (options?.category) params.append("category", options.category);
+        if (options?.limit) params.append("limit", options.limit.toString());
+        const queryString = params.toString();
+        const path = queryString ? `/v1/mpp/services?${queryString}` : "/v1/mpp/services";
+        return this.client.request(path);
+      }
+      /**
+       * Get pricing info for a service
+       */
+      async getServicePricing(domain) {
+        return this.client.request(`/v1/mpp/services/${domain}/pricing`);
+      }
+    };
+  }
+});
+
+// src/types.ts
+var init_types3 = __esm({
+  "src/types.ts"() {
+  }
+});
+
+// src/auth.ts
+async function loginWithPassword(credentials, apiUrl = "http://localhost:4000") {
+  const response = await fetch(`${apiUrl}/v1/auth/login`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(credentials)
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({
+      error: response.statusText
+    }));
+    throw new Error(error.error || `Login failed: ${response.status}`);
+  }
+  return response.json();
+}
+async function createWithPassword(credentials, environment = "sandbox", apiUrl) {
+  const { PayOS } = await Promise.resolve().then(() => (init_src(), src_exports));
+  const auth = await loginWithPassword(credentials, apiUrl);
+  return new PayOS({
+    apiKey: auth.access_token,
+    environment,
+    apiUrl
+  });
+}
+async function verifyApiKey(apiKey, apiUrl = "http://localhost:4000") {
+  try {
+    const response = await fetch(`${apiUrl}/v1/auth/me`, {
+      headers: {
+        "Authorization": `Bearer ${apiKey}`
+      }
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+var init_auth = __esm({
+  "src/auth.ts"() {
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ENVIRONMENT_CONFIGS: () => exports.ENVIRONMENT_CONFIGS,
+  PayOS: () => exports.Sly,
+  PayOSClient: () => exports.SlyClient,
+  Sly: () => exports.Sly,
+  SlyClient: () => exports.SlyClient,
+  createWithPassword: () => createWithPassword,
+  getEnvironmentConfig: () => getEnvironmentConfig,
+  inferEnvironmentFromKey: () => inferEnvironmentFromKey,
+  loginWithPassword: () => loginWithPassword,
+  validateEnvironment: () => validateEnvironment,
+  verifyApiKey: () => verifyApiKey
+});
+exports.Sly = void 0;
+var init_src = __esm({
+  "src/index.ts"() {
+    init_client();
+    init_config();
+    init_client2();
+    init_provider();
+    init_client3();
+    init_client4();
+    init_client5();
+    init_capabilities();
+    init_tools();
+    init_cards();
+    init_client7();
+    init_client8();
+    init_client9();
+    init_types3();
+    init_config();
+    init_client();
+    init_auth();
+    exports.Sly = class extends exports.SlyClient {
+      constructor(config) {
+        if (!config.apiKey || config.apiKey.trim() === "") {
+          throw new Error("API key is required");
+        }
+        const resolvedEnvironment = config.environment ?? inferEnvironmentFromKey(config.apiKey) ?? "sandbox";
+        const resolvedConfig = { ...config, environment: resolvedEnvironment };
+        super(resolvedConfig);
+        this.x402 = {
+          createClient: (overrides) => {
+            return new SlyX402Client({
+              ...resolvedConfig,
+              ...overrides
+            });
+          },
+          createProvider: (routes) => {
+            return new SlyX402Provider({
+              apiKey: config.apiKey,
+              environment: resolvedEnvironment,
+              routes,
+              facilitatorUrl: config.facilitatorUrl
+            });
+          }
+        };
+        this.ap2 = new AP2Client(this);
+        this.acp = new ACPClient(this);
+        this.ucp = new UCPClient(this);
+        this.capabilities = new CapabilitiesClient(this);
+        this.langchain = new LangChainTools(this);
+        this.cards = new CardsClient(this);
+        this.a2a = new A2AClient(this);
+        this.agentWallets = new AgentWalletsClient(this);
+        this.mpp = new MPPClient(this);
+      }
+    };
+  }
+});
+init_src();
+
+exports.PayOS = exports.Sly;
+exports.PayOSClient = exports.SlyClient;
+exports.createWithPassword = createWithPassword;
+exports.getEnvironmentConfig = getEnvironmentConfig;
+exports.inferEnvironmentFromKey = inferEnvironmentFromKey;
+exports.loginWithPassword = loginWithPassword;
+exports.validateEnvironment = validateEnvironment;
+exports.verifyApiKey = verifyApiKey;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map