@dtelecom/x402-client 0.1.0

package/dist/index.js

@@ -0,0 +1,403 @@
+"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, {
+  ConcurrencyLimitError: () => ConcurrencyLimitError,
+  DtelecomGateway: () => DtelecomGateway,
+  GatewayError: () => GatewayError,
+  InsufficientCreditsError: () => InsufficientCreditsError,
+  NoCapacityError: () => NoCapacityError,
+  PaymentError: () => PaymentError,
+  RateLimitError: () => RateLimitError,
+  createAuthHeaders: () => createAuthHeaders
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_viem = require("viem");
+var import_chains = require("viem/chains");
+var import_fetch = require("@x402/fetch");
+var import_client = require("@x402/evm/exact/client");
+var import_evm = require("@x402/evm");
+
+// src/auth.ts
+async function createAuthHeaders(account, method, path) {
+  const timestamp = Math.floor(Date.now() / 1e3).toString();
+  const pathname = path.split("?")[0];
+  const message = `${method}
+${pathname}
+${timestamp}`;
+  const signature = await account.signMessage({ message });
+  return {
+    Authorization: `evm:${signature}`,
+    "X-Wallet-Address": account.address,
+    "X-Wallet-Chain": "evm",
+    "X-Timestamp": timestamp
+  };
+}
+
+// src/errors.ts
+var GatewayError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "GatewayError";
+    this.status = status;
+  }
+};
+var InsufficientCreditsError = class extends GatewayError {
+  constructor(message) {
+    super(message, 402);
+    this.name = "InsufficientCreditsError";
+  }
+};
+var ConcurrencyLimitError = class extends GatewayError {
+  constructor(message) {
+    super(message, 429);
+    this.name = "ConcurrencyLimitError";
+  }
+};
+var RateLimitError = class extends GatewayError {
+  constructor(message) {
+    super(message, 429);
+    this.name = "RateLimitError";
+  }
+};
+var NoCapacityError = class extends GatewayError {
+  service;
+  constructor(message, service) {
+    super(message, 503);
+    this.name = "NoCapacityError";
+    this.service = service;
+  }
+};
+var PaymentError = class extends GatewayError {
+  constructor(message) {
+    super(message, 402);
+    this.name = "PaymentError";
+  }
+};
+
+// src/client.ts
+var DtelecomGateway = class {
+  baseUrl;
+  account;
+  fetchWithPayment;
+  constructor(config) {
+    this.baseUrl = config.gatewayUrl.replace(/\/+$/, "");
+    this.account = config.account;
+    const publicClient = (0, import_viem.createPublicClient)({ chain: import_chains.base, transport: (0, import_viem.http)() });
+    const signer = (0, import_evm.toClientEvmSigner)(config.account, publicClient);
+    const x402 = new import_fetch.x402Client();
+    (0, import_client.registerExactEvmScheme)(x402, { signer });
+    this.fetchWithPayment = (0, import_fetch.wrapFetchWithPayment)(fetch, x402);
+  }
+  // --- Credits ---
+  async buyCredits(options) {
+    const r = await this.requestWithPayment("/v1/credits/purchase", {
+      wallet_address: this.account.address,
+      wallet_chain: "evm",
+      amount_usd: options.amountUsd
+    });
+    return {
+      accountId: r.account_id,
+      creditedMicrocredits: r.credited_microcredits,
+      amountUsd: r.amount_usd
+    };
+  }
+  // --- Account ---
+  async getAccount() {
+    const r = await this.request("GET", "/v1/account");
+    return {
+      id: r.id,
+      walletAddress: r.wallet_address,
+      walletChain: r.wallet_chain,
+      creditBalance: r.credit_balance,
+      availableBalance: r.available_balance,
+      maxConcurrentSessions: r.max_concurrent_sessions,
+      maxApiRate: r.max_api_rate,
+      createdAt: r.created_at
+    };
+  }
+  async getTransactions(options) {
+    const params = new URLSearchParams();
+    if (options?.limit !== void 0) params.set("limit", String(options.limit));
+    if (options?.offset !== void 0)
+      params.set("offset", String(options.offset));
+    const qs = params.toString();
+    const r = await this.request(
+      "GET",
+      `/v1/account/transactions${qs ? `?${qs}` : ""}`
+    );
+    return {
+      transactions: r.transactions.map(mapTransaction),
+      limit: r.limit,
+      offset: r.offset
+    };
+  }
+  async getSessions(options) {
+    const params = new URLSearchParams();
+    if (options?.limit !== void 0) params.set("limit", String(options.limit));
+    if (options?.offset !== void 0)
+      params.set("offset", String(options.offset));
+    if (options?.status) params.set("status", options.status);
+    const qs = params.toString();
+    const r = await this.request(
+      "GET",
+      `/v1/account/sessions${qs ? `?${qs}` : ""}`
+    );
+    return {
+      sessions: r.sessions.map(mapSession),
+      limit: r.limit,
+      offset: r.offset
+    };
+  }
+  // --- Bundled Agent Session ---
+  async createAgentSession(options) {
+    const r = await this.request("POST", "/v1/agent-session", {
+      room_name: options.roomName,
+      participant_identity: options.participantIdentity,
+      duration_minutes: options.durationMinutes,
+      language: options.language,
+      tts_max_characters: options.ttsMaxCharacters,
+      metadata: options.metadata
+    });
+    return {
+      bundleId: r.bundle_id,
+      webrtc: {
+        sessionId: r.webrtc.session_id,
+        token: r.webrtc.token,
+        wsUrl: r.webrtc.ws_url
+      },
+      stt: {
+        sessionId: r.stt.session_id,
+        token: r.stt.token,
+        serverUrl: r.stt.server_url
+      },
+      tts: {
+        sessionId: r.tts.session_id,
+        token: r.tts.token,
+        serverUrl: r.tts.server_url
+      },
+      expiresAt: r.expires_at
+    };
+  }
+  async extendAgentSession(options) {
+    const r = await this.request("POST", "/v1/agent-session/extend", {
+      bundle_id: options.bundleId,
+      additional_minutes: options.additionalMinutes,
+      additional_tts_characters: options.additionalTtsCharacters
+    });
+    const result = {};
+    if (r.webrtc) {
+      result.webrtc = {
+        token: r.webrtc.token,
+        newExpiresAt: r.webrtc.new_expires_at
+      };
+    }
+    if (r.stt) {
+      result.stt = {
+        token: r.stt.token,
+        newExpiresAt: r.stt.new_expires_at
+      };
+    }
+    if (r.tts) {
+      result.tts = {
+        token: r.tts.token,
+        newExpiresAt: r.tts.new_expires_at
+      };
+    }
+    return result;
+  }
+  // --- Standalone WebRTC ---
+  async createWebRTCToken(options) {
+    const r = await this.request("POST", "/v1/webrtc/token", {
+      room_name: options.roomName,
+      participant_identity: options.participantIdentity,
+      duration_minutes: options.durationMinutes,
+      metadata: options.metadata
+    });
+    return {
+      sessionId: r.session_id,
+      token: r.token,
+      wsUrl: r.ws_url,
+      expiresAt: r.expires_at
+    };
+  }
+  async extendWebRTCToken(options) {
+    const r = await this.request("POST", "/v1/webrtc/token/extend", {
+      session_id: options.sessionId,
+      additional_minutes: options.additionalMinutes
+    });
+    return {
+      token: r.token,
+      wsUrl: r.ws_url,
+      newExpiresAt: r.new_expires_at
+    };
+  }
+  // --- Standalone STT ---
+  async createSTTSession(options) {
+    const r = await this.request("POST", "/v1/stt/session", {
+      duration_minutes: options.durationMinutes,
+      language: options.language
+    });
+    return {
+      sessionId: r.session_id,
+      token: r.token,
+      serverUrl: r.server_url,
+      expiresAt: r.expires_at
+    };
+  }
+  async extendSTTSession(options) {
+    const r = await this.request("POST", "/v1/stt/session/extend", {
+      session_id: options.sessionId,
+      additional_minutes: options.additionalMinutes
+    });
+    return {
+      token: r.token,
+      newExpiresAt: r.new_expires_at
+    };
+  }
+  // --- Standalone TTS ---
+  async createTTSSession(options) {
+    const r = await this.request("POST", "/v1/tts/session", {
+      max_characters: options.maxCharacters,
+      language: options.language
+    });
+    return {
+      sessionId: r.session_id,
+      token: r.token,
+      serverUrl: r.server_url,
+      expiresAt: r.expires_at
+    };
+  }
+  async extendTTSSession(options) {
+    const r = await this.request("POST", "/v1/tts/session/extend", {
+      session_id: options.sessionId,
+      additional_characters: options.additionalCharacters
+    });
+    return {
+      token: r.token,
+      maxCharacters: r.max_characters,
+      newExpiresAt: r.new_expires_at
+    };
+  }
+  // --- Internal: authenticated request ---
+  async request(method, path, body) {
+    const headers = await createAuthHeaders(this.account, method, path);
+    const init = {
+      method,
+      headers: {
+        ...headers,
+        ...body !== void 0 ? { "Content-Type": "application/json" } : {}
+      },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    };
+    const resp = await fetch(`${this.baseUrl}${path}`, init);
+    return this.handleResponse(resp, path);
+  }
+  // --- Internal: x402 payment request (for buyCredits) ---
+  async requestWithPayment(path, body) {
+    let resp;
+    try {
+      resp = await this.fetchWithPayment(`${this.baseUrl}${path}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+    } catch (err) {
+      throw new PaymentError(
+        `Payment failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    return this.handleResponse(resp, path);
+  }
+  // --- Internal: response handling ---
+  async handleResponse(resp, path) {
+    if (resp.ok) {
+      return await resp.json();
+    }
+    const text = await resp.text().catch(() => "");
+    let errorMessage;
+    try {
+      const parsed = JSON.parse(text);
+      errorMessage = parsed.error ?? text;
+    } catch {
+      errorMessage = text || resp.statusText;
+    }
+    switch (resp.status) {
+      case 402:
+        throw new InsufficientCreditsError(errorMessage);
+      case 429: {
+        if (errorMessage.toLowerCase().includes("concurrent")) {
+          throw new ConcurrencyLimitError(errorMessage);
+        }
+        throw new RateLimitError(errorMessage);
+      }
+      case 503: {
+        const service = path.split("/")[2] ?? "unknown";
+        throw new NoCapacityError(errorMessage, service);
+      }
+      default:
+        throw new GatewayError(errorMessage, resp.status);
+    }
+  }
+};
+function mapTransaction(r) {
+  return {
+    id: r.id,
+    amount: r.amount,
+    balanceAfter: r.balance_after,
+    type: r.type,
+    referenceId: r.reference_id,
+    service: r.service,
+    description: r.description,
+    createdAt: r.created_at
+  };
+}
+function mapSession(r) {
+  return {
+    id: r.id,
+    service: r.service,
+    bundleId: r.bundle_id,
+    status: r.status,
+    roomName: r.room_name,
+    serverUrl: r.server_url,
+    reservedMicrocredits: r.reserved_microcredits,
+    chargedMicrocredits: r.charged_microcredits,
+    tokenExpiresAt: r.token_expires_at,
+    startedAt: r.started_at,
+    endedAt: r.ended_at,
+    settlementMethod: r.settlement_method,
+    createdAt: r.created_at
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConcurrencyLimitError,
+  DtelecomGateway,
+  GatewayError,
+  InsufficientCreditsError,
+  NoCapacityError,
+  PaymentError,
+  RateLimitError,
+  createAuthHeaders
+});