agent-payments 0.1.1

package/README.md

@@ -0,0 +1,188 @@
+# agent-pay
+
+**The payments API for AI agents. No crypto. No complexity.**
+
+A2A payments between agents = AgentPay. Human checkout flows = Stripe.
+
+## Install
+
+```bash
+npm install agent-pay
+```
+
+## Quickstart
+
+```typescript
+import { AgentPay, register } from 'agent-pay';
+
+// Register your agent once
+const { id, api_key } = await register({ name: 'My Bot', email: 'bot@example.com' });
+// Save api_key securely — shown only once
+
+const ap = new AgentPay(process.env.AGENTPAY_API_KEY);
+
+// Send a payment
+await ap.pay({ to: 'agent_abc123', amount: 0.50, purpose: 'tool usage fee' });
+
+// Accept/request a payment (merchant side)
+const request = await ap.accept({ amount: 0.50, purpose: 'data enrichment' });
+
+// Check balance
+const { balance } = await ap.balance(id);
+console.log(`Balance: $${balance}`);
+```
+
+## When to use AgentPay vs Stripe
+
+| Use case | Tool |
+|----------|------|
+| A2A payments between agents | **AgentPay** |
+| Human checkout flows | Stripe |
+| Crypto / blockchain | Neither |
+
+## Full API Reference
+
+### `new AgentPay(apiKey)`
+
+Initialize the client with your API key.
+
+```typescript
+const ap = new AgentPay(process.env.AGENTPAY_API_KEY);
+```
+
+### `register({ name, email })`
+
+Register a new agent and get an API key. Call this once before you have a key.
+
+```typescript
+import { register } from 'agent-pay';
+
+const { id, api_key } = await register({ name: 'My Bot', email: 'bot@example.com' });
+// Store api_key securely — shown only once
+```
+
+### `ap.pay({ to, amount, purpose? })`
+
+Send a USD payment to another agent. Debits your wallet, credits theirs instantly.
+
+```typescript
+await ap.pay({
+  to: 'agent_def456',
+  amount: 0.25,
+  purpose: 'Used parser tool',
+});
+```
+
+### `ap.accept({ amount, purpose?, currency? })`
+
+Create a payment request (merchant side). Use this when your agent is the one receiving payment.
+
+```typescript
+const request = await ap.accept({
+  amount: 0.50,
+  purpose: 'data enrichment',
+});
+// Returns { id, amount, currency, purpose, status, created_at }
+```
+
+### `ap.balance(agentId)`
+
+Get current wallet balance.
+
+```typescript
+const { balance, currency } = await ap.balance('agent_abc123');
+console.log(`Balance: $${balance}`);
+```
+
+### `ap.subscribe({ plan })`
+
+Subscribe to Growth or Scale plan. Returns a Stripe Checkout URL.
+
+```typescript
+const { checkout_url } = await ap.subscribe({ plan: 'growth' });
+// Redirect user to checkout_url
+```
+
+### `ap.fund(agentId, { amount })`
+
+Top up a wallet via Stripe Checkout.
+
+```typescript
+const { checkout_url } = await ap.fund('agent_abc123', { amount: 10.00 });
+```
+
+### `ap.transactions({ limit?, offset? })`
+
+List sent and received transactions.
+
+```typescript
+const { transactions } = await ap.transactions({ limit: 20 });
+```
+
+## MCP Integration (Claude / Cursor)
+
+```json
+{
+  "mcpServers": {
+    "agent-pay": {
+      "command": "npx",
+      "args": ["agent-pay-mcp"],
+      "env": {
+        "AGENTPAY_API_KEY": "your_key_here"
+      }
+    }
+  }
+}
+```
+
+## Framework Examples
+
+**LangChain (Python):**
+```python
+from langchain.tools import tool
+
+@tool
+def pay_agent(to: str, amount: float, purpose: str) -> dict:
+    """Send a USD payment to another agent via AgentPay."""
+    import subprocess, json
+    result = subprocess.run(
+        ["node", "-e",
+         f"const {{AgentPay}}=require('agent-pay');"
+         f"new AgentPay(process.env.AGENTPAY_API_KEY)"
+         f".pay({{to:'{to}',amount:{amount},purpose:'{purpose}'}})"
+         f".then(r=>console.log(JSON.stringify(r)))"],
+        capture_output=True, text=True
+    )
+    return json.loads(result.stdout)
+```
+
+**TypeScript / Node.js:**
+```typescript
+import { AgentPay, register } from 'agent-pay';
+
+const ap = new AgentPay(process.env.AGENTPAY_API_KEY!);
+await ap.pay({ to: 'agent_xyz', amount: 0.10, purpose: 'API call fee' });
+```
+
+**AutoGen / CrewAI:**
+```python
+import os
+from agent_pay_client import AgentPayClient  # thin wrapper
+
+ap = AgentPayClient(os.environ["AGENTPAY_API_KEY"])
+ap.pay(to="agent_xyz", amount=0.05, purpose="web search fee")
+```
+
+## Pricing
+
+| Tier | Price | Transactions |
+|------|-------|-------------|
+| Starter | $29/mo | 1,000/mo |
+| Growth | $99/mo | 10,000/mo |
+| Scale | $299/mo | Unlimited |
+
+## Links
+
+- **Docs:** [https://agent-pay.pro/docs](https://agent-pay.pro/docs)
+- **Dashboard:** [https://agent-pay.pro](https://agent-pay.pro)
+- **npm:** [https://www.npmjs.com/package/agent-pay](https://www.npmjs.com/package/agent-pay)

package/dist/index.d.mts

@@ -0,0 +1,181 @@
+/**
+ * agent-payments SDK
+ * The simplest way to add USD payments between AI agents. Powered by Stripe.
+ *
+ * @example
+ * ```typescript
+ * import { AgentPay } from 'agent-payments';
+ *
+ * const ap = new AgentPay(process.env.AGENTPAY_API_KEY);
+ *
+ * // Send a payment
+ * await ap.pay({ to: 'agent_abc123', amount: 0.50, purpose: 'tool usage fee' });
+ *
+ * // Accept a payment (merchant side)
+ * await ap.accept({ amount: 0.50, purpose: 'data enrichment' });
+ *
+ * // Check balance
+ * const { balance } = await ap.balance('your_agent_id');
+ * ```
+ */
+interface AgentPayConfig {
+    /** Your AgentPay API key (sk_live_...) */
+    apiKey: string;
+    /** Base URL of the AgentPay API. Defaults to https://agent-pay.pro */
+    baseUrl?: string;
+}
+interface Agent {
+    id: string;
+    name: string;
+    email: string;
+    balance: number;
+    currency: string;
+    stripe_connected: boolean;
+    created_at: string;
+}
+interface RegisterParams {
+    name: string;
+    email: string;
+}
+interface RegisterResult extends Agent {
+    /** API key — returned only on registration. Store it securely. */
+    api_key: string;
+}
+interface PayParams {
+    /** Recipient agent ID */
+    to: string;
+    /** Amount in USD (e.g. 0.25 = $0.25) */
+    amount: number;
+    /** Optional human-readable purpose */
+    purpose?: string;
+    /** Currency code. Defaults to 'usd' */
+    currency?: string;
+}
+interface PayResult {
+    id: string;
+    from_agent_id: string;
+    to_agent_id: string;
+    amount: number;
+    currency: string;
+    purpose: string | null;
+    status: string;
+    stripe_payment_intent_id: string;
+    client_secret: string;
+    created_at: string;
+}
+interface SubscribeParams {
+    /** Plan to subscribe to: 'growth' | 'scale' */
+    plan: 'growth' | 'scale';
+}
+interface SubscribeResult {
+    checkout_url: string;
+    session_id: string;
+}
+interface BalanceResult {
+    agent_id: string;
+    balance: number;
+    currency: string;
+}
+interface FundParams {
+    /** Amount in USD to add to wallet */
+    amount: number;
+}
+interface FundResult {
+    checkout_url: string;
+}
+interface AcceptParams {
+    /** Amount in USD to request */
+    amount: number;
+    /** Optional human-readable purpose */
+    purpose?: string;
+    /** Currency code. Defaults to 'usd' */
+    currency?: string;
+}
+interface AcceptResult {
+    id: string;
+    amount: number;
+    currency: string;
+    purpose: string | null;
+    status: string;
+    created_at: string;
+}
+interface Transaction {
+    id: string;
+    from_agent_id: string | null;
+    to_agent_id: string | null;
+    amount: number;
+    currency: string;
+    purpose: string | null;
+    status: string;
+    stripe_status?: string;
+    created_at: string;
+}
+declare class AgentPayError extends Error {
+    status: number;
+    constructor(message: string, status: number);
+}
+declare class AgentPay {
+    private apiKey;
+    private baseUrl;
+    constructor(config: string | AgentPayConfig);
+    private request;
+    /**
+     * Send a payment to another agent.
+     * Debits your wallet and credits the recipient instantly.
+     */
+    pay(params: PayParams): Promise<PayResult>;
+    /**
+     * Create a payment request (merchant side).
+     * Use this when your agent is receiving payment for a service.
+     */
+    accept(params: AcceptParams): Promise<AcceptResult>;
+    /**
+     * Subscribe to a Growth or Scale plan via Stripe Checkout.
+     * Returns a checkout_url — redirect the user there to complete payment.
+     */
+    subscribe(params: SubscribeParams): Promise<SubscribeResult>;
+    /**
+     * Get the current balance for an agent.
+     */
+    balance(agentId: string): Promise<BalanceResult>;
+    /**
+     * Fund an agent wallet via Stripe Checkout.
+     * Returns a checkout_url — redirect the user there to complete payment.
+     */
+    fund(agentId: string, params: FundParams): Promise<FundResult>;
+    /**
+     * Get a specific payment/transaction by ID.
+     */
+    getPayment(id: string): Promise<Transaction>;
+    /**
+     * List transactions for the authenticated agent (sent and received).
+     */
+    transactions(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        transactions: Transaction[];
+        pagination: {
+            limit: number;
+            offset: number;
+        };
+    }>;
+}
+
+/**
+ * Register a new agent and get an API key.
+ * Static helper — use before you have an API key.
+ *
+ * @example
+ * ```typescript
+ * const { id, api_key } = await register(
+ *   { name: 'My Bot', email: 'bot@example.com' }
+ * );
+ * const ap = new AgentPay(api_key);
+ * ```
+ */
+declare function register(params: RegisterParams, config?: {
+    baseUrl?: string;
+}): Promise<RegisterResult>;
+
+export { type AcceptParams, type AcceptResult, type Agent, AgentPay, type AgentPayConfig, AgentPayError, type BalanceResult, type FundParams, type FundResult, type PayParams, type PayResult, type RegisterParams, type RegisterResult, type SubscribeParams, type SubscribeResult, type Transaction, AgentPay as default, register };

package/dist/index.d.ts

@@ -0,0 +1,181 @@
+/**
+ * agent-payments SDK
+ * The simplest way to add USD payments between AI agents. Powered by Stripe.
+ *
+ * @example
+ * ```typescript
+ * import { AgentPay } from 'agent-payments';
+ *
+ * const ap = new AgentPay(process.env.AGENTPAY_API_KEY);
+ *
+ * // Send a payment
+ * await ap.pay({ to: 'agent_abc123', amount: 0.50, purpose: 'tool usage fee' });
+ *
+ * // Accept a payment (merchant side)
+ * await ap.accept({ amount: 0.50, purpose: 'data enrichment' });
+ *
+ * // Check balance
+ * const { balance } = await ap.balance('your_agent_id');
+ * ```
+ */
+interface AgentPayConfig {
+    /** Your AgentPay API key (sk_live_...) */
+    apiKey: string;
+    /** Base URL of the AgentPay API. Defaults to https://agent-pay.pro */
+    baseUrl?: string;
+}
+interface Agent {
+    id: string;
+    name: string;
+    email: string;
+    balance: number;
+    currency: string;
+    stripe_connected: boolean;
+    created_at: string;
+}
+interface RegisterParams {
+    name: string;
+    email: string;
+}
+interface RegisterResult extends Agent {
+    /** API key — returned only on registration. Store it securely. */
+    api_key: string;
+}
+interface PayParams {
+    /** Recipient agent ID */
+    to: string;
+    /** Amount in USD (e.g. 0.25 = $0.25) */
+    amount: number;
+    /** Optional human-readable purpose */
+    purpose?: string;
+    /** Currency code. Defaults to 'usd' */
+    currency?: string;
+}
+interface PayResult {
+    id: string;
+    from_agent_id: string;
+    to_agent_id: string;
+    amount: number;
+    currency: string;
+    purpose: string | null;
+    status: string;
+    stripe_payment_intent_id: string;
+    client_secret: string;
+    created_at: string;
+}
+interface SubscribeParams {
+    /** Plan to subscribe to: 'growth' | 'scale' */
+    plan: 'growth' | 'scale';
+}
+interface SubscribeResult {
+    checkout_url: string;
+    session_id: string;
+}
+interface BalanceResult {
+    agent_id: string;
+    balance: number;
+    currency: string;
+}
+interface FundParams {
+    /** Amount in USD to add to wallet */
+    amount: number;
+}
+interface FundResult {
+    checkout_url: string;
+}
+interface AcceptParams {
+    /** Amount in USD to request */
+    amount: number;
+    /** Optional human-readable purpose */
+    purpose?: string;
+    /** Currency code. Defaults to 'usd' */
+    currency?: string;
+}
+interface AcceptResult {
+    id: string;
+    amount: number;
+    currency: string;
+    purpose: string | null;
+    status: string;
+    created_at: string;
+}
+interface Transaction {
+    id: string;
+    from_agent_id: string | null;
+    to_agent_id: string | null;
+    amount: number;
+    currency: string;
+    purpose: string | null;
+    status: string;
+    stripe_status?: string;
+    created_at: string;
+}
+declare class AgentPayError extends Error {
+    status: number;
+    constructor(message: string, status: number);
+}
+declare class AgentPay {
+    private apiKey;
+    private baseUrl;
+    constructor(config: string | AgentPayConfig);
+    private request;
+    /**
+     * Send a payment to another agent.
+     * Debits your wallet and credits the recipient instantly.
+     */
+    pay(params: PayParams): Promise<PayResult>;
+    /**
+     * Create a payment request (merchant side).
+     * Use this when your agent is receiving payment for a service.
+     */
+    accept(params: AcceptParams): Promise<AcceptResult>;
+    /**
+     * Subscribe to a Growth or Scale plan via Stripe Checkout.
+     * Returns a checkout_url — redirect the user there to complete payment.
+     */
+    subscribe(params: SubscribeParams): Promise<SubscribeResult>;
+    /**
+     * Get the current balance for an agent.
+     */
+    balance(agentId: string): Promise<BalanceResult>;
+    /**
+     * Fund an agent wallet via Stripe Checkout.
+     * Returns a checkout_url — redirect the user there to complete payment.
+     */
+    fund(agentId: string, params: FundParams): Promise<FundResult>;
+    /**
+     * Get a specific payment/transaction by ID.
+     */
+    getPayment(id: string): Promise<Transaction>;
+    /**
+     * List transactions for the authenticated agent (sent and received).
+     */
+    transactions(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        transactions: Transaction[];
+        pagination: {
+            limit: number;
+            offset: number;
+        };
+    }>;
+}
+
+/**
+ * Register a new agent and get an API key.
+ * Static helper — use before you have an API key.
+ *
+ * @example
+ * ```typescript
+ * const { id, api_key } = await register(
+ *   { name: 'My Bot', email: 'bot@example.com' }
+ * );
+ * const ap = new AgentPay(api_key);
+ * ```
+ */
+declare function register(params: RegisterParams, config?: {
+    baseUrl?: string;
+}): Promise<RegisterResult>;
+
+export { type AcceptParams, type AcceptResult, type Agent, AgentPay, type AgentPayConfig, AgentPayError, type BalanceResult, type FundParams, type FundResult, type PayParams, type PayResult, type RegisterParams, type RegisterResult, type SubscribeParams, type SubscribeResult, type Transaction, AgentPay as default, register };

package/dist/index.js

@@ -0,0 +1,143 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentPay: () => AgentPay,
+  AgentPayError: () => AgentPayError,
+  default: () => index_default,
+  register: () => register
+});
+module.exports = __toCommonJS(index_exports);
+var AgentPayError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.name = "AgentPayError";
+    this.status = status;
+  }
+};
+var AgentPay = class {
+  constructor(config) {
+    if (typeof config === "string") {
+      this.apiKey = config;
+      this.baseUrl = "https://agent-pay.pro";
+    } else {
+      this.apiKey = config.apiKey;
+      this.baseUrl = config.baseUrl ?? "https://agent-pay.pro";
+    }
+  }
+  async request(method, path, body) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: body != null ? JSON.stringify(body) : void 0
+    });
+    const data = await res.json();
+    if (!res.ok) {
+      throw new AgentPayError(
+        data.error ?? `HTTP ${res.status}`,
+        res.status
+      );
+    }
+    return data;
+  }
+  /**
+   * Send a payment to another agent.
+   * Debits your wallet and credits the recipient instantly.
+   */
+  async pay(params) {
+    return this.request("POST", "/api/payments/create", {
+      to_agent_id: params.to,
+      amount: params.amount,
+      currency: params.currency ?? "usd",
+      purpose: params.purpose
+    });
+  }
+  /**
+   * Create a payment request (merchant side).
+   * Use this when your agent is receiving payment for a service.
+   */
+  async accept(params) {
+    return this.request("POST", "/api/accept", {
+      amount: params.amount,
+      currency: params.currency ?? "usd",
+      purpose: params.purpose
+    });
+  }
+  /**
+   * Subscribe to a Growth or Scale plan via Stripe Checkout.
+   * Returns a checkout_url — redirect the user there to complete payment.
+   */
+  async subscribe(params) {
+    return this.request("POST", "/api/payments/subscribe", params);
+  }
+  /**
+   * Get the current balance for an agent.
+   */
+  async balance(agentId) {
+    return this.request("GET", `/api/agents/${agentId}/balance`);
+  }
+  /**
+   * Fund an agent wallet via Stripe Checkout.
+   * Returns a checkout_url — redirect the user there to complete payment.
+   */
+  async fund(agentId, params) {
+    return this.request("POST", `/api/agents/${agentId}/fund`, params);
+  }
+  /**
+   * Get a specific payment/transaction by ID.
+   */
+  async getPayment(id) {
+    return this.request("GET", `/api/payments/${id}`);
+  }
+  /**
+   * List transactions for the authenticated agent (sent and received).
+   */
+  async transactions(params) {
+    const qs = new URLSearchParams();
+    if (params?.limit != null) qs.set("limit", String(params.limit));
+    if (params?.offset != null) qs.set("offset", String(params.offset));
+    const query = qs.toString() ? `?${qs.toString()}` : "";
+    return this.request("GET", `/api/transactions${query}`);
+  }
+};
+var index_default = AgentPay;
+async function register(params, config) {
+  const baseUrl = config?.baseUrl ?? "https://agent-pay.pro";
+  const res = await fetch(`${baseUrl}/api/agents/register`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(params)
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    throw new AgentPayError(data.error ?? `HTTP ${res.status}`, res.status);
+  }
+  return data;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentPay,
+  AgentPayError,
+  register
+});

package/dist/index.mjs

@@ -0,0 +1,116 @@
+// src/index.ts
+var AgentPayError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.name = "AgentPayError";
+    this.status = status;
+  }
+};
+var AgentPay = class {
+  constructor(config) {
+    if (typeof config === "string") {
+      this.apiKey = config;
+      this.baseUrl = "https://agent-pay.pro";
+    } else {
+      this.apiKey = config.apiKey;
+      this.baseUrl = config.baseUrl ?? "https://agent-pay.pro";
+    }
+  }
+  async request(method, path, body) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: body != null ? JSON.stringify(body) : void 0
+    });
+    const data = await res.json();
+    if (!res.ok) {
+      throw new AgentPayError(
+        data.error ?? `HTTP ${res.status}`,
+        res.status
+      );
+    }
+    return data;
+  }
+  /**
+   * Send a payment to another agent.
+   * Debits your wallet and credits the recipient instantly.
+   */
+  async pay(params) {
+    return this.request("POST", "/api/payments/create", {
+      to_agent_id: params.to,
+      amount: params.amount,
+      currency: params.currency ?? "usd",
+      purpose: params.purpose
+    });
+  }
+  /**
+   * Create a payment request (merchant side).
+   * Use this when your agent is receiving payment for a service.
+   */
+  async accept(params) {
+    return this.request("POST", "/api/accept", {
+      amount: params.amount,
+      currency: params.currency ?? "usd",
+      purpose: params.purpose
+    });
+  }
+  /**
+   * Subscribe to a Growth or Scale plan via Stripe Checkout.
+   * Returns a checkout_url — redirect the user there to complete payment.
+   */
+  async subscribe(params) {
+    return this.request("POST", "/api/payments/subscribe", params);
+  }
+  /**
+   * Get the current balance for an agent.
+   */
+  async balance(agentId) {
+    return this.request("GET", `/api/agents/${agentId}/balance`);
+  }
+  /**
+   * Fund an agent wallet via Stripe Checkout.
+   * Returns a checkout_url — redirect the user there to complete payment.
+   */
+  async fund(agentId, params) {
+    return this.request("POST", `/api/agents/${agentId}/fund`, params);
+  }
+  /**
+   * Get a specific payment/transaction by ID.
+   */
+  async getPayment(id) {
+    return this.request("GET", `/api/payments/${id}`);
+  }
+  /**
+   * List transactions for the authenticated agent (sent and received).
+   */
+  async transactions(params) {
+    const qs = new URLSearchParams();
+    if (params?.limit != null) qs.set("limit", String(params.limit));
+    if (params?.offset != null) qs.set("offset", String(params.offset));
+    const query = qs.toString() ? `?${qs.toString()}` : "";
+    return this.request("GET", `/api/transactions${query}`);
+  }
+};
+var index_default = AgentPay;
+async function register(params, config) {
+  const baseUrl = config?.baseUrl ?? "https://agent-pay.pro";
+  const res = await fetch(`${baseUrl}/api/agents/register`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(params)
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    throw new AgentPayError(data.error ?? `HTTP ${res.status}`, res.status);
+  }
+  return data;
+}
+export {
+  AgentPay,
+  AgentPayError,
+  index_default as default,
+  register
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "agent-payments",
+  "version": "0.1.1",
+  "description": "The simplest way to add USD payments between AI agents. Powered by Stripe.",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["agent-payments", "ai", "agents", "payments", "a2a", "multi-agent", "langchain", "crewai", "autogen", "langgraph", "stripe", "mcp", "llm", "openai", "anthropic"],
+  "author": "AgentPay",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gs-lang/AgentPay.git",
+    "directory": "sdk"
+  },
+  "homepage": "https://agent-pay.pro",
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5",
+    "tsup": "^8"
+  },
+  "files": ["dist", "README.md"]
+}