@blockrun/llm 1.6.2 → 1.8.0

package/dist/index.js

@@ -1143,7 +1143,10 @@ var LLMClient = class _LLMClient {
       contextWindow: m.contextWindow ?? m.context_window ?? 0,
       maxOutput: m.maxOutput ?? m.max_output ?? 0,
       categories: m.categories || [],
-      available: true
+      available: true,
+      billingMode: m.billingMode ?? m.billing_mode,
+      flatPrice: m.flatPrice ?? m.flat_price ?? m.pricing?.flat,
+      hidden: m.hidden
     }));
   }
   /**
@@ -1813,8 +1816,703 @@ var ImageClient = class {
   }
 };
 
+// src/music.ts
+import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
+var DEFAULT_API_URL3 = "https://blockrun.ai/api";
+var DEFAULT_MODEL2 = "minimax/music-2.5+";
+var DEFAULT_TIMEOUT3 = 21e4;
+var MusicClient = 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 = privateKeyToAccount3(privateKey);
+    const apiUrl = options.apiUrl || DEFAULT_API_URL3;
+    validateApiUrl(apiUrl);
+    this.apiUrl = apiUrl.replace(/\/$/, "");
+    this.timeout = options.timeout || DEFAULT_TIMEOUT3;
+  }
+  /**
+   * Generate a music track from a text prompt.
+   *
+   * Takes 1-3 minutes. Returns a CDN URL valid for ~24h.
+   *
+   * @param prompt - Music style, mood, or description
+   * @param options - Optional generation parameters
+   * @returns MusicResponse with track URL and metadata
+   *
+   * @example
+   * const result = await client.generate('chill lo-fi beats with piano');
+   * console.log(result.data[0].url); // Download this URL — expires in 24h
+   *
+   * @example With lyrics
+   * const result = await client.generate('upbeat pop song', {
+   *   instrumental: false,
+   *   lyrics: 'Hello world, this is my song...'
+   * });
+   */
+  async generate(prompt, options) {
+    const instrumental = options?.instrumental ?? true;
+    const lyrics = options?.lyrics?.trim();
+    if (instrumental && lyrics) {
+      throw new Error("Cannot specify lyrics when instrumental is true");
+    }
+    const body = {
+      model: options?.model || DEFAULT_MODEL2,
+      prompt,
+      instrumental
+    };
+    if (lyrics) body.lyrics = lyrics;
+    return this.requestWithPayment("/v1/audio/generations", body);
+  }
+  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/audio/generations`,
+        resourceDescription: details.resource?.description || "BlockRun Music Generation",
+        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 += 0.1575;
+    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
+import { privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
+var DEFAULT_API_URL4 = "https://blockrun.ai/api";
+var DEFAULT_TIMEOUT4 = 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 = privateKeyToAccount4(privateKey);
+    const apiUrl = options.apiUrl || DEFAULT_API_URL4;
+    validateApiUrl(apiUrl);
+    this.apiUrl = apiUrl.replace(/\/$/, "");
+    this.timeout = options.timeout || DEFAULT_TIMEOUT4;
+  }
+  async search(query, options) {
+    if (!query || query.length > 1e3) {
+      throw new Error("query must be 1-1000 characters");
+    }
+    const maxResults = options?.maxResults ?? 10;
+    if (maxResults < 1 || maxResults > 50) {
+      throw new Error("maxResults must be between 1 and 50");
+    }
+    const body = {
+      query,
+      max_results: maxResults
+    };
+    if (options?.sources) body.sources = options.sources;
+    if (options?.fromDate) body.from_date = options.fromDate;
+    if (options?.toDate) body.to_date = options.toDate;
+    return this.requestWithPayment("/v1/search", body);
+  }
+  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 || url,
+        resourceDescription: details.resource?.description || "BlockRun Search",
+        maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
+        extra: details.extra
+      }
+    );
+    const retry = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "PAYMENT-SIGNATURE": paymentPayload
+      },
+      body: JSON.stringify(body)
+    });
+    if (retry.status === 402) {
+      throw new PaymentError("Payment was rejected. Check your wallet balance.");
+    }
+    if (!retry.ok) {
+      let errorBody;
+      try {
+        errorBody = await retry.json();
+      } catch {
+        errorBody = { error: "Request failed" };
+      }
+      throw new APIError(
+        `API error after payment: ${retry.status}`,
+        retry.status,
+        sanitizeErrorResponse(errorBody)
+      );
+    }
+    return retry.json();
+  }
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      return await fetch(url, { ...init, signal: controller.signal });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  getWalletAddress() {
+    return this.account.address;
+  }
+};
+
+// src/x-client.ts
+import { privateKeyToAccount as privateKeyToAccount5 } from "viem/accounts";
+var DEFAULT_API_URL5 = "https://blockrun.ai/api";
+var DEFAULT_TIMEOUT5 = 6e4;
+var XClient = 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 = privateKeyToAccount5(privateKey);
+    const apiUrl = options.apiUrl || DEFAULT_API_URL5;
+    validateApiUrl(apiUrl);
+    this.apiUrl = apiUrl.replace(/\/$/, "");
+    this.timeout = options.timeout || DEFAULT_TIMEOUT5;
+  }
+  // ───────── User endpoints ─────────
+  userLookup(usernames) {
+    return this.post("/v1/x/users/lookup", { usernames });
+  }
+  userInfo(username) {
+    return this.post("/v1/x/users/info", { username });
+  }
+  followers(username, cursor) {
+    const body = { username };
+    if (cursor) body.cursor = cursor;
+    return this.post("/v1/x/users/followers", body);
+  }
+  /** `/v1/x/users/following` (singular path variant). */
+  following(username, cursor) {
+    const body = { username };
+    if (cursor) body.cursor = cursor;
+    return this.post("/v1/x/users/following", body);
+  }
+  /** `/v1/x/users/followings` (plural path variant). */
+  followings(username, cursor) {
+    const body = { username };
+    if (cursor) body.cursor = cursor;
+    return this.post("/v1/x/users/followings", body);
+  }
+  verifiedFollowers(userId, cursor) {
+    const body = { userId };
+    if (cursor) body.cursor = cursor;
+    return this.post(
+      "/v1/x/users/verified-followers",
+      body
+    );
+  }
+  userTweets(options) {
+    if (!options.username && !options.userId) {
+      throw new Error("Either username or userId is required");
+    }
+    const body = {};
+    if (options.username) body.username = options.username;
+    if (options.userId) body.userId = options.userId;
+    if (options.cursor) body.cursor = options.cursor;
+    if (options.includeReplies !== void 0) body.includeReplies = options.includeReplies;
+    return this.post("/v1/x/users/tweets", body);
+  }
+  mentions(username, options) {
+    const body = { username };
+    if (options?.sinceTime) body.sinceTime = options.sinceTime;
+    if (options?.untilTime) body.untilTime = options.untilTime;
+    if (options?.cursor) body.cursor = options.cursor;
+    return this.post("/v1/x/users/mentions", body);
+  }
+  // ───────── Tweet endpoints ─────────
+  tweetLookup(tweetIds) {
+    return this.post("/v1/x/tweets/lookup", {
+      tweet_ids: tweetIds
+    });
+  }
+  tweetReplies(tweetId, options) {
+    const body = { tweetId };
+    if (options?.cursor) body.cursor = options.cursor;
+    if (options?.queryType) body.queryType = options.queryType;
+    return this.post("/v1/x/tweets/replies", body);
+  }
+  tweetThread(tweetId, cursor) {
+    const body = { tweetId };
+    if (cursor) body.cursor = cursor;
+    return this.post("/v1/x/tweets/thread", body);
+  }
+  // ───────── Search & discovery ─────────
+  search(query, options) {
+    const body = { query };
+    if (options?.queryType) body.queryType = options.queryType;
+    if (options?.cursor) body.cursor = options.cursor;
+    return this.post("/v1/x/search", body);
+  }
+  trending() {
+    return this.post("/v1/x/trending", {});
+  }
+  articlesRising() {
+    return this.post("/v1/x/articles/rising", {});
+  }
+  // ───────── Internals ─────────
+  async post(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.payAndRetry(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 payAndRetry(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 || url,
+        resourceDescription: details.resource?.description || "BlockRun X API",
+        maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
+        extra: details.extra
+      }
+    );
+    const retry = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "PAYMENT-SIGNATURE": paymentPayload
+      },
+      body: JSON.stringify(body)
+    });
+    if (retry.status === 402) {
+      throw new PaymentError("Payment was rejected. Check your wallet balance.");
+    }
+    if (!retry.ok) {
+      let errorBody;
+      try {
+        errorBody = await retry.json();
+      } catch {
+        errorBody = { error: "Request failed" };
+      }
+      throw new APIError(
+        `API error after payment: ${retry.status}`,
+        retry.status,
+        sanitizeErrorResponse(errorBody)
+      );
+    }
+    return retry.json();
+  }
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      return await fetch(url, { ...init, signal: controller.signal });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  getWalletAddress() {
+    return this.account.address;
+  }
+};
+
+// src/price.ts
+import { privateKeyToAccount as privateKeyToAccount6 } from "viem/accounts";
+var DEFAULT_API_URL6 = "https://blockrun.ai/api";
+var DEFAULT_TIMEOUT6 = 3e4;
+var PriceClient = class {
+  account = null;
+  privateKey = null;
+  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;
+    const requireWallet = options.requireWallet ?? true;
+    if (!privateKey && requireWallet) {
+      throw new Error(
+        "Private key required for paid endpoints. Pass privateKey in options, set BLOCKRUN_WALLET_KEY, or pass requireWallet: false for free-only usage."
+      );
+    }
+    if (privateKey) {
+      validatePrivateKey(privateKey);
+      this.privateKey = privateKey;
+      this.account = privateKeyToAccount6(privateKey);
+    }
+    const apiUrl = options.apiUrl || DEFAULT_API_URL6;
+    validateApiUrl(apiUrl);
+    this.apiUrl = apiUrl.replace(/\/$/, "");
+    this.timeout = options.timeout || DEFAULT_TIMEOUT6;
+  }
+  async price(category, symbol, options) {
+    if (!symbol) throw new Error("symbol is required");
+    const path5 = categoryPath(category, options?.market, "price", symbol);
+    const query = {};
+    if (options?.session) query.session = options.session;
+    const data = await this.getWithPayment(path5, query);
+    return {
+      symbol: data.symbol ?? symbol.toUpperCase(),
+      price: data.price,
+      publishTime: data.publishTime,
+      confidence: data.confidence,
+      feedId: data.feedId,
+      timestamp: data.timestamp,
+      assetType: data.assetType,
+      category: data.category,
+      source: data.source,
+      free: data.free
+    };
+  }
+  async history(category, symbol, options) {
+    if (!symbol) throw new Error("symbol is required");
+    if (!options.from || options.from <= 0) {
+      throw new Error("history requires options.from (unix seconds)");
+    }
+    const path5 = categoryPath(category, options.market, "history", symbol);
+    const query = {
+      resolution: options.resolution ?? "D",
+      from: String(options.from)
+    };
+    if (options.to) query.to = String(options.to);
+    if (options.session) query.session = options.session;
+    const data = await this.getWithPayment(path5, query);
+    return {
+      symbol: data.symbol ?? symbol.toUpperCase(),
+      resolution: data.resolution ?? (options.resolution ?? "D"),
+      from: data.from,
+      to: data.to,
+      bars: data.bars ?? [],
+      source: data.source,
+      category: data.category
+    };
+  }
+  async listSymbols(category, options) {
+    const path5 = categoryPath(category, options?.market, "list");
+    const query = {
+      limit: String(options?.limit && options.limit > 0 ? options.limit : 100)
+    };
+    if (options?.query) query.q = options.query;
+    const data = await this.getWithPayment(path5, query);
+    if (Array.isArray(data)) {
+      return { symbols: data, count: data.length };
+    }
+    const obj = data;
+    const symbols = obj.symbols ?? obj.feeds ?? [];
+    return {
+      symbols,
+      count: obj.count ?? symbols.length
+    };
+  }
+  getWalletAddress() {
+    return this.account?.address ?? null;
+  }
+  async getWithPayment(endpoint, query) {
+    const url = buildUrl(`${this.apiUrl}${endpoint}`, query);
+    const response = await this.fetchWithTimeout(url, { method: "GET" });
+    if (response.status === 402) {
+      if (!this.privateKey || !this.account) {
+        throw new PaymentError(
+          `${endpoint} returned 402 Payment Required but no wallet is configured.`
+        );
+      }
+      return this.payAndRetry(url, 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 payAndRetry(url, response) {
+    if (!this.privateKey || !this.account) {
+      throw new PaymentError("Wallet required to sign payment.");
+    }
+    let paymentHeader = response.headers.get("payment-required");
+    if (!paymentHeader) {
+      try {
+        const respBody = await response.json();
+        if (respBody.x402) {
+          paymentHeader = btoa(JSON.stringify(respBody.x402));
+        } else if (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 || url,
+        resourceDescription: details.resource?.description || "BlockRun Price Data",
+        maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
+        extra: details.extra
+      }
+    );
+    const retry = await this.fetchWithTimeout(url, {
+      method: "GET",
+      headers: { "PAYMENT-SIGNATURE": paymentPayload }
+    });
+    if (retry.status === 402) {
+      throw new PaymentError("Payment was rejected. Check your wallet balance.");
+    }
+    if (!retry.ok) {
+      let errorBody;
+      try {
+        errorBody = await retry.json();
+      } catch {
+        errorBody = { error: "Request failed" };
+      }
+      throw new APIError(
+        `API error after payment: ${retry.status}`,
+        retry.status,
+        sanitizeErrorResponse(errorBody)
+      );
+    }
+    return retry.json();
+  }
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      return await fetch(url, { ...init, signal: controller.signal });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+function categoryPath(category, market, kind, symbol) {
+  let base;
+  if (category === "stocks") {
+    if (!market) {
+      throw new Error("market is required when category === 'stocks'");
+    }
+    base = `/v1/stocks/${market}`;
+  } else if (["crypto", "fx", "commodity", "usstock"].includes(category)) {
+    base = `/v1/${category}`;
+  } else {
+    throw new Error(`unknown category: ${category}`);
+  }
+  if (!symbol) return `${base}/${kind}`;
+  return `${base}/${kind}/${encodeURIComponent(symbol.toUpperCase())}`;
+}
+function buildUrl(base, query) {
+  const params = Object.entries(query);
+  if (params.length === 0) return base;
+  const qs = params.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+  return `${base}?${qs}`;
+}
+
 // src/wallet.ts
-import { privateKeyToAccount as privateKeyToAccount3, generatePrivateKey } from "viem/accounts";
+import { privateKeyToAccount as privateKeyToAccount7, generatePrivateKey } from "viem/accounts";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
@@ -1824,7 +2522,7 @@ var WALLET_DIR = path.join(os.homedir(), ".blockrun");
 var WALLET_FILE = path.join(WALLET_DIR, ".session");
 function createWallet() {
   const privateKey = generatePrivateKey();
-  const account = privateKeyToAccount3(privateKey);
+  const account = privateKeyToAccount7(privateKey);
   return {
     address: account.address,
     privateKey
@@ -1880,12 +2578,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 = privateKeyToAccount3(envKey);
+    const account = privateKeyToAccount7(envKey);
     return { address: account.address, privateKey: envKey, isNew: false };
   }
   const fileKey = loadWallet();
   if (fileKey) {
-    const account = privateKeyToAccount3(fileKey);
+    const account = privateKeyToAccount7(fileKey);
     return { address: account.address, privateKey: fileKey, isNew: false };
   }
   const { address, privateKey } = createWallet();
@@ -1895,11 +2593,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 privateKeyToAccount3(envKey).address;
+    return privateKeyToAccount7(envKey).address;
   }
   const fileKey = loadWallet();
   if (fileKey) {
-    return privateKeyToAccount3(fileKey).address;
+    return privateKeyToAccount7(fileKey).address;
   }
   return null;
 }
@@ -2079,7 +2777,7 @@ async function getOrCreateSolanaWallet() {
 // src/solana-client.ts
 var SOLANA_API_URL = "https://sol.blockrun.ai/api";
 var DEFAULT_MAX_TOKENS2 = 1024;
-var DEFAULT_TIMEOUT3 = 6e4;
+var DEFAULT_TIMEOUT7 = 6e4;
 var SDK_VERSION2 = "0.3.0";
 var USER_AGENT2 = `blockrun-ts/${SDK_VERSION2}`;
 var SolanaLLMClient = class {
@@ -2104,7 +2802,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_TIMEOUT3;
+    this.timeout = options.timeout || DEFAULT_TIMEOUT7;
   }
   /** Get Solana wallet address (public key in base58). */
   async getWalletAddress() {
@@ -3049,7 +3747,7 @@ var OpenAI = class {
 };
 
 // src/anthropic-compat.ts
-import { privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
+import { privateKeyToAccount as privateKeyToAccount8 } from "viem/accounts";
 var AnthropicClient = class {
   _client = null;
   _clientPromise = null;
@@ -3062,7 +3760,7 @@ var AnthropicClient = class {
     const key = options.privateKey ?? wallet.privateKey;
     validatePrivateKey(key);
     this._privateKey = key;
-    this._account = privateKeyToAccount4(this._privateKey);
+    this._account = privateKeyToAccount8(this._privateKey);
     const apiUrl = options.apiUrl ?? "https://blockrun.ai/api";
     validateApiUrl(apiUrl);
     this._apiUrl = apiUrl.replace(/\/$/, "");
@@ -3164,16 +3862,20 @@ export {
   ImageClient,
   KNOWN_PROVIDERS,
   LLMClient,
+  MusicClient,
   OpenAI,
   PaymentError,
+  PriceClient,
   SOLANA_NETWORK,
   SOLANA_WALLET_FILE as SOLANA_WALLET_FILE_PATH,
+  SearchClient,
   SolanaLLMClient,
   USDC_BASE,
   USDC_BASE_CONTRACT,
   USDC_SOLANA,
   WALLET_DIR_PATH,
   WALLET_FILE_PATH,
+  XClient,
   clearCache,
   createPaymentPayload,
   createSolanaPaymentPayload,