@blockrun/llm 2.1.0 → 2.2.0

package/README.md

@@ -383,6 +383,35 @@ const r2 = await client.generate('the subject turns and smiles', {
 });
 ```
 
+### Voice Calls
+
+`VoiceClient` wraps `POST /v1/voice/call` (paid, $0.54/call) and
+`GET /v1/voice/call/{callId}` (free polling) — AI-powered outbound phone
+calls powered by Bland.ai. The agent dials the recipient and runs a real-time
+conversation based on your `task` instructions. US + Canada destinations.
+
+```ts
+import { VoiceClient } from '@blockrun/llm';
+
+const client = new VoiceClient();
+
+// Initiate (paid $0.54)
+const result = await client.call({
+  to: '+14155552671',
+  task: 'You are a friendly assistant calling to confirm a 3pm dentist appointment.',
+  voice: 'maya',     // 'nat' | 'josh' | 'maya' | 'june' | 'paige' | 'derek' | 'florian'
+  max_duration: 5,   // minutes (1–30)
+});
+console.log(result.call_id);
+
+// Poll for transcript + recording (free)
+const status = await client.getStatus(result.call_id);
+console.log(status.status, status.recording_url);
+```
+
+Bring your own caller-ID: pass `from: '+14155552671'` (must be a BlockRun
+phone number you own; buy via `/v1/phone/numbers/buy`).
+
 ### Standalone Search
 
 `SearchClient` wraps `POST /v1/search` — standalone Grok Live Search.

package/dist/index.cjs

@@ -48,6 +48,8 @@ __export(index_exports, {
   USDC_BASE: () => USDC_BASE,
   USDC_BASE_CONTRACT: () => USDC_BASE_CONTRACT,
   USDC_SOLANA: () => USDC_SOLANA,
+  VideoClient: () => VideoClient,
+  VoiceClient: () => VoiceClient,
   WALLET_DIR_PATH: () => WALLET_DIR_PATH,
   WALLET_FILE_PATH: () => WALLET_FILE_PATH,
   XClient: () => XClient,
@@ -619,9 +621,6 @@ var LLMClient = class _LLMClient {
    *
    * @example With routing profile
    * ```ts
-   * // Free tier only (zero cost)
-   * const result = await client.smartChat('Hello!', { routingProfile: 'free' });
-   *
    * // Eco mode (budget optimized)
    * const result = await client.smartChat('Explain quantum computing', { routingProfile: 'eco' });
    *
@@ -2366,15 +2365,21 @@ var MusicClient = class {
   }
 };
 
-// src/search.ts
+// src/video.ts
 var import_accounts5 = require("viem/accounts");
 var DEFAULT_API_URL4 = "https://blockrun.ai/api";
-var DEFAULT_TIMEOUT4 = 6e4;
-var SearchClient = class {
+var DEFAULT_MODEL3 = "xai/grok-imagine-video";
+var DEFAULT_TIMEOUT4 = 12e4;
+var POLL_INTERVAL_MS2 = 5e3;
+var DEFAULT_GENERATE_BUDGET_MS = 3e5;
+var MAX_TIMEOUT_SECONDS = 600;
+var VideoClient = class {
   account;
   privateKey;
   apiUrl;
   timeout;
+  sessionTotalUsd = 0;
+  sessionCalls = 0;
   constructor(options = {}) {
     const envKey = typeof process !== "undefined" && process.env ? process.env.BLOCKRUN_WALLET_KEY || process.env.BASE_CHAIN_WALLET_KEY : void 0;
     const privateKey = options.privateKey || envKey;
@@ -2391,6 +2396,394 @@ var SearchClient = class {
     this.apiUrl = apiUrl.replace(/\/$/, "");
     this.timeout = options.timeout || DEFAULT_TIMEOUT4;
   }
+  /**
+   * Generate a short video clip from a text prompt (or text + image).
+   *
+   * Submits an async job, then polls until the video is ready. Typical total
+   * wall-time is 60-180s. If upstream runs past the budget (default 5min),
+   * throws without charging.
+   *
+   * @param prompt - Text description of the video
+   * @param options - Optional generation parameters
+   */
+  async generate(prompt, options) {
+    const body = {
+      model: options?.model || DEFAULT_MODEL3,
+      prompt
+    };
+    if (options?.imageUrl) body.image_url = options.imageUrl;
+    if (options?.durationSeconds !== void 0) body.duration_seconds = options.durationSeconds;
+    const budgetMs = options?.budgetMs ?? DEFAULT_GENERATE_BUDGET_MS;
+    return this.submitAndPoll(body, budgetMs);
+  }
+  // --------------------------------------------------------------------
+  // Internal: async submit + poll
+  // --------------------------------------------------------------------
+  async submitAndPoll(body, budgetMs) {
+    const submitUrl = `${this.apiUrl}/v1/videos/generations`;
+    const resp402 = await this.fetchWithTimeout(submitUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (resp402.status !== 402) {
+      await this.throwApiError(resp402, "Expected 402 on first POST");
+    }
+    const paymentRequired = await this.extractPaymentRequired(resp402);
+    const details = extractPaymentDetails(paymentRequired);
+    const paymentPayload = await createPaymentPayload(
+      this.privateKey,
+      this.account.address,
+      details.recipient,
+      details.amount,
+      details.network || "eip155:8453",
+      {
+        resourceUrl: details.resource?.url || submitUrl,
+        resourceDescription: details.resource?.description || "BlockRun Video Generation",
+        // Ensure signed auth covers the entire polling window.
+        maxTimeoutSeconds: Math.max(details.maxTimeoutSeconds || 0, MAX_TIMEOUT_SECONDS),
+        extra: details.extra
+      }
+    );
+    const submitResp = await this.fetchWithTimeout(submitUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "PAYMENT-SIGNATURE": paymentPayload
+      },
+      body: JSON.stringify(body)
+    });
+    if (submitResp.status === 402) {
+      throw new PaymentError("Payment was rejected. Check your wallet balance.");
+    }
+    if (submitResp.status !== 200 && submitResp.status !== 202) {
+      await this.throwApiError(submitResp, "Submit failed");
+    }
+    const submitData = await submitResp.json();
+    if (!submitData.id || !submitData.poll_url) {
+      throw new APIError(
+        "Submit response missing id/poll_url",
+        submitResp.status,
+        { response: submitData }
+      );
+    }
+    const pollUrl = this.absolute(submitData.poll_url);
+    const deadline = Date.now() + budgetMs;
+    let lastStatus = submitData.status || "queued";
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS2));
+      const pollResp = await this.fetchWithTimeout(pollUrl, {
+        method: "GET",
+        headers: { "PAYMENT-SIGNATURE": paymentPayload }
+      });
+      let pollData = {};
+      try {
+        pollData = await pollResp.json();
+      } catch {
+      }
+      lastStatus = pollData.status || lastStatus;
+      if (pollResp.status === 202 && (lastStatus === "queued" || lastStatus === "in_progress")) {
+        continue;
+      }
+      if (lastStatus === "failed") {
+        throw new APIError(
+          `Upstream generation failed: ${pollData.error || "unknown"}`,
+          pollResp.status,
+          sanitizeErrorResponse(pollData)
+        );
+      }
+      if (pollResp.status === 200 && lastStatus === "completed") {
+        const data = pollData;
+        const billedSeconds = typeof body.duration_seconds === "number" ? body.duration_seconds : 8;
+        this.sessionCalls++;
+        this.sessionTotalUsd += 0.05 * billedSeconds * 1.05;
+        const txHash = pollResp.headers.get("x-payment-receipt") || pollResp.headers.get("X-Payment-Receipt");
+        if (txHash) data.txHash = txHash;
+        return data;
+      }
+      if (pollResp.status !== 200 && pollResp.status !== 202 && pollResp.status !== 504) {
+        await this.throwApiError(pollResp, "Poll failed");
+      }
+    }
+    throw new APIError(
+      `Video generation did not complete within ${Math.round(budgetMs / 1e3)}s (last status: ${lastStatus}). No payment was taken.`,
+      504,
+      { id: submitData.id, last_status: lastStatus }
+    );
+  }
+  absolute(url) {
+    if (url.startsWith("http://") || url.startsWith("https://")) return url;
+    const base = this.apiUrl.endsWith("/api") ? this.apiUrl.slice(0, -"/api".length) : this.apiUrl;
+    return `${base}${url}`;
+  }
+  async extractPaymentRequired(resp) {
+    const header = resp.headers.get("payment-required");
+    if (header) return parsePaymentRequired(header);
+    try {
+      const body = await resp.json();
+      if (body && (body.x402Version !== void 0 || body.accepts !== void 0)) {
+        return body;
+      }
+    } catch {
+    }
+    throw new PaymentError("402 response but no payment requirements found");
+  }
+  async throwApiError(resp, prefix) {
+    let errorBody;
+    try {
+      errorBody = await resp.json();
+    } catch {
+      errorBody = { error: "Request failed" };
+    }
+    throw new APIError(
+      `${prefix}: HTTP ${resp.status}`,
+      resp.status,
+      sanitizeErrorResponse(errorBody)
+    );
+  }
+  async fetchWithTimeout(url, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      return await fetch(url, { ...options, signal: controller.signal });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  getWalletAddress() {
+    return this.account.address;
+  }
+  getSpending() {
+    return { totalUsd: this.sessionTotalUsd, calls: this.sessionCalls };
+  }
+};
+
+// src/voice.ts
+var import_accounts6 = require("viem/accounts");
+var DEFAULT_API_URL5 = "https://blockrun.ai/api";
+var DEFAULT_TIMEOUT5 = 6e4;
+var CALL_PRICE_USD = 0.54;
+var VALID_MODELS = /* @__PURE__ */ new Set(["base", "enhanced", "turbo"]);
+var VoiceClient = class {
+  account;
+  privateKey;
+  apiUrl;
+  timeout;
+  sessionTotalUsd = 0;
+  sessionCalls = 0;
+  constructor(options = {}) {
+    const envKey = typeof process !== "undefined" && process.env ? process.env.BLOCKRUN_WALLET_KEY || process.env.BASE_CHAIN_WALLET_KEY : void 0;
+    const privateKey = options.privateKey || envKey;
+    if (!privateKey) {
+      throw new Error(
+        "Private key required. Pass privateKey in options or set BLOCKRUN_WALLET_KEY environment variable."
+      );
+    }
+    validatePrivateKey(privateKey);
+    this.privateKey = privateKey;
+    this.account = (0, import_accounts6.privateKeyToAccount)(privateKey);
+    const apiUrl = options.apiUrl || DEFAULT_API_URL5;
+    validateApiUrl(apiUrl);
+    this.apiUrl = apiUrl.replace(/\/$/, "");
+    this.timeout = options.timeout || DEFAULT_TIMEOUT5;
+  }
+  /**
+   * Initiate an AI-powered outbound phone call.
+   *
+   * Pricing: $0.54 per call. Returns immediately once the call is queued —
+   * poll getStatus() for transcript and recording.
+   *
+   * @example
+   *   const r = await client.call({
+   *     to: '+14155552671',
+   *     task: 'Confirm the user wants to reschedule to Tuesday 2pm.',
+   *     voice: 'maya',
+   *     max_duration: 3,
+   *   });
+   */
+  async call(options) {
+    if (!options.to || !options.to.trim()) {
+      throw new Error("'to' phone number is required (E.164 format)");
+    }
+    const task = options.task?.trim() ?? "";
+    if (task.length < 10) {
+      throw new Error("'task' must be at least 10 characters");
+    }
+    if (task.length > 4e3) {
+      throw new Error("'task' must be at most 4000 characters");
+    }
+    const maxDuration = options.max_duration ?? 5;
+    if (maxDuration < 1 || maxDuration > 30) {
+      throw new Error("max_duration must be between 1 and 30 minutes");
+    }
+    if (options.model && !VALID_MODELS.has(options.model)) {
+      throw new Error("model must be 'base' | 'enhanced' | 'turbo'");
+    }
+    if (options.interruption_threshold !== void 0 && (options.interruption_threshold < 50 || options.interruption_threshold > 500)) {
+      throw new Error("interruption_threshold must be between 50 and 500");
+    }
+    const body = {
+      to: options.to.trim(),
+      task,
+      max_duration: maxDuration,
+      language: options.language ?? "en-US"
+    };
+    if (options.from) body.from = options.from.trim();
+    if (options.voice) body.voice = options.voice;
+    if (options.first_sentence) body.first_sentence = options.first_sentence.trim();
+    if (options.wait_for_greeting !== void 0) body.wait_for_greeting = options.wait_for_greeting;
+    if (options.interruption_threshold !== void 0) body.interruption_threshold = options.interruption_threshold;
+    if (options.model) body.model = options.model;
+    return this.requestWithPayment("/v1/voice/call", body);
+  }
+  /**
+   * Poll the status of an in-progress or completed call. Free — no payment.
+   *
+   * Returns Bland.ai's full call record: status, transcript, recording URL, etc.
+   * Most fields populate only once the call ends.
+   */
+  async getStatus(callId) {
+    if (!callId || !callId.trim()) {
+      throw new Error("callId is required");
+    }
+    const url = `${this.apiUrl}/v1/voice/call/${encodeURIComponent(callId.trim())}`;
+    const response = await this.fetchWithTimeout(url, {
+      method: "GET",
+      headers: { Accept: "application/json" }
+    });
+    if (response.status === 404) {
+      throw new APIError(`Call not found: ${callId}`, 404, { call_id: callId });
+    }
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {
+        errorBody = { error: "Request failed" };
+      }
+      throw new APIError(`API error: ${response.status}`, response.status, sanitizeErrorResponse(errorBody));
+    }
+    return response.json();
+  }
+  async requestWithPayment(endpoint, body) {
+    const url = `${this.apiUrl}${endpoint}`;
+    const response = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (response.status === 402) {
+      return this.handlePaymentAndRetry(url, body, response);
+    }
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {
+        errorBody = { error: "Request failed" };
+      }
+      throw new APIError(`API error: ${response.status}`, response.status, sanitizeErrorResponse(errorBody));
+    }
+    return response.json();
+  }
+  async handlePaymentAndRetry(url, body, response) {
+    let paymentHeader = response.headers.get("payment-required");
+    if (!paymentHeader) {
+      try {
+        const respBody = await response.json();
+        if (respBody.x402 || respBody.accepts) {
+          paymentHeader = btoa(JSON.stringify(respBody));
+        }
+      } catch {
+      }
+    }
+    if (!paymentHeader) {
+      throw new PaymentError("402 response but no payment requirements found");
+    }
+    const paymentRequired = parsePaymentRequired(paymentHeader);
+    const details = extractPaymentDetails(paymentRequired);
+    const paymentPayload = await createPaymentPayload(
+      this.privateKey,
+      this.account.address,
+      details.recipient,
+      details.amount,
+      details.network || "eip155:8453",
+      {
+        resourceUrl: details.resource?.url || `${this.apiUrl}/v1/voice/call`,
+        resourceDescription: details.resource?.description || "BlockRun Voice Call",
+        maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
+        extra: details.extra
+      }
+    );
+    const retryResponse = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "PAYMENT-SIGNATURE": paymentPayload
+      },
+      body: JSON.stringify(body)
+    });
+    if (retryResponse.status === 402) {
+      throw new PaymentError("Payment was rejected. Check your wallet balance.");
+    }
+    if (!retryResponse.ok) {
+      let errorBody;
+      try {
+        errorBody = await retryResponse.json();
+      } catch {
+        errorBody = { error: "Request failed" };
+      }
+      throw new APIError(`API error after payment: ${retryResponse.status}`, retryResponse.status, sanitizeErrorResponse(errorBody));
+    }
+    const data = await retryResponse.json();
+    this.sessionCalls++;
+    this.sessionTotalUsd += CALL_PRICE_USD;
+    const txHash = retryResponse.headers.get("x-payment-receipt") || retryResponse.headers.get("X-Payment-Receipt");
+    if (txHash) data.txHash = txHash;
+    return data;
+  }
+  async fetchWithTimeout(url, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      return await fetch(url, { ...options, signal: controller.signal });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  getWalletAddress() {
+    return this.account.address;
+  }
+  getSpending() {
+    return { totalUsd: this.sessionTotalUsd, calls: this.sessionCalls };
+  }
+};
+
+// src/search.ts
+var import_accounts7 = require("viem/accounts");
+var DEFAULT_API_URL6 = "https://blockrun.ai/api";
+var DEFAULT_TIMEOUT6 = 6e4;
+var SearchClient = class {
+  account;
+  privateKey;
+  apiUrl;
+  timeout;
+  constructor(options = {}) {
+    const envKey = typeof process !== "undefined" && process.env ? process.env.BLOCKRUN_WALLET_KEY || process.env.BASE_CHAIN_WALLET_KEY : void 0;
+    const privateKey = options.privateKey || envKey;
+    if (!privateKey) {
+      throw new Error(
+        "Private key required. Pass privateKey in options or set BLOCKRUN_WALLET_KEY environment variable."
+      );
+    }
+    validatePrivateKey(privateKey);
+    this.privateKey = privateKey;
+    this.account = (0, import_accounts7.privateKeyToAccount)(privateKey);
+    const apiUrl = options.apiUrl || DEFAULT_API_URL6;
+    validateApiUrl(apiUrl);
+    this.apiUrl = apiUrl.replace(/\/$/, "");
+    this.timeout = options.timeout || DEFAULT_TIMEOUT6;
+  }
   async search(query, options) {
     if (!query || query.length > 1e3) {
       throw new Error("query must be 1-1000 characters");
@@ -2503,9 +2896,9 @@ var SearchClient = class {
 };
 
 // src/x-client.ts
-var import_accounts6 = require("viem/accounts");
-var DEFAULT_API_URL5 = "https://blockrun.ai/api";
-var DEFAULT_TIMEOUT5 = 6e4;
+var import_accounts8 = require("viem/accounts");
+var DEFAULT_API_URL7 = "https://blockrun.ai/api";
+var DEFAULT_TIMEOUT7 = 6e4;
 var XClient = class _XClient {
   account;
   privateKey;
@@ -2528,11 +2921,11 @@ var XClient = class _XClient {
     }
     validatePrivateKey(privateKey);
     this.privateKey = privateKey;
-    this.account = (0, import_accounts6.privateKeyToAccount)(privateKey);
-    const apiUrl = options.apiUrl || DEFAULT_API_URL5;
+    this.account = (0, import_accounts8.privateKeyToAccount)(privateKey);
+    const apiUrl = options.apiUrl || DEFAULT_API_URL7;
     validateApiUrl(apiUrl);
     this.apiUrl = apiUrl.replace(/\/$/, "");
-    this.timeout = options.timeout || DEFAULT_TIMEOUT5;
+    this.timeout = options.timeout || DEFAULT_TIMEOUT7;
   }
   // ───────── User endpoints ─────────
   userLookup(usernames) {
@@ -2710,9 +3103,9 @@ var XClient = class _XClient {
 };
 
 // src/price.ts
-var import_accounts7 = require("viem/accounts");
-var DEFAULT_API_URL6 = "https://blockrun.ai/api";
-var DEFAULT_TIMEOUT6 = 3e4;
+var import_accounts9 = require("viem/accounts");
+var DEFAULT_API_URL8 = "https://blockrun.ai/api";
+var DEFAULT_TIMEOUT8 = 3e4;
 var PriceClient = class {
   account = null;
   privateKey = null;
@@ -2730,12 +3123,12 @@ var PriceClient = class {
     if (privateKey) {
       validatePrivateKey(privateKey);
       this.privateKey = privateKey;
-      this.account = (0, import_accounts7.privateKeyToAccount)(privateKey);
+      this.account = (0, import_accounts9.privateKeyToAccount)(privateKey);
     }
-    const apiUrl = options.apiUrl || DEFAULT_API_URL6;
+    const apiUrl = options.apiUrl || DEFAULT_API_URL8;
     validateApiUrl(apiUrl);
     this.apiUrl = apiUrl.replace(/\/$/, "");
-    this.timeout = options.timeout || DEFAULT_TIMEOUT6;
+    this.timeout = options.timeout || DEFAULT_TIMEOUT8;
   }
   async price(category, symbol, options) {
     if (!symbol) throw new Error("symbol is required");
@@ -2914,7 +3307,7 @@ function buildUrl(base, query) {
 }
 
 // src/wallet.ts
-var import_accounts8 = require("viem/accounts");
+var import_accounts10 = require("viem/accounts");
 var fs2 = __toESM(require("fs"), 1);
 var path2 = __toESM(require("path"), 1);
 var os2 = __toESM(require("os"), 1);
@@ -2923,8 +3316,8 @@ var BASE_CHAIN_ID2 = "8453";
 var WALLET_DIR = path2.join(os2.homedir(), ".blockrun");
 var WALLET_FILE = path2.join(WALLET_DIR, ".session");
 function createWallet() {
-  const privateKey = (0, import_accounts8.generatePrivateKey)();
-  const account = (0, import_accounts8.privateKeyToAccount)(privateKey);
+  const privateKey = (0, import_accounts10.generatePrivateKey)();
+  const account = (0, import_accounts10.privateKeyToAccount)(privateKey);
   return {
     address: account.address,
     privateKey
@@ -2980,12 +3373,12 @@ function loadWallet() {
 function getOrCreateWallet() {
   const envKey = typeof process !== "undefined" && process.env ? process.env.BLOCKRUN_WALLET_KEY || process.env.BASE_CHAIN_WALLET_KEY : void 0;
   if (envKey) {
-    const account = (0, import_accounts8.privateKeyToAccount)(envKey);
+    const account = (0, import_accounts10.privateKeyToAccount)(envKey);
     return { address: account.address, privateKey: envKey, isNew: false };
   }
   const fileKey = loadWallet();
   if (fileKey) {
-    const account = (0, import_accounts8.privateKeyToAccount)(fileKey);
+    const account = (0, import_accounts10.privateKeyToAccount)(fileKey);
     return { address: account.address, privateKey: fileKey, isNew: false };
   }
   const { address, privateKey } = createWallet();
@@ -2995,11 +3388,11 @@ function getOrCreateWallet() {
 function getWalletAddress() {
   const envKey = typeof process !== "undefined" && process.env ? process.env.BLOCKRUN_WALLET_KEY || process.env.BASE_CHAIN_WALLET_KEY : void 0;
   if (envKey) {
-    return (0, import_accounts8.privateKeyToAccount)(envKey).address;
+    return (0, import_accounts10.privateKeyToAccount)(envKey).address;
   }
   const fileKey = loadWallet();
   if (fileKey) {
-    return (0, import_accounts8.privateKeyToAccount)(fileKey).address;
+    return (0, import_accounts10.privateKeyToAccount)(fileKey).address;
   }
   return null;
 }
@@ -3179,7 +3572,7 @@ async function getOrCreateSolanaWallet() {
 // src/solana-client.ts
 var SOLANA_API_URL = "https://sol.blockrun.ai/api";
 var DEFAULT_MAX_TOKENS2 = 1024;
-var DEFAULT_TIMEOUT7 = 6e4;
+var DEFAULT_TIMEOUT9 = 6e4;
 var SDK_VERSION2 = "0.3.0";
 var USER_AGENT2 = `blockrun-ts/${SDK_VERSION2}`;
 var SolanaLLMClient = class {
@@ -3204,7 +3597,7 @@ var SolanaLLMClient = class {
     validateApiUrl(apiUrl);
     this.apiUrl = apiUrl.replace(/\/$/, "");
     this.rpcUrl = options.rpcUrl || "https://api.mainnet-beta.solana.com";
-    this.timeout = options.timeout || DEFAULT_TIMEOUT7;
+    this.timeout = options.timeout || DEFAULT_TIMEOUT9;
   }
   /** Get Solana wallet address (public key in base58). */
   async getWalletAddress() {
@@ -4029,6 +4422,9 @@ var ChatCompletions = class {
     this.apiUrl = apiUrl;
     this.timeout = timeout;
   }
+  client;
+  apiUrl;
+  timeout;
   async create(params) {
     if (params.stream) {
       return this.createStream(params);
@@ -4108,7 +4504,7 @@ var OpenAI = class {
 };
 
 // src/anthropic-compat.ts
-var import_accounts9 = require("viem/accounts");
+var import_accounts11 = require("viem/accounts");
 var AnthropicClient = class {
   _client = null;
   _clientPromise = null;
@@ -4121,7 +4517,7 @@ var AnthropicClient = class {
     const key = options.privateKey ?? wallet.privateKey;
     validatePrivateKey(key);
     this._privateKey = key;
-    this._account = (0, import_accounts9.privateKeyToAccount)(this._privateKey);
+    this._account = (0, import_accounts11.privateKeyToAccount)(this._privateKey);
     const apiUrl = options.apiUrl ?? "https://blockrun.ai/api";
     validateApiUrl(apiUrl);
     this._apiUrl = apiUrl.replace(/\/$/, "");
@@ -4235,6 +4631,8 @@ var AnthropicClient = class {
   USDC_BASE,
   USDC_BASE_CONTRACT,
   USDC_SOLANA,
+  VideoClient,
+  VoiceClient,
   WALLET_DIR_PATH,
   WALLET_FILE_PATH,
   XClient,