@conto_finance/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,683 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "@conto_finance/sdk",
+      version: "0.1.0",
+      description: "Conto SDK for AI agent payment authorization",
+      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"
+        }
+      },
+      publishConfig: {
+        access: "public"
+      },
+      engines: {
+        node: ">=18"
+      },
+      files: [
+        "dist"
+      ],
+      scripts: {
+        build: "tsup src/index.ts --format cjs,esm --dts",
+        dev: "tsup src/index.ts --format cjs,esm --dts --watch",
+        lint: "tsc --noEmit",
+        prepublishOnly: "npm run build"
+      },
+      keywords: [
+        "conto",
+        "ai",
+        "agent",
+        "payments",
+        "authorization",
+        "sdk"
+      ],
+      author: "Conto",
+      license: "MIT",
+      repository: {
+        type: "git",
+        url: "https://github.com/conto-finance/conto.git",
+        directory: "packages/sdk"
+      },
+      homepage: "https://conto.finance/docs/sdk",
+      bugs: {
+        url: "https://github.com/conto-finance/conto/issues"
+      },
+      dependencies: {
+        "@sentry/node": "^10.56.0"
+      },
+      overrides: {
+        esbuild: "0.28.1"
+      },
+      devDependencies: {
+        "@types/node": "^22.19.18",
+        tsup: "^8.5.1",
+        typescript: "^5.9.3"
+      }
+    };
+  }
+});
+
+// src/package-version.js
+var require_package_version = __commonJS({
+  "src/package-version.js"(exports, module) {
+    "use strict";
+    var packageJson = require_package();
+    var SDK_PACKAGE_VERSION3 = packageJson.version || "0.0.0";
+    module.exports = {
+      SDK_PACKAGE_VERSION: SDK_PACKAGE_VERSION3
+    };
+  }
+});
+
+// src/index.ts
+var import_package_version2 = __toESM(require_package_version());
+import * as Sentry2 from "@sentry/node";
+
+// src/admin.ts
+var import_package_version = __toESM(require_package_version());
+import * as Sentry from "@sentry/node";
+var ContoAdmin = class {
+  constructor(config) {
+    if (!config.orgApiKey) {
+      throw new Error("Organization API key is required");
+    }
+    if (config.orgApiKey.startsWith("conto_agent_")) {
+      throw new Error(
+        "ContoAdmin requires an organization API key (conto_xxx...), not an agent SDK key (conto_agent_xxx...). Use the Conto class for agent operations."
+      );
+    }
+    if (!config.orgApiKey.startsWith("conto_")) {
+      throw new Error(
+        "Invalid API key format. Expected organization API key starting with conto_xxx..."
+      );
+    }
+    this.orgApiKey = config.orgApiKey;
+    this.baseUrl = (config.baseUrl || "https://conto.finance").replace(/\/$/, "");
+    this.timeout = config.timeout || 3e4;
+    this.agents = new AgentsClient(this);
+    this.wallets = new WalletsClient(this);
+    this.policies = new PoliciesClient(this);
+    this.team = new TeamClient(this);
+  }
+  async fetchWithRetry(url, options, maxRetries = 3) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const response = await fetch(url, options);
+        if (response.status === 429 || response.status >= 500 && attempt < maxRetries) {
+          const retryAfter = response.headers.get("retry-after");
+          const delay = retryAfter ? parseInt(retryAfter, 10) * 1e3 : Math.min(1e3 * 2 ** attempt, 1e4);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+        return response;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < maxRetries) {
+          const delay = Math.min(1e3 * 2 ** attempt, 1e4);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+      }
+    }
+    throw lastError || new Error("Request failed after retries");
+  }
+  /** Make an authenticated request to the Conto API */
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await this.fetchWithRetry(url, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.orgApiKey}`,
+          "Content-Type": "application/json",
+          "User-Agent": `@conto_finance/sdk-admin/${import_package_version.SDK_PACKAGE_VERSION}`
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const data = await response.json();
+      if (!response.ok) {
+        const errorMessage = typeof data.error === "string" ? data.error : "Request failed";
+        const error = new Error(errorMessage);
+        error.code = typeof data.code === "string" ? data.code : "UNKNOWN_ERROR";
+        error.status = response.status;
+        throw error;
+      }
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        const timeoutError = new Error("Request timeout");
+        timeoutError.code = "TIMEOUT";
+        timeoutError.status = 0;
+        Sentry.captureException(timeoutError, { extra: { method, path } });
+        throw timeoutError;
+      }
+      if (error instanceof Error) {
+        Sentry.captureException(error, { extra: { method, path } });
+      }
+      throw error;
+    }
+  }
+};
+var AgentsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List agents in the organization */
+  async list(params) {
+    const query = new URLSearchParams();
+    if (params?.status) query.set("status", params.status);
+    if (params?.search) query.set("search", params.search);
+    if (params?.limit) query.set("limit", String(params.limit));
+    if (params?.offset) query.set("offset", String(params.offset));
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    return this.client.request("GET", `/api/agents${qs}`);
+  }
+  /** Create a new agent */
+  async create(input) {
+    return this.client.request(
+      "POST",
+      "/api/agents",
+      input
+    );
+  }
+  /** Get a single agent by ID */
+  async get(agentId) {
+    return this.client.request("GET", `/api/agents/${agentId}`);
+  }
+  /** Update an agent */
+  async update(agentId, input) {
+    return this.client.request(
+      "PATCH",
+      `/api/agents/${agentId}`,
+      input
+    );
+  }
+  /** Delete an agent (soft delete) */
+  async delete(agentId) {
+    return this.client.request("DELETE", `/api/agents/${agentId}`);
+  }
+  /** Freeze an agent, blocking all transactions */
+  async freeze(agentId, input) {
+    return this.client.request(
+      "POST",
+      `/api/agents/${agentId}/freeze`,
+      input
+    );
+  }
+  /** Unfreeze an agent, restoring transaction ability */
+  async unfreeze(agentId, input) {
+    return this.client.request(
+      "POST",
+      `/api/agents/${agentId}/unfreeze`,
+      input
+    );
+  }
+  /** List wallets linked to an agent */
+  async listWallets(agentId) {
+    return this.client.request(
+      "GET",
+      `/api/agents/${agentId}/wallets`
+    );
+  }
+  /** Link a wallet to an agent with spending limits */
+  async linkWallet(agentId, input) {
+    return this.client.request(
+      "POST",
+      `/api/agents/${agentId}/wallets`,
+      input
+    );
+  }
+  /** Unlink a wallet from an agent */
+  async unlinkWallet(agentId, walletId) {
+    return this.client.request(
+      "DELETE",
+      `/api/agents/${agentId}/wallets/${walletId}`
+    );
+  }
+  /** List policies assigned to an agent */
+  async listPolicies(agentId) {
+    return this.client.request(
+      "GET",
+      `/api/agents/${agentId}/policies`
+    );
+  }
+  /** Assign a policy to an agent */
+  async assignPolicy(agentId, policyId, overrides) {
+    return this.client.request("POST", `/api/agents/${agentId}/policies`, {
+      policyId,
+      ...overrides && { overrides }
+    });
+  }
+  /** Unassign a policy from an agent */
+  async unassignPolicy(agentId, policyId) {
+    return this.client.request(
+      "DELETE",
+      `/api/agents/${agentId}/policies?policyId=${policyId}`
+    );
+  }
+  /** List SDK keys for an agent */
+  async listSdkKeys(agentId) {
+    return this.client.request("GET", `/api/agents/${agentId}/sdk-keys`);
+  }
+  /** Create an SDK key for an agent (key value is returned only once) */
+  async createSdkKey(agentId, input) {
+    return this.client.request(
+      "POST",
+      `/api/agents/${agentId}/sdk-keys`,
+      input
+    );
+  }
+  /** Revoke an SDK key */
+  async revokeSdkKey(agentId, keyId) {
+    return this.client.request(
+      "DELETE",
+      `/api/agents/${agentId}/sdk-keys?keyId=${keyId}`
+    );
+  }
+};
+var WalletsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List wallets in the organization */
+  async list(params) {
+    const query = new URLSearchParams();
+    if (params?.status) query.set("status", params.status);
+    if (params?.chainType) query.set("chainType", params.chainType);
+    if (params?.chainId) query.set("chainId", params.chainId);
+    if (params?.limit) query.set("limit", String(params.limit));
+    if (params?.offset) query.set("offset", String(params.offset));
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    return this.client.request("GET", `/api/wallets${qs}`);
+  }
+  /** Create a new wallet or attach an existing provider/self-custodied wallet */
+  async create(input) {
+    return this.client.request(
+      "POST",
+      "/api/wallets",
+      input
+    );
+  }
+  /** Get a single wallet by ID */
+  async get(walletId) {
+    return this.client.request("GET", `/api/wallets/${walletId}`);
+  }
+  /** Update a wallet */
+  async update(walletId, input) {
+    return this.client.request(
+      "PATCH",
+      `/api/wallets/${walletId}`,
+      input
+    );
+  }
+  /** Delete a wallet (cannot delete if linked to agents) */
+  async delete(walletId) {
+    return this.client.request("DELETE", `/api/wallets/${walletId}`);
+  }
+  /** Provision a wallet for onchain transactions */
+  async provision(walletId) {
+    return this.client.request(
+      "POST",
+      `/api/wallets/${walletId}/provision`,
+      {}
+    );
+  }
+  /** Refresh a wallet's balance from the chain */
+  async refreshBalance(walletId) {
+    return this.client.request(
+      "POST",
+      `/api/wallets/${walletId}/refresh-balance`,
+      {}
+    );
+  }
+};
+var PoliciesClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List policies in the organization */
+  async list(params) {
+    const query = new URLSearchParams();
+    if (params?.limit) query.set("limit", String(params.limit));
+    if (params?.offset) query.set("offset", String(params.offset));
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    return this.client.request("GET", `/api/policies${qs}`);
+  }
+  /** Create a new policy (optionally with rules and agent assignments) */
+  async create(input) {
+    return this.client.request(
+      "POST",
+      "/api/policies",
+      input
+    );
+  }
+  /** Get a single policy by ID */
+  async get(policyId) {
+    return this.client.request("GET", `/api/policies/${policyId}`);
+  }
+  /** Update a policy */
+  async update(policyId, input) {
+    return this.client.request(
+      "PATCH",
+      `/api/policies/${policyId}`,
+      input
+    );
+  }
+  /** Delete a policy */
+  async delete(policyId) {
+    return this.client.request("DELETE", `/api/policies/${policyId}`);
+  }
+  /** List rules for a policy */
+  async listRules(policyId) {
+    return this.client.request("GET", `/api/policies/${policyId}/rules`);
+  }
+  /** Add a single rule to a policy */
+  async addRule(policyId, rule) {
+    return this.client.request(
+      "POST",
+      `/api/policies/${policyId}/rules`,
+      rule
+    );
+  }
+  /** Add multiple rules to a policy */
+  async addRules(policyId, rules) {
+    return this.client.request("POST", `/api/policies/${policyId}/rules`, {
+      rules
+    });
+  }
+  /** Update a single rule */
+  async updateRule(policyId, ruleId, input) {
+    return this.client.request(
+      "PATCH",
+      `/api/policies/${policyId}/rules/${ruleId}`,
+      input
+    );
+  }
+  /** Delete a single rule */
+  async deleteRule(policyId, ruleId) {
+    return this.client.request(
+      "DELETE",
+      `/api/policies/${policyId}/rules/${ruleId}`
+    );
+  }
+  /** Delete all rules for a policy */
+  async deleteAllRules(policyId) {
+    return this.client.request(
+      "DELETE",
+      `/api/policies/${policyId}/rules`
+    );
+  }
+};
+var TeamClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List organization memberships for the authenticated organization */
+  async listMembers() {
+    return this.client.request(
+      "GET",
+      "/api/organizations/me/members"
+    );
+  }
+};
+
+// src/index.ts
+if (process.env.SENTRY_DSN) {
+  Sentry2.init({
+    dsn: process.env.SENTRY_DSN,
+    environment: process.env.NODE_ENV || "production",
+    tracesSampleRate: 0.05,
+    enableLogs: true
+  });
+}
+var Conto = class {
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("API key is required");
+    }
+    if (!config.apiKey.startsWith("conto_agent_")) {
+      throw new Error("Invalid API key format. Expected conto_agent_xxx...");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl || "https://conto.finance").replace(/\/$/, "");
+    this.timeout = config.timeout || 3e4;
+    this.payments = new PaymentsClient(this);
+  }
+  async fetchWithRetry(url, options, maxRetries = 3) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const response = await fetch(url, options);
+        if (response.status === 429 || response.status >= 500 && attempt < maxRetries) {
+          const retryAfter = response.headers.get("retry-after");
+          const delay = retryAfter ? parseInt(retryAfter, 10) * 1e3 : Math.min(1e3 * 2 ** attempt, 1e4);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+        return response;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < maxRetries) {
+          const delay = Math.min(1e3 * 2 ** attempt, 1e4);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+      }
+    }
+    throw lastError || new Error("Request failed after retries");
+  }
+  /** Make an authenticated request to the Giro API */
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await this.fetchWithRetry(url, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json",
+          "User-Agent": `@conto_finance/sdk/${import_package_version2.SDK_PACKAGE_VERSION}`
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const data = await response.json();
+      if (!response.ok) {
+        const errorMessage = typeof data.error === "string" ? data.error : "Request failed";
+        const error = new Error(errorMessage);
+        error.code = typeof data.code === "string" ? data.code : "UNKNOWN_ERROR";
+        error.status = response.status;
+        throw error;
+      }
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        const timeoutError = new Error("Request timeout");
+        timeoutError.code = "TIMEOUT";
+        timeoutError.status = 0;
+        Sentry2.captureException(timeoutError, { extra: { method, path } });
+        throw timeoutError;
+      }
+      if (error instanceof Error) {
+        Sentry2.captureException(error, { extra: { method, path } });
+      }
+      throw error;
+    }
+  }
+};
+var PaymentsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Request authorization for a payment.
+   *
+   * This evaluates spending policies and returns whether the payment
+   * is approved, denied, or requires manual approval.
+   *
+   * @example
+   * ```typescript
+   * const request = await conto.payments.request({
+   *   amount: 25.00,
+   *   recipientAddress: '0x742d35Cc6634C0532925a3b844Bc9e7595f...',
+   *   recipientName: 'OpenAI',
+   *   purpose: 'GPT-4 API credits',
+   *   category: 'API_PROVIDER'
+   * });
+   *
+   * if (request.status === 'APPROVED') {
+   *   // Payment is pre-authorized, execute it
+   *   const result = await conto.payments.execute(request.requestId);
+   * } else if (request.status === 'REQUIRES_APPROVAL') {
+   *   // Wait for human approval
+   *   console.log('Payment requires manual approval');
+   * } else {
+   *   // Payment was denied
+   *   console.log('Denied:', request.reasons.join(', '));
+   * }
+   * ```
+   */
+  async request(input) {
+    return this.client.request(
+      "POST",
+      "/api/sdk/payments/request",
+      input
+    );
+  }
+  /**
+   * Execute an approved payment.
+   *
+   * This sends the onchain transaction. Only works for payments
+   * with status 'APPROVED'.
+   *
+   * @param requestId - The requestId from a successful payment request
+   *
+   * @example
+   * ```typescript
+   * const result = await conto.payments.execute(request.requestId);
+   * console.log(`Transaction: ${result.txHash}`);
+   * console.log(`Explorer: ${result.explorerUrl}`);
+   * ```
+   */
+  async execute(requestId) {
+    return this.client.request(
+      "POST",
+      `/api/sdk/payments/${requestId}/execute`,
+      {}
+    );
+  }
+  /**
+   * Get the status of a payment request.
+   *
+   * @param requestId - The requestId to check
+   *
+   * @example
+   * ```typescript
+   * const status = await conto.payments.status(requestId);
+   * if (status.transaction?.status === 'CONFIRMED') {
+   *   console.log('Payment confirmed at block', status.transaction.blockNumber);
+   * }
+   * ```
+   */
+  async status(requestId) {
+    return this.client.request(
+      "GET",
+      `/api/sdk/payments/${requestId}`,
+      void 0
+    );
+  }
+  /**
+   * Request and execute a payment in one call.
+   *
+   * Convenience method that requests authorization and immediately
+   * executes if approved. Throws if denied or requires approval.
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   const result = await conto.payments.pay({
+   *     amount: 10.00,
+   *     recipientAddress: '0x...',
+   *     purpose: 'Service fee'
+   *   });
+   *   console.log(`Paid! TX: ${result.txHash}`);
+   * } catch (error) {
+   *   if (error.code === 'REQUIRES_APPROVAL') {
+   *     console.log('Payment needs human approval');
+   *   } else {
+   *     console.log('Payment denied:', error.message);
+   *   }
+   * }
+   * ```
+   */
+  async pay(input) {
+    const { autoExecute: _autoExecute, ...requestInput } = input;
+    const request = await this.request(requestInput);
+    if (request.status === "DENIED") {
+      const error = new Error(`Payment denied: ${request.reasons.join(", ")}`);
+      error.code = "PAYMENT_DENIED";
+      error.status = 403;
+      throw error;
+    }
+    if (request.status === "REQUIRES_APPROVAL") {
+      const error = new Error("Payment requires manual approval");
+      error.code = "REQUIRES_APPROVAL";
+      error.status = 202;
+      throw error;
+    }
+    return this.execute(request.requestId);
+  }
+};
+var index_default = Conto;
+export {
+  Conto,
+  ContoAdmin,
+  Conto as Giro,
+  index_default as default
+};