@blockrun/llm 2.1.0 → 2.2.0

package/dist/index.js

@@ -524,9 +524,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' });
    *
@@ -2271,15 +2268,21 @@ var MusicClient = class {
   }
 };
 
-// src/search.ts
+// src/video.ts
 import { privateKeyToAccount as privateKeyToAccount4 } from "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;
@@ -2296,6 +2299,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
+import { privateKeyToAccount as privateKeyToAccount5 } from "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 = privateKeyToAccount5(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
+import { privateKeyToAccount as privateKeyToAccount6 } from "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 = privateKeyToAccount6(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");
@@ -2408,9 +2799,9 @@ var SearchClient = class {
 };
 
 // src/x-client.ts
-import { privateKeyToAccount as privateKeyToAccount5 } from "viem/accounts";
-var DEFAULT_API_URL5 = "https://blockrun.ai/api";
-var DEFAULT_TIMEOUT5 = 6e4;
+import { privateKeyToAccount as privateKeyToAccount7 } from "viem/accounts";
+var DEFAULT_API_URL7 = "https://blockrun.ai/api";
+var DEFAULT_TIMEOUT7 = 6e4;
 var XClient = class _XClient {
   account;
   privateKey;
@@ -2433,11 +2824,11 @@ var XClient = class _XClient {
     }
     validatePrivateKey(privateKey);
     this.privateKey = privateKey;
-    this.account = privateKeyToAccount5(privateKey);
-    const apiUrl = options.apiUrl || DEFAULT_API_URL5;
+    this.account = privateKeyToAccount7(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) {
@@ -2615,9 +3006,9 @@ var XClient = class _XClient {
 };
 
 // src/price.ts
-import { privateKeyToAccount as privateKeyToAccount6 } from "viem/accounts";
-var DEFAULT_API_URL6 = "https://blockrun.ai/api";
-var DEFAULT_TIMEOUT6 = 3e4;
+import { privateKeyToAccount as privateKeyToAccount8 } from "viem/accounts";
+var DEFAULT_API_URL8 = "https://blockrun.ai/api";
+var DEFAULT_TIMEOUT8 = 3e4;
 var PriceClient = class {
   account = null;
   privateKey = null;
@@ -2635,12 +3026,12 @@ var PriceClient = class {
     if (privateKey) {
       validatePrivateKey(privateKey);
       this.privateKey = privateKey;
-      this.account = privateKeyToAccount6(privateKey);
+      this.account = privateKeyToAccount8(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");
@@ -2819,7 +3210,7 @@ function buildUrl(base, query) {
 }
 
 // src/wallet.ts
-import { privateKeyToAccount as privateKeyToAccount7, generatePrivateKey } from "viem/accounts";
+import { privateKeyToAccount as privateKeyToAccount9, generatePrivateKey } from "viem/accounts";
 import * as fs2 from "fs";
 import * as path2 from "path";
 import * as os2 from "os";
@@ -2829,7 +3220,7 @@ var WALLET_DIR = path2.join(os2.homedir(), ".blockrun");
 var WALLET_FILE = path2.join(WALLET_DIR, ".session");
 function createWallet() {
   const privateKey = generatePrivateKey();
-  const account = privateKeyToAccount7(privateKey);
+  const account = privateKeyToAccount9(privateKey);
   return {
     address: account.address,
     privateKey
@@ -2885,12 +3276,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 = privateKeyToAccount7(envKey);
+    const account = privateKeyToAccount9(envKey);
     return { address: account.address, privateKey: envKey, isNew: false };
   }
   const fileKey = loadWallet();
   if (fileKey) {
-    const account = privateKeyToAccount7(fileKey);
+    const account = privateKeyToAccount9(fileKey);
     return { address: account.address, privateKey: fileKey, isNew: false };
   }
   const { address, privateKey } = createWallet();
@@ -2900,11 +3291,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 privateKeyToAccount7(envKey).address;
+    return privateKeyToAccount9(envKey).address;
   }
   const fileKey = loadWallet();
   if (fileKey) {
-    return privateKeyToAccount7(fileKey).address;
+    return privateKeyToAccount9(fileKey).address;
   }
   return null;
 }
@@ -3084,7 +3475,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 {
@@ -3109,7 +3500,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() {
@@ -3934,6 +4325,9 @@ var ChatCompletions = class {
     this.apiUrl = apiUrl;
     this.timeout = timeout;
   }
+  client;
+  apiUrl;
+  timeout;
   async create(params) {
     if (params.stream) {
       return this.createStream(params);
@@ -4013,7 +4407,7 @@ var OpenAI = class {
 };
 
 // src/anthropic-compat.ts
-import { privateKeyToAccount as privateKeyToAccount8 } from "viem/accounts";
+import { privateKeyToAccount as privateKeyToAccount10 } from "viem/accounts";
 var AnthropicClient = class {
   _client = null;
   _clientPromise = null;
@@ -4026,7 +4420,7 @@ var AnthropicClient = class {
     const key = options.privateKey ?? wallet.privateKey;
     validatePrivateKey(key);
     this._privateKey = key;
-    this._account = privateKeyToAccount8(this._privateKey);
+    this._account = privateKeyToAccount10(this._privateKey);
     const apiUrl = options.apiUrl ?? "https://blockrun.ai/api";
     validateApiUrl(apiUrl);
     this._apiUrl = apiUrl.replace(/\/$/, "");
@@ -4139,6 +4533,8 @@ export {
   USDC_BASE,
   USDC_BASE_CONTRACT,
   USDC_SOLANA,
+  VideoClient,
+  VoiceClient,
   WALLET_DIR_PATH,
   WALLET_FILE_PATH,
   XClient,

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@blockrun/llm",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "type": "module",
-  "description": "BlockRun SDK - Pay-per-request AI (LLM, Image, Video, Music) via x402 on Base and Solana",
+  "description": "BlockRun SDK - Pay-per-request AI (LLM, Image, Video, Music, Voice) via x402 on Base and Solana",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,23 +48,23 @@
     "url": "https://github.com/BlockRunAI/blockrun-llm-ts/issues"
   },
   "dependencies": {
-    "@blockrun/clawrouter": "^0.12.71",
+    "@blockrun/clawrouter": "^0.12.190",
     "bs58": "^6.0.0",
-    "viem": "^2.21.0"
+    "viem": "^2.49.0"
   },
   "optionalDependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
-    "@solana/spl-token": "^0.4.0",
-    "@solana/web3.js": "^1.98.0"
+    "@solana/spl-token": "^0.4.14",
+    "@solana/web3.js": "^1.98.4"
   },
   "devDependencies": {
-    "@eslint/js": "^9.0.0",
-    "@types/node": "^20.0.0",
-    "eslint": "^9.0.0",
-    "tsup": "^8.0.0",
-    "typescript": "^5.0.0",
-    "typescript-eslint": "^8.0.0",
-    "vitest": "^1.0.0"
+    "@eslint/js": "^9.39.4",
+    "@types/node": "^20.19.41",
+    "eslint": "^9.39.4",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.59.3",
+    "vitest": "^1.6.1"
   },
   "engines": {
     "node": ">=20"