arispay 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,216 @@
+import { RegisterAgentRequest, AgentResponse, AgentListResponse, SetCircuitBreakerRequest, CircuitBreakerResponse, RotateKeysResponse, AgentBalanceResponse, AgentTopupRequest, AgentTopupResponse, AgentSweepRequest, AgentSweepResponse, LedgerHistoryResponse, AgentEarningRequest, CreateUserRequest, UserResponse, WalletStatusResponse, SetupPaymentMethodResponse, WalletPaymentMethodResponse, SetLimitsRequest, SpendLimitsResponse, CreatePaymentRequest, PaymentResponse, Complete3dsRequest, ListTransactionsQuery, TransactionListResponse, RegisterWebhookRequest, WebhookResponse } from '@arispay/shared';
+export { AgentBalanceResponse, AgentEarningRequest, AgentModeMismatchError, AgentSweepRequest, AgentSweepResponse, AgentTopupRequest, AgentTopupResponse, ArisPayError, InsufficientBalanceError, InsufficientFundsError, LedgerEntryResponse, LedgerHistoryResponse, SpendLimitExceededError } from '@arispay/shared';
+
+declare class HttpClient {
+    private baseUrl;
+    private apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    private request;
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    put<T>(path: string, body?: unknown): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+}
+
+interface ChildAgentSummary {
+    id: string;
+    name: string;
+    status: string;
+    permissions: string[];
+    delegatedBudget: number | null;
+    delegatedBudgetDay: number | null;
+    delegatedBudgetMo: number | null;
+    createdAt: string;
+}
+declare class AgentService {
+    private client;
+    constructor(client: HttpClient);
+    register(params: RegisterAgentRequest): Promise<AgentResponse>;
+    get(agentId: string): Promise<AgentResponse>;
+    list(params?: {
+        name?: string;
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<AgentListResponse>;
+    listChildren(agentId: string): Promise<ChildAgentSummary[]>;
+    resume(agentId: string): Promise<{
+        status: string;
+        resumedAt: string;
+    }>;
+    setCircuitBreaker(agentId: string, params: SetCircuitBreakerRequest): Promise<CircuitBreakerResponse>;
+    getCircuitBreaker(agentId: string): Promise<CircuitBreakerResponse>;
+    rotateKeys(agentId: string): Promise<RotateKeysResponse>;
+    /**
+     * Get the current balance for an autonomous agent.
+     */
+    getBalance(agentId: string): Promise<AgentBalanceResponse>;
+    /**
+     * Fund an autonomous agent's balance (topup).
+     */
+    topup(agentId: string, params: AgentTopupRequest): Promise<AgentTopupResponse>;
+    /**
+     * Withdraw from an autonomous agent's balance (sweep).
+     * Omit `amount` to sweep everything above the sweep threshold.
+     */
+    sweep(agentId: string, params?: AgentSweepRequest): Promise<AgentSweepResponse>;
+    /**
+     * Get paginated ledger history for an autonomous agent.
+     */
+    getLedger(agentId: string, params?: {
+        limit?: number;
+        offset?: number;
+        type?: string;
+        from?: string;
+        to?: string;
+    }): Promise<LedgerHistoryResponse>;
+    /**
+     * Record an earning (inbound money) for an autonomous agent.
+     */
+    recordEarning(agentId: string, params: AgentEarningRequest): Promise<AgentTopupResponse>;
+}
+
+declare class UserService {
+    private client;
+    constructor(client: HttpClient);
+    create(params: CreateUserRequest): Promise<UserResponse>;
+    get(userId: string): Promise<UserResponse>;
+    getByExternalId(externalId: string): Promise<UserResponse>;
+    getWalletStatus(userId: string): Promise<WalletStatusResponse>;
+    /** Hosted card flow — returns setupUrl for redirect */
+    addPaymentMethod(params: {
+        userId: string;
+        type: 'card';
+        returnUrl: string;
+    }): Promise<SetupPaymentMethodResponse>;
+    /** Direct card tokenization — returns user with card attached */
+    addPaymentMethod(params: {
+        userId: string;
+        type: 'card';
+        cardNumber: string;
+        expiryMonth: string;
+        expiryYear: string;
+        securityCode: string;
+    }): Promise<UserResponse>;
+    addPaymentMethod(params: {
+        userId: string;
+        type: 'wallet';
+        walletAddress: string;
+        chain: string;
+    }): Promise<WalletPaymentMethodResponse>;
+    completePaymentMethod(params: {
+        userId: string;
+        sessionId: string;
+    }): Promise<UserResponse>;
+    setLimits(params: {
+        userId: string;
+    } & SetLimitsRequest): Promise<SpendLimitsResponse>;
+}
+
+declare class PaymentService {
+    private client;
+    constructor(client: HttpClient);
+    create(params: CreatePaymentRequest): Promise<PaymentResponse>;
+    get(paymentId: string): Promise<PaymentResponse>;
+    /** Complete a 3D Secure authentication step (method or challenge) */
+    complete3ds(paymentId: string, params: Complete3dsRequest): Promise<PaymentResponse>;
+}
+
+declare class TransactionService {
+    private client;
+    constructor(client: HttpClient);
+    list(params?: ListTransactionsQuery): Promise<TransactionListResponse>;
+}
+
+declare class WebhookService {
+    private client;
+    constructor(client: HttpClient);
+    register(params: RegisterWebhookRequest): Promise<WebhookResponse & {
+        secret: string;
+    }>;
+    list(): Promise<WebhookResponse[]>;
+    delete(webhookId: string): Promise<void>;
+    /**
+     * Verify a webhook signature from an incoming request.
+     *
+     * ArisPay signs every webhook delivery with HMAC-SHA256 using the secret
+     * returned when you registered the webhook. The signature is sent in the
+     * `X-ArisPay-Signature` header and the unix timestamp in `X-ArisPay-Timestamp`.
+     *
+     * @param body      - The raw request body string (do NOT parse it first)
+     * @param signature - Value of the `X-ArisPay-Signature` header
+     * @param timestamp - Value of the `X-ArisPay-Timestamp` header
+     * @param secret    - Your webhook secret (`whsec_...`)
+     * @param toleranceSec - Maximum allowed age in seconds (default: 300 = 5 min)
+     * @returns `true` if the signature is valid and the timestamp is within tolerance
+     *
+     * @example
+     * ```ts
+     * import { WebhookService } from 'arispay';
+     *
+     * app.post('/webhooks', (req, res) => {
+     *   const isValid = WebhookService.verifyWebhookSignature(
+     *     req.body,                              // raw body string
+     *     req.headers['x-arispay-signature'],
+     *     req.headers['x-arispay-timestamp'],
+     *     process.env.WEBHOOK_SECRET!,
+     *   );
+     *   if (!isValid) return res.status(401).send('Invalid signature');
+     *   // Process the webhook event...
+     * });
+     * ```
+     */
+    static verifyWebhookSignature(body: string, signature: string, timestamp: string, secret: string, toleranceSec?: number): boolean;
+}
+
+interface ArisPayConfig {
+    apiKey: string;
+    environment?: 'sandbox' | 'production';
+    baseUrl?: string;
+}
+interface ArisPayClient {
+    agents: AgentService;
+    users: UserService;
+    payments: PaymentService;
+    transactions: TransactionService;
+    webhooks: WebhookService;
+}
+declare class ArisPay {
+    /**
+     * Initialize the ArisPay SDK.
+     *
+     * @example
+     * ```ts
+     * import ArisPay from 'arispay';
+     *
+     * const arispay = ArisPay.init({
+     *   apiKey: 'ap_test_abc123',
+     *   environment: 'sandbox',
+     * });
+     *
+     * const agent = await arispay.agents.register({
+     *   name: 'TableClaw',
+     *   description: 'AI restaurant booking agent',
+     *   permissions: ['browse', 'payment'],
+     * });
+     *
+     * const user = await arispay.users.create({
+     *   externalId: 'user_123',
+     *   email: 'jane@example.com',
+     * });
+     *
+     * const payment = await arispay.payments.create({
+     *   agentId: agent.id,
+     *   userId: user.id,
+     *   amount: 20000,
+     *   currency: 'USD',
+     *   merchantUrl: 'https://nobu.com',
+     *   memo: 'Table for 2',
+     *   idempotencyKey: 'booking_123',
+     * });
+     * ```
+     */
+    static init(config: ArisPayConfig): ArisPayClient;
+}
+
+export { AgentService, ArisPay, type ArisPayClient, type ArisPayConfig, PaymentService, TransactionService, UserService, WebhookService, ArisPay as default };

package/dist/index.js

@@ -0,0 +1,406 @@
+// ../shared/dist/constants.js
+var CRYPTO_CHAINS = {
+  ETHEREUM: "ethereum",
+  BASE: "base",
+  POLYGON: "polygon",
+  SOLANA: "solana"
+};
+var SUPPORTED_CHAINS = Object.values(CRYPTO_CHAINS);
+var ERROR_CODES = {
+  INSUFFICIENT_FUNDS: "INSUFFICIENT_FUNDS",
+  SPEND_LIMIT_EXCEEDED: "SPEND_LIMIT_EXCEEDED",
+  MERCHANT_REJECTED: "MERCHANT_REJECTED",
+  TAP_VERIFICATION_FAILED: "TAP_VERIFICATION_FAILED",
+  CARD_DECLINED: "CARD_DECLINED",
+  INVALID_API_KEY: "INVALID_API_KEY",
+  RATE_LIMITED: "RATE_LIMITED",
+  IDEMPOTENCY_CONFLICT: "IDEMPOTENCY_CONFLICT",
+  AGENT_NOT_FOUND: "AGENT_NOT_FOUND",
+  USER_NOT_FOUND: "USER_NOT_FOUND",
+  PAYMENT_NOT_FOUND: "PAYMENT_NOT_FOUND",
+  INVALID_REQUEST: "INVALID_REQUEST",
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  CIRCUIT_BREAKER_TRIPPED: "CIRCUIT_BREAKER_TRIPPED",
+  AGENT_SUSPENDED: "AGENT_SUSPENDED",
+  WALLET_NOT_FOUND: "WALLET_NOT_FOUND",
+  INSUFFICIENT_ALLOWANCE: "INSUFFICIENT_ALLOWANCE",
+  INSUFFICIENT_TOKEN_BALANCE: "INSUFFICIENT_TOKEN_BALANCE",
+  CRYPTO_TRANSFER_FAILED: "CRYPTO_TRANSFER_FAILED",
+  INVALID_WALLET_ADDRESS: "INVALID_WALLET_ADDRESS",
+  UNSUPPORTED_CHAIN: "UNSUPPORTED_CHAIN",
+  UNSUPPORTED_TOKEN: "UNSUPPORTED_TOKEN",
+  UNSUPPORTED_CARD_NETWORK: "UNSUPPORTED_CARD_NETWORK",
+  NETWORK_REGISTRY_ERROR: "NETWORK_REGISTRY_ERROR",
+  INSUFFICIENT_BALANCE: "INSUFFICIENT_BALANCE",
+  AGENT_MODE_MISMATCH: "AGENT_MODE_MISMATCH",
+  THREE_DS_FAILED: "THREE_DS_FAILED",
+  MERCHANT_NOT_FOUND: "MERCHANT_NOT_FOUND",
+  INVALID_MERCHANT_API_KEY: "INVALID_MERCHANT_API_KEY"
+};
+
+// ../shared/dist/errors.js
+var ArisPayError = class extends Error {
+  code;
+  statusCode;
+  constructor(code, message, statusCode = 400) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "ArisPayError";
+  }
+  toJSON() {
+    return {
+      error: {
+        code: this.code,
+        message: this.message
+      }
+    };
+  }
+};
+var SpendLimitExceededError = class extends ArisPayError {
+  constructor(limit, requested) {
+    super("SPEND_LIMIT_EXCEEDED", `Spend limit exceeded: max ${limit} cents per transaction, requested ${requested} cents`, 403);
+    this.name = "SpendLimitExceededError";
+  }
+};
+var InsufficientFundsError = class extends ArisPayError {
+  constructor(message = "Insufficient funds for this transaction") {
+    super("INSUFFICIENT_FUNDS", message, 402);
+    this.name = "InsufficientFundsError";
+  }
+};
+var InsufficientBalanceError = class extends ArisPayError {
+  constructor(available, requested) {
+    super("INSUFFICIENT_BALANCE", `Insufficient agent balance: available ${available} cents, requested ${requested} cents`, 402);
+    this.name = "InsufficientBalanceError";
+  }
+};
+var AgentModeMismatchError = class extends ArisPayError {
+  constructor(expected, actual) {
+    super("AGENT_MODE_MISMATCH", `Agent mode mismatch: expected '${expected}', got '${actual}'`, 400);
+    this.name = "AgentModeMismatchError";
+  }
+};
+
+// src/client.ts
+var SDK_REQUEST_TIMEOUT_MS = 3e4;
+var VALID_ERROR_CODES = new Set(Object.values(ERROR_CODES));
+function toErrorCode(code) {
+  if (typeof code === "string" && VALID_ERROR_CODES.has(code)) {
+    return code;
+  }
+  return "INTERNAL_ERROR";
+}
+var HttpClient = class {
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0,
+      signal: AbortSignal.timeout(SDK_REQUEST_TIMEOUT_MS)
+    });
+    const data = await res.json();
+    if (!res.ok) {
+      const err = data;
+      throw new ArisPayError(
+        toErrorCode(err.error?.code),
+        err.error?.message ?? "Request failed",
+        res.status
+      );
+    }
+    return data;
+  }
+  get(path) {
+    return this.request("GET", path);
+  }
+  post(path, body) {
+    return this.request("POST", path, body);
+  }
+  put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  delete(path) {
+    return this.request("DELETE", path);
+  }
+};
+
+// src/agents.ts
+var AgentService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async register(params) {
+    return this.client.post("/v1/agents", params);
+  }
+  async get(agentId) {
+    return this.client.get(`/v1/agents/${agentId}`);
+  }
+  async list(params) {
+    const query = new URLSearchParams();
+    if (params?.name) query.set("name", params.name);
+    if (params?.status) query.set("status", params.status);
+    if (params?.limit) query.set("limit", String(params.limit));
+    if (params?.offset) query.set("offset", String(params.offset));
+    const qs = query.toString();
+    return this.client.get(`/v1/agents${qs ? `?${qs}` : ""}`);
+  }
+  async listChildren(agentId) {
+    return this.client.get(`/v1/agents/${agentId}/children`);
+  }
+  async resume(agentId) {
+    return this.client.post(`/v1/agents/${agentId}/resume`);
+  }
+  async setCircuitBreaker(agentId, params) {
+    return this.client.put(`/v1/agents/${agentId}/circuit-breaker`, params);
+  }
+  async getCircuitBreaker(agentId) {
+    return this.client.get(`/v1/agents/${agentId}/circuit-breaker`);
+  }
+  async rotateKeys(agentId) {
+    return this.client.post(`/v1/agents/${agentId}/rotate-keys`);
+  }
+  // ── Autonomous Agent Methods ──────────────────────────
+  /**
+   * Get the current balance for an autonomous agent.
+   */
+  async getBalance(agentId) {
+    return this.client.get(`/v1/agents/${agentId}/balance`);
+  }
+  /**
+   * Fund an autonomous agent's balance (topup).
+   */
+  async topup(agentId, params) {
+    return this.client.post(`/v1/agents/${agentId}/topup`, params);
+  }
+  /**
+   * Withdraw from an autonomous agent's balance (sweep).
+   * Omit `amount` to sweep everything above the sweep threshold.
+   */
+  async sweep(agentId, params) {
+    return this.client.post(`/v1/agents/${agentId}/sweep`, params ?? {});
+  }
+  /**
+   * Get paginated ledger history for an autonomous agent.
+   */
+  async getLedger(agentId, params) {
+    const query = new URLSearchParams();
+    if (params?.limit) query.set("limit", String(params.limit));
+    if (params?.offset) query.set("offset", String(params.offset));
+    if (params?.type) query.set("type", params.type);
+    if (params?.from) query.set("from", params.from);
+    if (params?.to) query.set("to", params.to);
+    const qs = query.toString();
+    return this.client.get(`/v1/agents/${agentId}/ledger${qs ? `?${qs}` : ""}`);
+  }
+  /**
+   * Record an earning (inbound money) for an autonomous agent.
+   */
+  async recordEarning(agentId, params) {
+    return this.client.post(`/v1/agents/${agentId}/earn`, params);
+  }
+};
+
+// src/users.ts
+var UserService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(params) {
+    return this.client.post("/v1/users", params);
+  }
+  async get(userId) {
+    return this.client.get(`/v1/users/${userId}`);
+  }
+  async getByExternalId(externalId) {
+    return this.client.get(`/v1/users/by-external/${encodeURIComponent(externalId)}`);
+  }
+  async getWalletStatus(userId) {
+    return this.client.get(`/v1/users/${userId}/wallet-status`);
+  }
+  async addPaymentMethod(params) {
+    const { userId, ...body } = params;
+    return this.client.post(`/v1/users/${userId}/payment-methods`, body);
+  }
+  async completePaymentMethod(params) {
+    const { userId, ...body } = params;
+    return this.client.post(`/v1/users/${userId}/payment-methods/complete`, body);
+  }
+  async setLimits(params) {
+    const { userId, ...body } = params;
+    return this.client.put(`/v1/users/${userId}/limits`, body);
+  }
+};
+
+// src/payments.ts
+var PaymentService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(params) {
+    return this.client.post("/v1/payments", params);
+  }
+  async get(paymentId) {
+    return this.client.get(`/v1/payments/${paymentId}`);
+  }
+  /** Complete a 3D Secure authentication step (method or challenge) */
+  async complete3ds(paymentId, params) {
+    return this.client.post(
+      `/v1/payments/${paymentId}/3ds/complete`,
+      params
+    );
+  }
+};
+
+// src/transactions.ts
+var TransactionService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    const searchParams = new URLSearchParams();
+    if (params?.userId) searchParams.set("userId", params.userId);
+    if (params?.agentId) searchParams.set("agentId", params.agentId);
+    if (params?.from) searchParams.set("from", params.from);
+    if (params?.to) searchParams.set("to", params.to);
+    if (params?.limit) searchParams.set("limit", String(params.limit));
+    if (params?.offset) searchParams.set("offset", String(params.offset));
+    const qs = searchParams.toString();
+    return this.client.get(`/v1/transactions${qs ? `?${qs}` : ""}`);
+  }
+};
+
+// src/webhooks.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var WEBHOOK_TOLERANCE_SECONDS = 300;
+var WebhookService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async register(params) {
+    return this.client.post("/v1/webhooks", params);
+  }
+  async list() {
+    return this.client.get("/v1/webhooks");
+  }
+  async delete(webhookId) {
+    await this.client.delete(`/v1/webhooks/${webhookId}`);
+  }
+  /**
+   * Verify a webhook signature from an incoming request.
+   *
+   * ArisPay signs every webhook delivery with HMAC-SHA256 using the secret
+   * returned when you registered the webhook. The signature is sent in the
+   * `X-ArisPay-Signature` header and the unix timestamp in `X-ArisPay-Timestamp`.
+   *
+   * @param body      - The raw request body string (do NOT parse it first)
+   * @param signature - Value of the `X-ArisPay-Signature` header
+   * @param timestamp - Value of the `X-ArisPay-Timestamp` header
+   * @param secret    - Your webhook secret (`whsec_...`)
+   * @param toleranceSec - Maximum allowed age in seconds (default: 300 = 5 min)
+   * @returns `true` if the signature is valid and the timestamp is within tolerance
+   *
+   * @example
+   * ```ts
+   * import { WebhookService } from 'arispay';
+   *
+   * app.post('/webhooks', (req, res) => {
+   *   const isValid = WebhookService.verifyWebhookSignature(
+   *     req.body,                              // raw body string
+   *     req.headers['x-arispay-signature'],
+   *     req.headers['x-arispay-timestamp'],
+   *     process.env.WEBHOOK_SECRET!,
+   *   );
+   *   if (!isValid) return res.status(401).send('Invalid signature');
+   *   // Process the webhook event...
+   * });
+   * ```
+   */
+  static verifyWebhookSignature(body, signature, timestamp, secret, toleranceSec = WEBHOOK_TOLERANCE_SECONDS) {
+    if (!body || !signature || !timestamp || !secret) return false;
+    const ts = parseInt(timestamp, 10);
+    if (isNaN(ts)) return false;
+    const age = Math.abs(Math.floor(Date.now() / 1e3) - ts);
+    if (age > toleranceSec) return false;
+    const signaturePayload = `${timestamp}.${body}`;
+    const expected = createHmac("sha256", secret).update(signaturePayload).digest("hex");
+    try {
+      return timingSafeEqual(Buffer.from(signature, "hex"), Buffer.from(expected, "hex"));
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/index.ts
+var ArisPay = class {
+  /**
+   * Initialize the ArisPay SDK.
+   *
+   * @example
+   * ```ts
+   * import ArisPay from 'arispay';
+   *
+   * const arispay = ArisPay.init({
+   *   apiKey: 'ap_test_abc123',
+   *   environment: 'sandbox',
+   * });
+   *
+   * const agent = await arispay.agents.register({
+   *   name: 'TableClaw',
+   *   description: 'AI restaurant booking agent',
+   *   permissions: ['browse', 'payment'],
+   * });
+   *
+   * const user = await arispay.users.create({
+   *   externalId: 'user_123',
+   *   email: 'jane@example.com',
+   * });
+   *
+   * const payment = await arispay.payments.create({
+   *   agentId: agent.id,
+   *   userId: user.id,
+   *   amount: 20000,
+   *   currency: 'USD',
+   *   merchantUrl: 'https://nobu.com',
+   *   memo: 'Table for 2',
+   *   idempotencyKey: 'booking_123',
+   * });
+   * ```
+   */
+  static init(config) {
+    const defaultUrl = config.environment === "production" ? "https://api.arispay.app" : "https://api-production-79ea.up.railway.app";
+    const baseUrl = config.baseUrl || defaultUrl;
+    const client = new HttpClient(baseUrl, config.apiKey);
+    return {
+      agents: new AgentService(client),
+      users: new UserService(client),
+      payments: new PaymentService(client),
+      transactions: new TransactionService(client),
+      webhooks: new WebhookService(client)
+    };
+  }
+};
+var index_default = ArisPay;
+export {
+  AgentModeMismatchError,
+  AgentService,
+  ArisPay,
+  ArisPayError,
+  InsufficientBalanceError,
+  InsufficientFundsError,
+  PaymentService,
+  SpendLimitExceededError,
+  TransactionService,
+  UserService,
+  WebhookService,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "arispay",
+  "version": "0.1.0",
+  "description": "SDK and CLI for enabling agent-initiated payments via Visa TAP + Fiserv",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "arispay": "./dist/cli.js",
+    "payagent": "./dist/cli-b.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "build:tsc": "tsc",
+    "dev": "tsc --watch"
+  },
+  "devDependencies": {
+    "@arispay/shared": "workspace:*",
+    "@types/node": "^22.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.7.0"
+  },
+  "keywords": ["ai", "agents", "payments", "visa", "tap", "fiserv", "openclaw", "agentic-commerce"],
+  "license": "MIT"
+}