@ckcloudai.com/clawrouter 0.0.5 → 0.0.7

package/dist/index.js

@@ -12,6 +12,430 @@ var PROXY_PORT = (() => {
 })();
 var PLUGIN_NAME = "ckcloud";
 
+// src/balance.ts
+import { createPublicClient, http, erc20Abi } from "viem";
+import { base } from "viem/chains";
+
+// src/errors.ts
+var RpcError = class extends Error {
+  code = "RPC_ERROR";
+  originalError;
+  constructor(message, originalError) {
+    super(`RPC error: ${message}. Check network connectivity.`);
+    this.name = "RpcError";
+    this.originalError = originalError;
+  }
+};
+
+// src/plugin-logger.ts
+var pluginLogger = console;
+function setPluginLogger(logger2) {
+  pluginLogger = logger2 ?? console;
+}
+var logger = {
+  debug: (message) => pluginLogger.debug?.(message),
+  info: (message) => pluginLogger.info(message),
+  warn: (message) => pluginLogger.warn(message),
+  error: (message) => pluginLogger.error(message)
+};
+
+// src/balance.ts
+var USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var CACHE_TTL_MS = 3e4;
+var REMOTE_BALANCE_TIMEOUT_MS = 5e3;
+var REMOTE_BALANCE_URL = "https://t.ckcloudai.com/v1/balance?Pubkey=";
+var BALANCE_THRESHOLDS = {
+  /** Low balance warning threshold: $1.00 */
+  LOW_BALANCE_MICROS: 1000000n,
+  /** Effectively zero threshold: $0.0001 (covers dust/rounding) */
+  ZERO_THRESHOLD: 100n
+};
+var BalanceMonitor = class {
+  client;
+  walletAddress;
+  /** Cached balance (null = not yet fetched) */
+  cachedBalance = null;
+  /** Timestamp when cache was last updated */
+  cachedAt = 0;
+  constructor(walletAddress) {
+    this.walletAddress = walletAddress;
+    this.client = createPublicClient({
+      chain: base,
+      transport: http(void 0, {
+        timeout: 1e4
+        // 10 second timeout to prevent hanging on slow RPC
+      })
+    });
+  }
+  /**
+   * Check current USDC balance.
+   * Uses cache if valid, otherwise fetches from RPC.
+   */
+  async checkBalance() {
+    const now = Date.now();
+    if (this.cachedBalance !== null && this.cachedBalance > 0n && now - this.cachedAt < CACHE_TTL_MS) {
+      return this.buildInfo(this.cachedBalance);
+    }
+    const remoteBalance = await this.fetchRemoteBalance();
+    if (remoteBalance !== null) {
+      if (remoteBalance > 0n) {
+        this.cachedBalance = remoteBalance;
+        this.cachedAt = now;
+      }
+      return this.buildInfo(remoteBalance);
+    }
+    const balance = await this.fetchBalance();
+    if (balance > 0n) {
+      this.cachedBalance = balance;
+      this.cachedAt = now;
+    }
+    return this.buildInfo(balance);
+  }
+  /**
+   * Best-effort remote balance lookup.
+   * Returns balance in USDC micros or null if unavailable/invalid.
+   */
+  async fetchRemoteBalance() {
+    const url = `${REMOTE_BALANCE_URL}${encodeURIComponent(this.walletAddress)}`;
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), REMOTE_BALANCE_TIMEOUT_MS);
+      const resp = await fetch(url, { signal: controller.signal });
+      clearTimeout(timeoutId);
+      if (!resp.ok) {
+        logger.warn(
+          `[ckcloud] Remote balance lookup failed (${resp.status}) for ${this.walletAddress}`
+        );
+        return null;
+      }
+      const text = await resp.text();
+      const parsed = this.parseRemoteBalance(text);
+      if (parsed === null) {
+        logger.warn(`[ckcloud] Remote balance lookup returned unparseable data`);
+      }
+      return parsed;
+    } catch (err) {
+      logger.warn(
+        `[ckcloud] Remote balance lookup error for ${this.walletAddress}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return null;
+    }
+  }
+  parseRemoteBalance(body) {
+    const trimmed = body.trim();
+    if (!trimmed) return null;
+    try {
+      const data = JSON.parse(trimmed);
+      const extracted = this.extractBalanceValue(data);
+      return this.coerceMicros(extracted);
+    } catch {
+    }
+    return this.coerceMicros(trimmed);
+  }
+  extractBalanceValue(data) {
+    if (data && typeof data === "object") {
+      const obj = data;
+      return obj.balance ?? obj.balance_usd ?? obj.balanceUSD ?? (obj.data && typeof obj.data === "object" ? obj.data.balance ?? obj.data.balance_usd ?? obj.data.balanceUSD : void 0) ?? (obj.result && typeof obj.result === "object" ? obj.result.balance ?? obj.result.balance_usd ?? obj.result.balanceUSD : void 0);
+    }
+    return data;
+  }
+  coerceMicros(value) {
+    if (value === null || value === void 0) return null;
+    if (typeof value === "number") {
+      if (!Number.isFinite(value)) return null;
+      if (Number.isInteger(value)) return value >= 0 ? BigInt(value) : null;
+      return BigInt(Math.round(value * 1e6));
+    }
+    if (typeof value === "string") {
+      const match = value.trim().match(/-?\d+(\.\d+)?/);
+      if (!match) return null;
+      const s = match[0];
+      if (s.includes(".")) {
+        const num = Number.parseFloat(s);
+        if (!Number.isFinite(num)) return null;
+        return BigInt(Math.round(num * 1e6));
+      }
+      try {
+        return BigInt(s);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if balance is sufficient for an estimated cost.
+   *
+   * @param estimatedCostMicros - Estimated cost in USDC smallest unit (6 decimals)
+   */
+  async checkSufficient(estimatedCostMicros) {
+    const info = await this.checkBalance();
+    if (info.balance >= estimatedCostMicros) {
+      return { sufficient: true, info };
+    }
+    const shortfall = estimatedCostMicros - info.balance;
+    return {
+      sufficient: false,
+      info,
+      shortfall: this.formatUSDC(shortfall)
+    };
+  }
+  /**
+   * Optimistically deduct estimated cost from cached balance.
+   * Call this after a successful payment to keep cache accurate.
+   *
+   * @param amountMicros - Amount to deduct in USDC smallest unit
+   */
+  deductEstimated(amountMicros) {
+    if (this.cachedBalance !== null && this.cachedBalance >= amountMicros) {
+      this.cachedBalance -= amountMicros;
+    }
+  }
+  /**
+   * Invalidate cache, forcing next checkBalance() to fetch from RPC.
+   * Call this after a payment failure to get accurate balance.
+   */
+  invalidate() {
+    this.cachedBalance = null;
+    this.cachedAt = 0;
+  }
+  /**
+   * Force refresh balance from RPC (ignores cache).
+   */
+  async refresh() {
+    this.invalidate();
+    return this.checkBalance();
+  }
+  /**
+   * Format USDC amount (in micros) as "$X.XX".
+   */
+  formatUSDC(amountMicros) {
+    const dollars = Number(amountMicros) / 1e6;
+    return `$${dollars.toFixed(2)}`;
+  }
+  /**
+   * Get the wallet address being monitored.
+   */
+  getWalletAddress() {
+    return this.walletAddress;
+  }
+  /** Fetch balance from RPC */
+  async fetchBalance() {
+    try {
+      const balance = await this.client.readContract({
+        address: USDC_BASE,
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [this.walletAddress]
+      });
+      return balance;
+    } catch (error) {
+      throw new RpcError(error instanceof Error ? error.message : "Unknown error", error);
+    }
+  }
+  /** Build BalanceInfo from raw balance */
+  buildInfo(balance) {
+    return {
+      balance,
+      balanceUSD: this.formatUSDC(balance),
+      isLow: balance < BALANCE_THRESHOLDS.LOW_BALANCE_MICROS,
+      isEmpty: balance < BALANCE_THRESHOLDS.ZERO_THRESHOLD,
+      walletAddress: this.walletAddress
+    };
+  }
+};
+
+// src/solana-balance.ts
+import { address as solAddress, createSolanaRpc } from "@solana/kit";
+var SOLANA_USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+var SOLANA_DEFAULT_RPC = "https://api.mainnet-beta.solana.com";
+var BALANCE_TIMEOUT_MS = 1e4;
+var CACHE_TTL_MS2 = 3e4;
+var REMOTE_BALANCE_TIMEOUT_MS2 = 5e3;
+var REMOTE_BALANCE_URL2 = "https://t.ckcloudai.com/v1/balance?Pubkey=";
+var SolanaBalanceMonitor = class {
+  rpc;
+  walletAddress;
+  cachedBalance = null;
+  cachedAt = 0;
+  constructor(walletAddress, rpcUrl) {
+    this.walletAddress = walletAddress;
+    const url = rpcUrl || process["env"].CLAWROUTER_SOLANA_RPC_URL || SOLANA_DEFAULT_RPC;
+    this.rpc = createSolanaRpc(url);
+  }
+  async checkBalance() {
+    const now = Date.now();
+    if (this.cachedBalance !== null && this.cachedBalance > 0n && now - this.cachedAt < CACHE_TTL_MS2) {
+      return this.buildInfo(this.cachedBalance);
+    }
+    const remoteBalance = await this.fetchRemoteBalance();
+    if (remoteBalance !== null) {
+      if (remoteBalance > 0n) {
+        this.cachedBalance = remoteBalance;
+        this.cachedAt = now;
+      }
+      return this.buildInfo(remoteBalance);
+    }
+    const balance = await this.fetchBalance();
+    if (balance > 0n) {
+      this.cachedBalance = balance;
+      this.cachedAt = now;
+    }
+    return this.buildInfo(balance);
+  }
+  /**
+   * Best-effort remote balance lookup.
+   * Returns balance in USDC micros or null if unavailable/invalid.
+   */
+  async fetchRemoteBalance() {
+    const url = `${REMOTE_BALANCE_URL2}${encodeURIComponent(this.walletAddress)}`;
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), REMOTE_BALANCE_TIMEOUT_MS2);
+      const resp = await fetch(url, { signal: controller.signal });
+      clearTimeout(timeoutId);
+      if (!resp.ok) {
+        logger.warn(
+          `[ckcloud] Remote balance lookup failed (${resp.status}) for ${this.walletAddress}`
+        );
+        return null;
+      }
+      const text = await resp.text();
+      const parsed = this.parseRemoteBalance(text);
+      if (parsed === null) {
+        logger.warn(`[ckcloud] Remote balance lookup returned unparseable data`);
+      }
+      return parsed;
+    } catch (err) {
+      logger.warn(
+        `[ckcloud] Remote balance lookup error for ${this.walletAddress}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return null;
+    }
+  }
+  parseRemoteBalance(body) {
+    const trimmed = body.trim();
+    if (!trimmed) return null;
+    try {
+      const data = JSON.parse(trimmed);
+      const extracted = this.extractBalanceValue(data);
+      return this.coerceMicros(extracted);
+    } catch {
+    }
+    return this.coerceMicros(trimmed);
+  }
+  extractBalanceValue(data) {
+    if (data && typeof data === "object") {
+      const obj = data;
+      return obj.balance ?? obj.balance_usd ?? obj.balanceUSD ?? (obj.data && typeof obj.data === "object" ? obj.data.balance ?? obj.data.balance_usd ?? obj.data.balanceUSD : void 0) ?? (obj.result && typeof obj.result === "object" ? obj.result.balance ?? obj.result.balance_usd ?? obj.result.balanceUSD : void 0);
+    }
+    return data;
+  }
+  coerceMicros(value) {
+    if (value === null || value === void 0) return null;
+    if (typeof value === "number") {
+      if (!Number.isFinite(value)) return null;
+      if (Number.isInteger(value)) return value >= 0 ? BigInt(value) : null;
+      return BigInt(Math.round(value * 1e6));
+    }
+    if (typeof value === "string") {
+      const match = value.trim().match(/-?\d+(\.\d+)?/);
+      if (!match) return null;
+      const s = match[0];
+      if (s.includes(".")) {
+        const num = Number.parseFloat(s);
+        if (!Number.isFinite(num)) return null;
+        return BigInt(Math.round(num * 1e6));
+      }
+      try {
+        return BigInt(s);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  deductEstimated(amountMicros) {
+    if (this.cachedBalance !== null && this.cachedBalance >= amountMicros) {
+      this.cachedBalance -= amountMicros;
+    }
+  }
+  invalidate() {
+    this.cachedBalance = null;
+    this.cachedAt = 0;
+  }
+  async refresh() {
+    this.invalidate();
+    return this.checkBalance();
+  }
+  /**
+   * Check if balance is sufficient for an estimated cost.
+   */
+  async checkSufficient(estimatedCostMicros) {
+    const info = await this.checkBalance();
+    if (info.balance >= estimatedCostMicros) {
+      return { sufficient: true, info };
+    }
+    const shortfall = estimatedCostMicros - info.balance;
+    return {
+      sufficient: false,
+      info,
+      shortfall: this.formatUSDC(shortfall)
+    };
+  }
+  /**
+   * Format USDC amount (in micros) as "$X.XX".
+   */
+  formatUSDC(amountMicros) {
+    const dollars = Number(amountMicros) / 1e6;
+    return `$${dollars.toFixed(2)}`;
+  }
+  getWalletAddress() {
+    return this.walletAddress;
+  }
+  async fetchBalance() {
+    const owner = solAddress(this.walletAddress);
+    const mint = solAddress(SOLANA_USDC_MINT);
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const result = await this.fetchBalanceOnce(owner, mint);
+      if (result > 0n || attempt === 1) return result;
+      await new Promise((r) => setTimeout(r, 1e3));
+    }
+    return 0n;
+  }
+  async fetchBalanceOnce(owner, mint) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), BALANCE_TIMEOUT_MS);
+    try {
+      const response = await this.rpc.getTokenAccountsByOwner(owner, { mint }, { encoding: "jsonParsed" }).send({ abortSignal: controller.signal });
+      if (response.value.length === 0) return 0n;
+      let total = 0n;
+      for (const account of response.value) {
+        const parsed = account.account.data;
+        total += BigInt(parsed.parsed.info.tokenAmount.amount);
+      }
+      return total;
+    } catch (err) {
+      throw new Error(
+        `Failed to fetch Solana USDC balance: ${err instanceof Error ? err.message : String(err)}`,
+        { cause: err }
+      );
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  buildInfo(balance) {
+    const dollars = Number(balance) / 1e6;
+    return {
+      balance,
+      balanceUSD: `$${dollars.toFixed(2)}`,
+      isLow: balance < 1000000n,
+      isEmpty: balance < 100n,
+      walletAddress: this.walletAddress
+    };
+  }
+};
+
 // src/index.ts
 import { join as join6 } from "path";
 import { homedir as homedir5 } from "os";
@@ -128,7 +552,7 @@ async function loadBaseModels() {
 }
 var BASE_MODELS = [...DEFAULT_BASE_MODELS];
 function resolveModelAlias(model) {
-  const normalized = model.trim().toLowerCase();
+  const normalized = model.trim();
   const resolved = MODEL_ALIASES[normalized];
   if (resolved) return resolved;
   if (normalized.startsWith("ckcloud/")) {
@@ -163,68 +587,7 @@ function toOpenClawModel(m) {
     maxTokens: m.maxOutput
   };
 }
-var MODEL_ALIASES = {
-  // Claude - use newest versions (4.6)
-  claude: "anthropic/claude-sonnet-4.6",
-  sonnet: "anthropic/claude-sonnet-4.6",
-  "sonnet-4": "anthropic/claude-sonnet-4.6",
-  "sonnet-4.6": "anthropic/claude-sonnet-4.6",
-  "sonnet-4-6": "anthropic/claude-sonnet-4.6",
-  opus: "anthropic/claude-opus-4.6",
-  "opus-4": "anthropic/claude-opus-4.6",
-  "opus-4.6": "anthropic/claude-opus-4.6",
-  "opus-4-6": "anthropic/claude-opus-4.6",
-  haiku: "anthropic/claude-haiku-4.5",
-  // Claude - provider/shortname patterns (common in agent frameworks)
-  "anthropic/sonnet": "anthropic/claude-sonnet-4.6",
-  "anthropic/opus": "anthropic/claude-opus-4.6",
-  "anthropic/haiku": "anthropic/claude-haiku-4.5",
-  "anthropic/claude": "anthropic/claude-sonnet-4.6",
-  // Backward compatibility - map all variants to 4.6
-  "anthropic/claude-sonnet-4": "anthropic/claude-sonnet-4.6",
-  "anthropic/claude-sonnet-4-6": "anthropic/claude-sonnet-4.6",
-  "anthropic/claude-opus-4": "anthropic/claude-opus-4.6",
-  "anthropic/claude-opus-4-6": "anthropic/claude-opus-4.6",
-  "anthropic/claude-opus-4.5": "anthropic/claude-opus-4.6",
-  "anthropic/claude-haiku-4": "anthropic/claude-haiku-4.5",
-  "anthropic/claude-haiku-4-5": "anthropic/claude-haiku-4.5",
-  // OpenAI
-  gpt: "openai/gpt-4o",
-  gpt4: "openai/gpt-4o",
-  gpt5: "openai/gpt-5.4",
-  "gpt-5.4": "openai/gpt-5.4",
-  "gpt-5.4-pro": "openai/gpt-5.4-pro",
-  codex: "openai/gpt-5.2-codex",
-  mini: "openai/gpt-4o-mini",
-  o1: "openai/o1",
-  o3: "openai/o3",
-  // DeepSeek
-  deepseek: "deepseek/deepseek-chat",
-  reasoner: "deepseek/deepseek-reasoner",
-  // Kimi / Moonshot
-  kimi: "moonshot/kimi-k2.5",
-  moonshot: "moonshot/kimi-k2.5",
-  "kimi-k2.5": "moonshot/kimi-k2.5",
-  // Google
-  gemini: "google/gemini-2.5-pro",
-  flash: "google/gemini-2.5-flash",
-  "gemini-3.1-pro-preview": "google/gemini-3.1-pro",
-  "google/gemini-3.1-pro-preview": "google/gemini-3.1-pro",
-  // xAI
-  grok: "xai/grok-3",
-  "grok-fast": "xai/grok-4-fast-reasoning",
-  "grok-code": "xai/grok-code-fast-1",
-  // NVIDIA
-  nvidia: "nvidia/gpt-oss-120b",
-  "gpt-120b": "nvidia/gpt-oss-120b",
-  // MiniMax
-  minimax: "minimax/minimax-m2.5",
-  // Routing profile aliases (common variations)
-  "auto-router": "auto",
-  router: "auto"
-  // Note: auto, free, eco, premium are virtual routing profiles registered in BASE_MODELS
-  // They don't need aliases since they're already top-level model IDs
-};
+var MODEL_ALIASES = {};
 function buildAliasModels(baseModels) {
   return Object.entries(MODEL_ALIASES).map(([alias, targetId]) => {
     const target = baseModels.find((m) => m.id === targetId);
@@ -338,305 +701,57 @@ function createPayFetchWithPreAuth(baseFetch, client, ttlMs = DEFAULT_TTL_MS, op
       try {
         const payload2 = await client.createPaymentPayload(cached.paymentRequired);
         const headers = httpClient.encodePaymentSignatureHeader(payload2);
-        const preAuthRequest = request.clone();
-        for (const [key, value] of Object.entries(headers)) {
-          preAuthRequest.headers.set(key, value);
-        }
-        const response2 = await baseFetch(preAuthRequest);
-        if (response2.status !== 402) {
-          return response2;
-        }
-        cache.delete(urlPath);
-      } catch {
-        cache.delete(urlPath);
-      }
-    }
-    const clonedRequest = request.clone();
-    const response = await baseFetch(request);
-    if (response.status !== 402) {
-      return response;
-    }
-    let paymentRequired;
-    try {
-      const getHeader = (name) => response.headers.get(name);
-      let body;
-      try {
-        const responseText = await Promise.race([
-          response.text(),
-          new Promise(
-            (_, reject) => setTimeout(() => reject(new Error("Body read timeout")), 3e4)
-          )
-        ]);
-        if (responseText) body = JSON.parse(responseText);
-      } catch {
-      }
-      paymentRequired = httpClient.getPaymentRequiredResponse(getHeader, body);
-      cache.set(urlPath, { paymentRequired, cachedAt: Date.now() });
-    } catch (error) {
-      throw new Error(
-        `Failed to parse payment requirements: ${error instanceof Error ? error.message : "Unknown error"}`,
-        { cause: error }
-      );
-    }
-    const payload = await client.createPaymentPayload(paymentRequired);
-    const paymentHeaders = httpClient.encodePaymentSignatureHeader(payload);
-    for (const [key, value] of Object.entries(paymentHeaders)) {
-      clonedRequest.headers.set(key, value);
-    }
-    return baseFetch(clonedRequest);
-  };
-}
-
-// src/proxy.ts
-import { registerExactEvmScheme } from "@x402/evm/exact/client";
-
-// src/balance.ts
-import { createPublicClient, http, erc20Abi } from "viem";
-import { base } from "viem/chains";
-
-// src/errors.ts
-var RpcError = class extends Error {
-  code = "RPC_ERROR";
-  originalError;
-  constructor(message, originalError) {
-    super(`RPC error: ${message}. Check network connectivity.`);
-    this.name = "RpcError";
-    this.originalError = originalError;
-  }
-};
-
-// src/balance.ts
-var USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-var CACHE_TTL_MS = 3e4;
-var BALANCE_THRESHOLDS = {
-  /** Low balance warning threshold: $1.00 */
-  LOW_BALANCE_MICROS: 1000000n,
-  /** Effectively zero threshold: $0.0001 (covers dust/rounding) */
-  ZERO_THRESHOLD: 100n
-};
-var BalanceMonitor = class {
-  client;
-  walletAddress;
-  /** Cached balance (null = not yet fetched) */
-  cachedBalance = null;
-  /** Timestamp when cache was last updated */
-  cachedAt = 0;
-  constructor(walletAddress) {
-    this.walletAddress = walletAddress;
-    this.client = createPublicClient({
-      chain: base,
-      transport: http(void 0, {
-        timeout: 1e4
-        // 10 second timeout to prevent hanging on slow RPC
-      })
-    });
-  }
-  /**
-   * Check current USDC balance.
-   * Uses cache if valid, otherwise fetches from RPC.
-   */
-  async checkBalance() {
-    const now = Date.now();
-    if (this.cachedBalance !== null && this.cachedBalance > 0n && now - this.cachedAt < CACHE_TTL_MS) {
-      return this.buildInfo(this.cachedBalance);
-    }
-    const balance = await this.fetchBalance();
-    if (balance > 0n) {
-      this.cachedBalance = balance;
-      this.cachedAt = now;
-    }
-    return this.buildInfo(balance);
-  }
-  /**
-   * Check if balance is sufficient for an estimated cost.
-   *
-   * @param estimatedCostMicros - Estimated cost in USDC smallest unit (6 decimals)
-   */
-  async checkSufficient(estimatedCostMicros) {
-    const info = await this.checkBalance();
-    if (info.balance >= estimatedCostMicros) {
-      return { sufficient: true, info };
-    }
-    const shortfall = estimatedCostMicros - info.balance;
-    return {
-      sufficient: false,
-      info,
-      shortfall: this.formatUSDC(shortfall)
-    };
-  }
-  /**
-   * Optimistically deduct estimated cost from cached balance.
-   * Call this after a successful payment to keep cache accurate.
-   *
-   * @param amountMicros - Amount to deduct in USDC smallest unit
-   */
-  deductEstimated(amountMicros) {
-    if (this.cachedBalance !== null && this.cachedBalance >= amountMicros) {
-      this.cachedBalance -= amountMicros;
-    }
-  }
-  /**
-   * Invalidate cache, forcing next checkBalance() to fetch from RPC.
-   * Call this after a payment failure to get accurate balance.
-   */
-  invalidate() {
-    this.cachedBalance = null;
-    this.cachedAt = 0;
-  }
-  /**
-   * Force refresh balance from RPC (ignores cache).
-   */
-  async refresh() {
-    this.invalidate();
-    return this.checkBalance();
-  }
-  /**
-   * Format USDC amount (in micros) as "$X.XX".
-   */
-  formatUSDC(amountMicros) {
-    const dollars = Number(amountMicros) / 1e6;
-    return `$${dollars.toFixed(2)}`;
-  }
-  /**
-   * Get the wallet address being monitored.
-   */
-  getWalletAddress() {
-    return this.walletAddress;
-  }
-  /** Fetch balance from RPC */
-  async fetchBalance() {
-    try {
-      const balance = await this.client.readContract({
-        address: USDC_BASE,
-        abi: erc20Abi,
-        functionName: "balanceOf",
-        args: [this.walletAddress]
-      });
-      return balance;
-    } catch (error) {
-      throw new RpcError(error instanceof Error ? error.message : "Unknown error", error);
-    }
-  }
-  /** Build BalanceInfo from raw balance */
-  buildInfo(balance) {
-    return {
-      balance,
-      balanceUSD: this.formatUSDC(balance),
-      isLow: balance < BALANCE_THRESHOLDS.LOW_BALANCE_MICROS,
-      isEmpty: balance < BALANCE_THRESHOLDS.ZERO_THRESHOLD,
-      walletAddress: this.walletAddress
-    };
-  }
-};
-
-// src/solana-balance.ts
-import { address as solAddress, createSolanaRpc } from "@solana/kit";
-var SOLANA_USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
-var SOLANA_DEFAULT_RPC = "https://api.mainnet-beta.solana.com";
-var BALANCE_TIMEOUT_MS = 1e4;
-var CACHE_TTL_MS2 = 3e4;
-var SolanaBalanceMonitor = class {
-  rpc;
-  walletAddress;
-  cachedBalance = null;
-  cachedAt = 0;
-  constructor(walletAddress, rpcUrl) {
-    this.walletAddress = walletAddress;
-    const url = rpcUrl || process["env"].CLAWROUTER_SOLANA_RPC_URL || SOLANA_DEFAULT_RPC;
-    this.rpc = createSolanaRpc(url);
-  }
-  async checkBalance() {
-    const now = Date.now();
-    if (this.cachedBalance !== null && this.cachedBalance > 0n && now - this.cachedAt < CACHE_TTL_MS2) {
-      return this.buildInfo(this.cachedBalance);
-    }
-    const balance = await this.fetchBalance();
-    if (balance > 0n) {
-      this.cachedBalance = balance;
-      this.cachedAt = now;
-    }
-    return this.buildInfo(balance);
-  }
-  deductEstimated(amountMicros) {
-    if (this.cachedBalance !== null && this.cachedBalance >= amountMicros) {
-      this.cachedBalance -= amountMicros;
-    }
-  }
-  invalidate() {
-    this.cachedBalance = null;
-    this.cachedAt = 0;
-  }
-  async refresh() {
-    this.invalidate();
-    return this.checkBalance();
-  }
-  /**
-   * Check if balance is sufficient for an estimated cost.
-   */
-  async checkSufficient(estimatedCostMicros) {
-    const info = await this.checkBalance();
-    if (info.balance >= estimatedCostMicros) {
-      return { sufficient: true, info };
+        const preAuthRequest = request.clone();
+        for (const [key, value] of Object.entries(headers)) {
+          preAuthRequest.headers.set(key, value);
+        }
+        const response2 = await baseFetch(preAuthRequest);
+        if (response2.status !== 402) {
+          return response2;
+        }
+        cache.delete(urlPath);
+      } catch {
+        cache.delete(urlPath);
+      }
     }
-    const shortfall = estimatedCostMicros - info.balance;
-    return {
-      sufficient: false,
-      info,
-      shortfall: this.formatUSDC(shortfall)
-    };
-  }
-  /**
-   * Format USDC amount (in micros) as "$X.XX".
-   */
-  formatUSDC(amountMicros) {
-    const dollars = Number(amountMicros) / 1e6;
-    return `$${dollars.toFixed(2)}`;
-  }
-  getWalletAddress() {
-    return this.walletAddress;
-  }
-  async fetchBalance() {
-    const owner = solAddress(this.walletAddress);
-    const mint = solAddress(SOLANA_USDC_MINT);
-    for (let attempt = 0; attempt < 2; attempt++) {
-      const result = await this.fetchBalanceOnce(owner, mint);
-      if (result > 0n || attempt === 1) return result;
-      await new Promise((r) => setTimeout(r, 1e3));
+    const clonedRequest = request.clone();
+    const response = await baseFetch(request);
+    if (response.status !== 402) {
+      return response;
     }
-    return 0n;
-  }
-  async fetchBalanceOnce(owner, mint) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), BALANCE_TIMEOUT_MS);
+    let paymentRequired;
     try {
-      const response = await this.rpc.getTokenAccountsByOwner(owner, { mint }, { encoding: "jsonParsed" }).send({ abortSignal: controller.signal });
-      if (response.value.length === 0) return 0n;
-      let total = 0n;
-      for (const account of response.value) {
-        const parsed = account.account.data;
-        total += BigInt(parsed.parsed.info.tokenAmount.amount);
+      const getHeader = (name) => response.headers.get(name);
+      let body;
+      try {
+        const responseText = await Promise.race([
+          response.text(),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("Body read timeout")), 3e4)
+          )
+        ]);
+        if (responseText) body = JSON.parse(responseText);
+      } catch {
       }
-      return total;
-    } catch (err) {
+      paymentRequired = httpClient.getPaymentRequiredResponse(getHeader, body);
+      cache.set(urlPath, { paymentRequired, cachedAt: Date.now() });
+    } catch (error) {
       throw new Error(
-        `Failed to fetch Solana USDC balance: ${err instanceof Error ? err.message : String(err)}`,
-        { cause: err }
+        `Failed to parse payment requirements: ${error instanceof Error ? error.message : "Unknown error"}`,
+        { cause: error }
       );
-    } finally {
-      clearTimeout(timer);
     }
-  }
-  buildInfo(balance) {
-    const dollars = Number(balance) / 1e6;
-    return {
-      balance,
-      balanceUSD: `$${dollars.toFixed(2)}`,
-      isLow: balance < 1000000n,
-      isEmpty: balance < 100n,
-      walletAddress: this.walletAddress
-    };
-  }
-};
+    const payload = await client.createPaymentPayload(paymentRequired);
+    const paymentHeaders = httpClient.encodePaymentSignatureHeader(payload);
+    for (const [key, value] of Object.entries(paymentHeaders)) {
+      clonedRequest.headers.set(key, value);
+    }
+    return baseFetch(clonedRequest);
+  };
+}
+
+// src/proxy.ts
+import { registerExactEvmScheme } from "@x402/evm/exact/client";
 
 // src/stats.ts
 import { readdir, unlink } from "fs/promises";
@@ -791,86 +906,819 @@ function formatStatsAscii(stats) {
   } else {
     lines.push(savingsLine.padEnd(61) + "\u2551");
   }
-  lines.push(`\u2551  Avg Latency: ${stats.avgLatencyMs.toFixed(0)}ms`.padEnd(61) + "\u2551");
-  lines.push("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
-  lines.push("\u2551  Routing by Tier:                                          \u2551");
-  const knownTiers = ["SIMPLE", "MEDIUM", "COMPLEX", "REASONING", "DIRECT"];
-  const allTiers = Object.keys(stats.byTier);
-  const otherTiers = allTiers.filter((t) => !knownTiers.includes(t));
-  const tierOrder = [...knownTiers.filter((t) => stats.byTier[t]), ...otherTiers];
-  for (const tier of tierOrder) {
-    const data = stats.byTier[tier];
-    if (data) {
-      const bar = "\u2588".repeat(Math.min(20, Math.round(data.percentage / 5)));
-      const displayTier = tier === "UNKNOWN" ? "OTHER" : tier;
-      const line = `\u2551    ${displayTier.padEnd(10)} ${bar.padEnd(20)} ${data.percentage.toFixed(1).padStart(5)}% (${data.count})`;
-      lines.push(line.padEnd(61) + "\u2551");
+  lines.push(`\u2551  Avg Latency: ${stats.avgLatencyMs.toFixed(0)}ms`.padEnd(61) + "\u2551");
+  lines.push("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
+  lines.push("\u2551  Routing by Tier:                                          \u2551");
+  const knownTiers = ["SIMPLE", "MEDIUM", "COMPLEX", "REASONING", "DIRECT"];
+  const allTiers = Object.keys(stats.byTier);
+  const otherTiers = allTiers.filter((t) => !knownTiers.includes(t));
+  const tierOrder = [...knownTiers.filter((t) => stats.byTier[t]), ...otherTiers];
+  for (const tier of tierOrder) {
+    const data = stats.byTier[tier];
+    if (data) {
+      const bar = "\u2588".repeat(Math.min(20, Math.round(data.percentage / 5)));
+      const displayTier = tier === "UNKNOWN" ? "OTHER" : tier;
+      const line = `\u2551    ${displayTier.padEnd(10)} ${bar.padEnd(20)} ${data.percentage.toFixed(1).padStart(5)}% (${data.count})`;
+      lines.push(line.padEnd(61) + "\u2551");
+    }
+  }
+  lines.push("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
+  lines.push("\u2551  Top Models:                                               \u2551");
+  const sortedModels = Object.entries(stats.byModel).sort((a, b) => b[1].count - a[1].count).slice(0, 5);
+  for (const [model, data] of sortedModels) {
+    const shortModel = model.length > 25 ? model.slice(0, 22) + "..." : model;
+    const line = `\u2551    ${shortModel.padEnd(25)} ${data.count.toString().padStart(5)} reqs  $${data.cost.toFixed(4)}`;
+    lines.push(line.padEnd(61) + "\u2551");
+  }
+  if (stats.dailyBreakdown.length > 0) {
+    lines.push("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
+    lines.push("\u2551  Daily Breakdown:                                          \u2551");
+    lines.push("\u2551    Date        Requests    Cost      Saved                 \u2551");
+    for (const day of stats.dailyBreakdown.slice(-7)) {
+      const saved = day.totalBaselineCost - day.totalCost;
+      const line = `\u2551    ${day.date}   ${day.totalRequests.toString().padStart(6)}    $${day.totalCost.toFixed(4).padStart(8)}  $${saved.toFixed(4)}`;
+      lines.push(line.padEnd(61) + "\u2551");
+    }
+  }
+  lines.push("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+  return lines.join("\n");
+}
+async function clearStats() {
+  try {
+    const files = await readdir(LOG_DIR);
+    const logFiles = files.filter((f) => f.startsWith("usage-") && f.endsWith(".jsonl"));
+    await Promise.all(logFiles.map((f) => unlink(join2(LOG_DIR, f))));
+    return { deletedFiles: logFiles.length };
+  } catch {
+    return { deletedFiles: 0 };
+  }
+}
+
+// src/logger.ts
+import { appendFile, mkdir } from "fs/promises";
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+var LOG_DIR2 = join3(homedir2(), ".openclaw", "ckcloud", "logs");
+var dirReady = false;
+async function ensureDir() {
+  if (dirReady) return;
+  await mkdir(LOG_DIR2, { recursive: true });
+  dirReady = true;
+}
+async function logUsage(entry) {
+  try {
+    await ensureDir();
+    const date = entry.timestamp.slice(0, 10);
+    const file = join3(LOG_DIR2, `usage-${date}.jsonl`);
+    await appendFile(file, JSON.stringify(entry) + "\n");
+  } catch {
+  }
+}
+
+// src/compression/types.ts
+var DEFAULT_COMPRESSION_CONFIG = {
+  enabled: true,
+  preserveRaw: true,
+  layers: {
+    deduplication: true,
+    // Safe: removes duplicate messages
+    whitespace: true,
+    // Safe: normalizes whitespace
+    dictionary: false,
+    // DISABLED: requires model to understand codebook
+    paths: false,
+    // DISABLED: requires model to understand path codes
+    jsonCompact: true,
+    // Safe: just removes JSON whitespace
+    observation: false,
+    // DISABLED: may lose important context
+    dynamicCodebook: false
+    // DISABLED: requires model to understand codes
+  },
+  dictionary: {
+    maxEntries: 50,
+    minPhraseLength: 15,
+    includeCodebookHeader: false
+    // No codebook header needed
+  }
+};
+
+// src/compression/layers/deduplication.ts
+import crypto from "crypto";
+function hashMessage(message) {
+  let contentStr = "";
+  if (typeof message.content === "string") {
+    contentStr = message.content;
+  } else if (Array.isArray(message.content)) {
+    contentStr = JSON.stringify(message.content);
+  }
+  const parts = [message.role, contentStr, message.tool_call_id || "", message.name || ""];
+  if (message.tool_calls) {
+    parts.push(
+      JSON.stringify(
+        message.tool_calls.map((tc) => ({
+          name: tc.function.name,
+          args: tc.function.arguments
+        }))
+      )
+    );
+  }
+  const content = parts.join("|");
+  return crypto.createHash("md5").update(content).digest("hex");
+}
+function deduplicateMessages(messages) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  let duplicatesRemoved = 0;
+  const referencedToolCallIds = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    if (message.role === "tool" && message.tool_call_id) {
+      referencedToolCallIds.add(message.tool_call_id);
+    }
+  }
+  for (const message of messages) {
+    if (message.role === "system") {
+      result.push(message);
+      continue;
+    }
+    if (message.role === "user") {
+      result.push(message);
+      continue;
+    }
+    if (message.role === "tool") {
+      result.push(message);
+      continue;
+    }
+    if (message.role === "assistant" && message.tool_calls) {
+      const hasReferencedToolCall = message.tool_calls.some(
+        (tc) => referencedToolCallIds.has(tc.id)
+      );
+      if (hasReferencedToolCall) {
+        result.push(message);
+        continue;
+      }
+    }
+    const hash = hashMessage(message);
+    if (!seen.has(hash)) {
+      seen.add(hash);
+      result.push(message);
+    } else {
+      duplicatesRemoved++;
+    }
+  }
+  return {
+    messages: result,
+    duplicatesRemoved,
+    originalCount: messages.length
+  };
+}
+
+// src/compression/layers/whitespace.ts
+function normalizeWhitespace(content) {
+  if (!content || typeof content !== "string") return content;
+  return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n{3,}/g, "\n\n").replace(/[ \t]+$/gm, "").replace(/([^\n]) {2,}/g, "$1 ").replace(/^[ ]{8,}/gm, (match) => "  ".repeat(Math.ceil(match.length / 4))).replace(/\t/g, "  ").trim();
+}
+function normalizeMessagesWhitespace(messages) {
+  let charsSaved = 0;
+  const result = messages.map((message) => {
+    if (!message.content || typeof message.content !== "string") return message;
+    const originalLength = message.content.length;
+    const normalizedContent = normalizeWhitespace(message.content);
+    charsSaved += originalLength - normalizedContent.length;
+    return {
+      ...message,
+      content: normalizedContent
+    };
+  });
+  return {
+    messages: result,
+    charsSaved
+  };
+}
+
+// src/compression/codebook.ts
+var STATIC_CODEBOOK = {
+  // High-impact: OpenClaw/Agent system prompt patterns (very common)
+  $OC01: "unbrowse_",
+  // Common prefix in tool names
+  $OC02: "<location>",
+  $OC03: "</location>",
+  $OC04: "<name>",
+  $OC05: "</name>",
+  $OC06: "<description>",
+  $OC07: "</description>",
+  $OC08: "(may need login)",
+  $OC09: "API skill for OpenClaw",
+  $OC10: "endpoints",
+  // Skill/tool markers
+  $SK01: "<available_skills>",
+  $SK02: "</available_skills>",
+  $SK03: "<skill>",
+  $SK04: "</skill>",
+  // Schema patterns (very common in tool definitions)
+  $T01: 'type: "function"',
+  $T02: '"type": "function"',
+  $T03: '"type": "string"',
+  $T04: '"type": "object"',
+  $T05: '"type": "array"',
+  $T06: '"type": "boolean"',
+  $T07: '"type": "number"',
+  // Common descriptions
+  $D01: "description:",
+  $D02: '"description":',
+  // Common instructions
+  $I01: "You are a personal assistant",
+  $I02: "Tool names are case-sensitive",
+  $I03: "Call tools exactly as listed",
+  $I04: "Use when",
+  $I05: "without asking",
+  // Safety phrases
+  $S01: "Do not manipulate or persuade",
+  $S02: "Prioritize safety and human oversight",
+  $S03: "unless explicitly requested",
+  // JSON patterns
+  $J01: '"required": ["',
+  $J02: '"properties": {',
+  $J03: '"additionalProperties": false',
+  // Heartbeat patterns
+  $H01: "HEARTBEAT_OK",
+  $H02: "Read HEARTBEAT.md if it exists",
+  // Role markers
+  $R01: '"role": "system"',
+  $R02: '"role": "user"',
+  $R03: '"role": "assistant"',
+  $R04: '"role": "tool"',
+  // Common endings/phrases
+  $E01: "would you like to",
+  $E02: "Let me know if you",
+  $E03: "internal APIs",
+  $E04: "session cookies",
+  // ckcloud model aliases (common in prompts)
+  $M01: "ckcloud/",
+  $M02: "openai/",
+  $M03: "anthropic/",
+  $M04: "google/",
+  $M05: "xai/"
+};
+function getInverseCodebook() {
+  const inverse = {};
+  for (const [code, phrase] of Object.entries(STATIC_CODEBOOK)) {
+    inverse[phrase] = code;
+  }
+  return inverse;
+}
+function generateCodebookHeader(usedCodes, pathMap = {}) {
+  if (usedCodes.size === 0 && Object.keys(pathMap).length === 0) {
+    return "";
+  }
+  const parts = [];
+  if (usedCodes.size > 0) {
+    const codeEntries = Array.from(usedCodes).map((code) => `${code}=${STATIC_CODEBOOK[code]}`).join(", ");
+    parts.push(`[Dict: ${codeEntries}]`);
+  }
+  if (Object.keys(pathMap).length > 0) {
+    const pathEntries = Object.entries(pathMap).map(([code, path]) => `${code}=${path}`).join(", ");
+    parts.push(`[Paths: ${pathEntries}]`);
+  }
+  return parts.join("\n");
+}
+
+// src/compression/layers/dictionary.ts
+function encodeContent(content, inverseCodebook) {
+  if (!content || typeof content !== "string") {
+    return { encoded: content, substitutions: 0, codes: /* @__PURE__ */ new Set(), charsSaved: 0 };
+  }
+  let encoded = content;
+  let substitutions = 0;
+  let charsSaved = 0;
+  const codes = /* @__PURE__ */ new Set();
+  const phrases = Object.keys(inverseCodebook).sort((a, b) => b.length - a.length);
+  for (const phrase of phrases) {
+    const code = inverseCodebook[phrase];
+    const regex = new RegExp(escapeRegex(phrase), "g");
+    const matches = encoded.match(regex);
+    if (matches && matches.length > 0) {
+      encoded = encoded.replace(regex, code);
+      substitutions += matches.length;
+      charsSaved += matches.length * (phrase.length - code.length);
+      codes.add(code);
+    }
+  }
+  return { encoded, substitutions, codes, charsSaved };
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function encodeMessages(messages) {
+  const inverseCodebook = getInverseCodebook();
+  let totalSubstitutions = 0;
+  let totalCharsSaved = 0;
+  const allUsedCodes = /* @__PURE__ */ new Set();
+  const result = messages.map((message) => {
+    if (!message.content || typeof message.content !== "string") return message;
+    const { encoded, substitutions, codes, charsSaved } = encodeContent(
+      message.content,
+      inverseCodebook
+    );
+    totalSubstitutions += substitutions;
+    totalCharsSaved += charsSaved;
+    codes.forEach((code) => allUsedCodes.add(code));
+    return {
+      ...message,
+      content: encoded
+    };
+  });
+  return {
+    messages: result,
+    substitutionCount: totalSubstitutions,
+    usedCodes: allUsedCodes,
+    charsSaved: totalCharsSaved
+  };
+}
+
+// src/compression/layers/paths.ts
+var PATH_REGEX = /(?:\/[\w.-]+){3,}/g;
+function extractPaths(messages) {
+  const paths = [];
+  for (const message of messages) {
+    if (!message.content || typeof message.content !== "string") continue;
+    const matches = message.content.match(PATH_REGEX);
+    if (matches) {
+      paths.push(...matches);
+    }
+  }
+  return paths;
+}
+function findFrequentPrefixes(paths) {
+  const prefixCounts = /* @__PURE__ */ new Map();
+  for (const path of paths) {
+    const parts = path.split("/").filter(Boolean);
+    for (let i = 2; i < parts.length; i++) {
+      const prefix = "/" + parts.slice(0, i).join("/") + "/";
+      prefixCounts.set(prefix, (prefixCounts.get(prefix) || 0) + 1);
+    }
+  }
+  return Array.from(prefixCounts.entries()).filter(([, count]) => count >= 3).sort((a, b) => b[0].length - a[0].length).slice(0, 5).map(([prefix]) => prefix);
+}
+function shortenPaths(messages) {
+  const allPaths = extractPaths(messages);
+  if (allPaths.length < 5) {
+    return {
+      messages,
+      pathMap: {},
+      charsSaved: 0
+    };
+  }
+  const prefixes = findFrequentPrefixes(allPaths);
+  if (prefixes.length === 0) {
+    return {
+      messages,
+      pathMap: {},
+      charsSaved: 0
+    };
+  }
+  const pathMap = {};
+  prefixes.forEach((prefix, i) => {
+    pathMap[`$P${i + 1}`] = prefix;
+  });
+  let charsSaved = 0;
+  const result = messages.map((message) => {
+    if (!message.content || typeof message.content !== "string") return message;
+    let content = message.content;
+    const originalLength = content.length;
+    for (const [code, prefix] of Object.entries(pathMap)) {
+      content = content.split(prefix).join(code + "/");
+    }
+    charsSaved += originalLength - content.length;
+    return {
+      ...message,
+      content
+    };
+  });
+  return {
+    messages: result,
+    pathMap,
+    charsSaved
+  };
+}
+
+// src/compression/layers/json-compact.ts
+function compactJson(jsonString) {
+  try {
+    const parsed = JSON.parse(jsonString);
+    return JSON.stringify(parsed);
+  } catch {
+    return jsonString;
+  }
+}
+function looksLikeJson(str) {
+  const trimmed = str.trim();
+  return trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]");
+}
+function compactToolCalls(toolCalls) {
+  return toolCalls.map((tc) => ({
+    ...tc,
+    function: {
+      ...tc.function,
+      arguments: compactJson(tc.function.arguments)
+    }
+  }));
+}
+function compactMessagesJson(messages) {
+  let charsSaved = 0;
+  const result = messages.map((message) => {
+    const newMessage = { ...message };
+    if (message.tool_calls && message.tool_calls.length > 0) {
+      const originalLength = JSON.stringify(message.tool_calls).length;
+      newMessage.tool_calls = compactToolCalls(message.tool_calls);
+      const newLength = JSON.stringify(newMessage.tool_calls).length;
+      charsSaved += originalLength - newLength;
+    }
+    if (message.role === "tool" && message.content && typeof message.content === "string" && looksLikeJson(message.content)) {
+      const originalLength = message.content.length;
+      const compacted = compactJson(message.content);
+      charsSaved += originalLength - compacted.length;
+      newMessage.content = compacted;
+    }
+    return newMessage;
+  });
+  return {
+    messages: result,
+    charsSaved
+  };
+}
+
+// src/compression/layers/observation.ts
+var TOOL_RESULT_THRESHOLD = 500;
+var COMPRESSED_RESULT_MAX = 300;
+function compressToolResult(content) {
+  if (!content || content.length <= TOOL_RESULT_THRESHOLD) {
+    return content;
+  }
+  const lines = content.split("\n").map((l) => l.trim()).filter(Boolean);
+  const errorLines = lines.filter(
+    (l) => /error|exception|failed|denied|refused|timeout|invalid/i.test(l) && l.length < 200
+  );
+  const statusLines = lines.filter(
+    (l) => /success|complete|created|updated|found|result|status|total|count/i.test(l) && l.length < 150
+  );
+  const jsonMatches = [];
+  const jsonPattern = /"(id|name|status|error|message|count|total|url|path)":\s*"?([^",}\n]+)"?/gi;
+  let match;
+  while ((match = jsonPattern.exec(content)) !== null) {
+    jsonMatches.push(`${match[1]}: ${match[2].slice(0, 50)}`);
+  }
+  const firstLine = lines[0]?.slice(0, 100);
+  const lastLine = lines.length > 1 ? lines[lines.length - 1]?.slice(0, 100) : "";
+  const parts = [];
+  if (errorLines.length > 0) {
+    parts.push("[ERR] " + errorLines.slice(0, 3).join(" | "));
+  }
+  if (statusLines.length > 0) {
+    parts.push(statusLines.slice(0, 3).join(" | "));
+  }
+  if (jsonMatches.length > 0) {
+    parts.push(jsonMatches.slice(0, 5).join(", "));
+  }
+  if (parts.length === 0) {
+    parts.push(firstLine || "");
+    if (lines.length > 2) {
+      parts.push(`[...${lines.length - 2} lines...]`);
+    }
+    if (lastLine && lastLine !== firstLine) {
+      parts.push(lastLine);
     }
   }
-  lines.push("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
-  lines.push("\u2551  Top Models:                                               \u2551");
-  const sortedModels = Object.entries(stats.byModel).sort((a, b) => b[1].count - a[1].count).slice(0, 5);
-  for (const [model, data] of sortedModels) {
-    const shortModel = model.length > 25 ? model.slice(0, 22) + "..." : model;
-    const line = `\u2551    ${shortModel.padEnd(25)} ${data.count.toString().padStart(5)} reqs  $${data.cost.toFixed(4)}`;
-    lines.push(line.padEnd(61) + "\u2551");
+  let result = parts.join("\n");
+  if (result.length > COMPRESSED_RESULT_MAX) {
+    result = result.slice(0, COMPRESSED_RESULT_MAX - 20) + "\n[...truncated]";
   }
-  if (stats.dailyBreakdown.length > 0) {
-    lines.push("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
-    lines.push("\u2551  Daily Breakdown:                                          \u2551");
-    lines.push("\u2551    Date        Requests    Cost      Saved                 \u2551");
-    for (const day of stats.dailyBreakdown.slice(-7)) {
-      const saved = day.totalBaselineCost - day.totalCost;
-      const line = `\u2551    ${day.date}   ${day.totalRequests.toString().padStart(6)}    $${day.totalCost.toFixed(4).padStart(8)}  $${saved.toFixed(4)}`;
-      lines.push(line.padEnd(61) + "\u2551");
+  return result;
+}
+function deduplicateLargeBlocks(messages) {
+  const blockHashes = /* @__PURE__ */ new Map();
+  let charsSaved = 0;
+  const result = messages.map((msg, idx) => {
+    if (!msg.content || typeof msg.content !== "string" || msg.content.length < 500) {
+      return msg;
+    }
+    const blockKey = msg.content.slice(0, 200);
+    if (blockHashes.has(blockKey)) {
+      const firstIdx = blockHashes.get(blockKey);
+      const original = msg.content;
+      const compressed = `[See message #${firstIdx + 1} - same content]`;
+      charsSaved += original.length - compressed.length;
+      return { ...msg, content: compressed };
+    }
+    blockHashes.set(blockKey, idx);
+    return msg;
+  });
+  return { messages: result, charsSaved };
+}
+function compressObservations(messages) {
+  let charsSaved = 0;
+  let observationsCompressed = 0;
+  let result = messages.map((msg) => {
+    if (msg.role !== "tool" || !msg.content || typeof msg.content !== "string") {
+      return msg;
+    }
+    const original = msg.content;
+    if (original.length <= TOOL_RESULT_THRESHOLD) {
+      return msg;
+    }
+    const compressed = compressToolResult(original);
+    const saved = original.length - compressed.length;
+    if (saved > 50) {
+      charsSaved += saved;
+      observationsCompressed++;
+      return { ...msg, content: compressed };
+    }
+    return msg;
+  });
+  const dedupResult = deduplicateLargeBlocks(result);
+  result = dedupResult.messages;
+  charsSaved += dedupResult.charsSaved;
+  return {
+    messages: result,
+    charsSaved,
+    observationsCompressed
+  };
+}
+
+// src/compression/layers/dynamic-codebook.ts
+var MIN_PHRASE_LENGTH = 20;
+var MAX_PHRASE_LENGTH = 200;
+var MIN_FREQUENCY = 3;
+var MAX_ENTRIES = 100;
+var CODE_PREFIX = "$D";
+function findRepeatedPhrases(allContent) {
+  const phrases = /* @__PURE__ */ new Map();
+  const segments = allContent.split(/(?<=[.!?\n])\s+/);
+  for (const segment of segments) {
+    const trimmed = segment.trim();
+    if (trimmed.length >= MIN_PHRASE_LENGTH && trimmed.length <= MAX_PHRASE_LENGTH) {
+      phrases.set(trimmed, (phrases.get(trimmed) || 0) + 1);
+    }
+  }
+  const lines = allContent.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.length >= MIN_PHRASE_LENGTH && trimmed.length <= MAX_PHRASE_LENGTH) {
+      phrases.set(trimmed, (phrases.get(trimmed) || 0) + 1);
     }
   }
-  lines.push("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
-  return lines.join("\n");
+  return phrases;
 }
-async function clearStats() {
-  try {
-    const files = await readdir(LOG_DIR);
-    const logFiles = files.filter((f) => f.startsWith("usage-") && f.endsWith(".jsonl"));
-    await Promise.all(logFiles.map((f) => unlink(join2(LOG_DIR, f))));
-    return { deletedFiles: logFiles.length };
-  } catch {
-    return { deletedFiles: 0 };
+function buildDynamicCodebook(messages) {
+  let allContent = "";
+  for (const msg of messages) {
+    if (msg.content && typeof msg.content === "string") {
+      allContent += msg.content + "\n";
+    }
+  }
+  const phrases = findRepeatedPhrases(allContent);
+  const candidates = [];
+  for (const [phrase, count] of phrases.entries()) {
+    if (count >= MIN_FREQUENCY) {
+      const codeLength = 4;
+      const savings = (phrase.length - codeLength) * count;
+      if (savings > 50) {
+        candidates.push({ phrase, count, savings });
+      }
+    }
   }
+  candidates.sort((a, b) => b.savings - a.savings);
+  const topCandidates = candidates.slice(0, MAX_ENTRIES);
+  const codebook = {};
+  topCandidates.forEach((c, i) => {
+    const code = `${CODE_PREFIX}${String(i + 1).padStart(2, "0")}`;
+    codebook[code] = c.phrase;
+  });
+  return codebook;
 }
-
-// src/logger.ts
-import { appendFile, mkdir } from "fs/promises";
-import { join as join3 } from "path";
-import { homedir as homedir2 } from "os";
-var LOG_DIR2 = join3(homedir2(), ".openclaw", "ckcloud", "logs");
-var dirReady = false;
-async function ensureDir() {
-  if (dirReady) return;
-  await mkdir(LOG_DIR2, { recursive: true });
-  dirReady = true;
+function escapeRegex2(str) {
+  if (!str || typeof str !== "string") return "";
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-async function logUsage(entry) {
-  try {
-    await ensureDir();
-    const date = entry.timestamp.slice(0, 10);
-    const file = join3(LOG_DIR2, `usage-${date}.jsonl`);
-    await appendFile(file, JSON.stringify(entry) + "\n");
-  } catch {
+function applyDynamicCodebook(messages) {
+  const codebook = buildDynamicCodebook(messages);
+  if (Object.keys(codebook).length === 0) {
+    return {
+      messages,
+      charsSaved: 0,
+      dynamicCodes: {},
+      substitutions: 0
+    };
   }
+  const phraseToCode = {};
+  for (const [code, phrase] of Object.entries(codebook)) {
+    phraseToCode[phrase] = code;
+  }
+  const sortedPhrases = Object.keys(phraseToCode).sort((a, b) => b.length - a.length);
+  let charsSaved = 0;
+  let substitutions = 0;
+  const result = messages.map((msg) => {
+    if (!msg.content || typeof msg.content !== "string") return msg;
+    let content = msg.content;
+    for (const phrase of sortedPhrases) {
+      const code = phraseToCode[phrase];
+      const regex = new RegExp(escapeRegex2(phrase), "g");
+      const matches = content.match(regex);
+      if (matches) {
+        content = content.replace(regex, code);
+        charsSaved += (phrase.length - code.length) * matches.length;
+        substitutions += matches.length;
+      }
+    }
+    return { ...msg, content };
+  });
+  return {
+    messages: result,
+    charsSaved,
+    dynamicCodes: codebook,
+    substitutions
+  };
+}
+function generateDynamicCodebookHeader(codebook) {
+  if (Object.keys(codebook).length === 0) return "";
+  const entries = Object.entries(codebook).slice(0, 20).map(([code, phrase]) => {
+    const displayPhrase = phrase.length > 40 ? phrase.slice(0, 37) + "..." : phrase;
+    return `${code}=${displayPhrase}`;
+  }).join(", ");
+  return `[DynDict: ${entries}]`;
 }
 
-// src/plugin-logger.ts
-var pluginLogger = console;
-function setPluginLogger(logger2) {
-  pluginLogger = logger2 ?? console;
+// src/compression/index.ts
+function calculateTotalChars(messages) {
+  return messages.reduce((total, msg) => {
+    let chars = 0;
+    if (typeof msg.content === "string") {
+      chars = msg.content.length;
+    } else if (Array.isArray(msg.content)) {
+      chars = JSON.stringify(msg.content).length;
+    }
+    if (msg.tool_calls) {
+      chars += JSON.stringify(msg.tool_calls).length;
+    }
+    return total + chars;
+  }, 0);
+}
+function cloneMessages(messages) {
+  return JSON.parse(JSON.stringify(messages));
+}
+function prependCodebookHeader(messages, usedCodes, pathMap) {
+  const header = generateCodebookHeader(usedCodes, pathMap);
+  if (!header) return messages;
+  const userIndex = messages.findIndex((m) => m.role === "user");
+  if (userIndex === -1) {
+    return [{ role: "system", content: header }, ...messages];
+  }
+  return messages.map((msg, i) => {
+    if (i === userIndex) {
+      if (typeof msg.content === "string") {
+        return {
+          ...msg,
+          content: `${header}
+
+${msg.content}`
+        };
+      }
+    }
+    return msg;
+  });
+}
+async function compressContext(messages, config = {}) {
+  const fullConfig = {
+    ...DEFAULT_COMPRESSION_CONFIG,
+    ...config,
+    layers: {
+      ...DEFAULT_COMPRESSION_CONFIG.layers,
+      ...config.layers
+    },
+    dictionary: {
+      ...DEFAULT_COMPRESSION_CONFIG.dictionary,
+      ...config.dictionary
+    }
+  };
+  if (!fullConfig.enabled) {
+    const originalChars2 = calculateTotalChars(messages);
+    return {
+      messages,
+      originalMessages: messages,
+      originalChars: originalChars2,
+      compressedChars: originalChars2,
+      compressionRatio: 1,
+      stats: {
+        duplicatesRemoved: 0,
+        whitespaceSavedChars: 0,
+        dictionarySubstitutions: 0,
+        pathsShortened: 0,
+        jsonCompactedChars: 0,
+        observationsCompressed: 0,
+        observationCharsSaved: 0,
+        dynamicSubstitutions: 0,
+        dynamicCharsSaved: 0
+      },
+      codebook: {},
+      pathMap: {},
+      dynamicCodes: {}
+    };
+  }
+  const originalMessages = fullConfig.preserveRaw ? cloneMessages(messages) : messages;
+  const originalChars = calculateTotalChars(messages);
+  const stats = {
+    duplicatesRemoved: 0,
+    whitespaceSavedChars: 0,
+    dictionarySubstitutions: 0,
+    pathsShortened: 0,
+    jsonCompactedChars: 0,
+    observationsCompressed: 0,
+    observationCharsSaved: 0,
+    dynamicSubstitutions: 0,
+    dynamicCharsSaved: 0
+  };
+  let result = cloneMessages(messages);
+  let usedCodes = /* @__PURE__ */ new Set();
+  let pathMap = {};
+  let dynamicCodes = {};
+  if (fullConfig.layers.deduplication) {
+    const dedupResult = deduplicateMessages(result);
+    result = dedupResult.messages;
+    stats.duplicatesRemoved = dedupResult.duplicatesRemoved;
+  }
+  if (fullConfig.layers.whitespace) {
+    const wsResult = normalizeMessagesWhitespace(result);
+    result = wsResult.messages;
+    stats.whitespaceSavedChars = wsResult.charsSaved;
+  }
+  if (fullConfig.layers.dictionary) {
+    const dictResult = encodeMessages(result);
+    result = dictResult.messages;
+    stats.dictionarySubstitutions = dictResult.substitutionCount;
+    usedCodes = dictResult.usedCodes;
+  }
+  if (fullConfig.layers.paths) {
+    const pathResult = shortenPaths(result);
+    result = pathResult.messages;
+    pathMap = pathResult.pathMap;
+    stats.pathsShortened = Object.keys(pathMap).length;
+  }
+  if (fullConfig.layers.jsonCompact) {
+    const jsonResult = compactMessagesJson(result);
+    result = jsonResult.messages;
+    stats.jsonCompactedChars = jsonResult.charsSaved;
+  }
+  if (fullConfig.layers.observation) {
+    const obsResult = compressObservations(result);
+    result = obsResult.messages;
+    stats.observationsCompressed = obsResult.observationsCompressed;
+    stats.observationCharsSaved = obsResult.charsSaved;
+  }
+  if (fullConfig.layers.dynamicCodebook) {
+    const dynResult = applyDynamicCodebook(result);
+    result = dynResult.messages;
+    stats.dynamicSubstitutions = dynResult.substitutions;
+    stats.dynamicCharsSaved = dynResult.charsSaved;
+    dynamicCodes = dynResult.dynamicCodes;
+  }
+  if (fullConfig.dictionary.includeCodebookHeader && (usedCodes.size > 0 || Object.keys(pathMap).length > 0 || Object.keys(dynamicCodes).length > 0)) {
+    result = prependCodebookHeader(result, usedCodes, pathMap);
+    if (Object.keys(dynamicCodes).length > 0) {
+      const dynHeader = generateDynamicCodebookHeader(dynamicCodes);
+      if (dynHeader) {
+        const systemIndex = result.findIndex((m) => m.role === "system");
+        if (systemIndex >= 0 && typeof result[systemIndex].content === "string") {
+          result[systemIndex] = {
+            ...result[systemIndex],
+            content: `${dynHeader}
+${result[systemIndex].content}`
+          };
+        }
+      }
+    }
+  }
+  const compressedChars = calculateTotalChars(result);
+  const compressionRatio = compressedChars / originalChars;
+  const usedCodebook = {};
+  usedCodes.forEach((code) => {
+    usedCodebook[code] = STATIC_CODEBOOK[code];
+  });
+  return {
+    messages: result,
+    originalMessages,
+    originalChars,
+    compressedChars,
+    compressionRatio,
+    stats,
+    codebook: usedCodebook,
+    pathMap,
+    dynamicCodes
+  };
+}
+function shouldCompress(messages) {
+  const chars = calculateTotalChars(messages);
+  return chars > 5e3;
 }
-var logger = {
-  debug: (message) => pluginLogger.debug?.(message),
-  info: (message) => pluginLogger.info(message),
-  warn: (message) => pluginLogger.warn(message),
-  error: (message) => pluginLogger.error(message)
-};
 
 // src/session.ts
 import { createHash } from "crypto";
@@ -4029,8 +4877,6 @@ var IMAGE_DIR = join5(homedir4(), ".openclaw", "ckcloud", "images");
 var AUTO_MODEL = "ckcloud/auto";
 var BALANCE_CHECK_BUFFER = 1.5;
 var ROUTING_PROFILES = /* @__PURE__ */ new Set([
-  "ckcloud/free",
-  "free",
   "ckcloud/eco",
   "eco",
   "ckcloud/auto",
@@ -4038,7 +4884,6 @@ var ROUTING_PROFILES = /* @__PURE__ */ new Set([
   "ckcloud/premium",
   "premium"
 ]);
-var FREE_MODEL = "kimi-k2";
 var MAX_MESSAGES = 200;
 var CONTEXT_LIMIT_KB = 5120;
 var HEARTBEAT_INTERVAL_MS = 2e3;
@@ -4605,7 +5450,7 @@ function transformPaymentError(errorBody) {
                 wallet,
                 current_balance_usd: currentUSD,
                 required_usd: requiredUSD,
-                help: `Fund wallet ${shortWallet} with USDC on Base, or use free model: /model free`
+                help: `Fund wallet ${shortWallet} with USDC on Base`
               }
             });
           }
@@ -4627,7 +5472,7 @@ function transformPaymentError(errorBody) {
             error: {
               message: "Solana payment simulation failed. Retrying with a different model.",
               type: "transaction_simulation_failed",
-              help: "This is usually temporary. If it persists, check your Solana USDC balance or try: /model free"
+              help: "This is usually temporary. If it persists, check your Solana USDC balance."
             }
           });
         }
@@ -4640,7 +5485,7 @@ function transformPaymentError(errorBody) {
         error: {
           message: gasError ? "Payment failed: network congestion or gas issue. Try again." : "Payment settlement failed. Try again in a moment.",
           type: "settlement_failed",
-          help: "This is usually temporary. If it persists, try: /model free"
+          help: "This is usually temporary. If it persists, try again later."
         }
       });
     }
@@ -4654,6 +5499,7 @@ async function startProxy(options) {
   setPluginLogger(options.logger ?? console);
   await initBaseModels();
   const paymentChain = options.paymentChain ?? await resolvePaymentChain();
+  logger.info(`paymentChain: ${paymentChain}`);
   const apiBase = options.apiBase ?? (paymentChain === "solana" && solanaPrivateKeyBytes ? CKCLOUD_SOLANA_API : CKCLOUD_API);
   if (paymentChain === "solana" && !solanaPrivateKeyBytes) {
     logger.warn(`[ckcloud] \u26A0 Payment chain is Solana but no mnemonic found \u2014 falling back to Base (EVM).`);
@@ -5152,7 +5998,7 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
         const estimatedTokens = Math.ceil(fullText.length / 4);
         const normalizedModel2 = typeof parsed.model === "string" ? parsed.model.trim().toLowerCase() : "";
         const profileName = normalizedModel2.replace("ckcloud/", "");
-        const debugProfile = ["free", "eco", "auto", "premium"].includes(profileName) ? profileName : "auto";
+        const debugProfile = ["eco", "auto", "premium"].includes(profileName) ? profileName : "auto";
         const scoring = classifyByRules(
           debugPrompt,
           systemPrompt,
@@ -5463,121 +6309,44 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
         modelId = resolvedModel;
       }
       if (isRoutingProfile) {
-        if (routingProfile === "free") {
-          const freeModel = "nvidia/gpt-oss-120b";
-          logger.info(`[ckcloud] Free profile - using ${freeModel} directly`);
-          parsed.model = freeModel;
-          modelId = freeModel;
-          bodyModified = true;
-          await logUsage({
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            model: freeModel,
-            tier: "SIMPLE",
-            cost: 0,
-            baselineCost: 0,
-            savings: 1,
-            // 100% savings
-            latencyMs: 0
-          });
-        } else {
-          effectiveSessionId = getSessionId(req.headers) ?? deriveSessionId(parsedMessages);
-          const existingSession = effectiveSessionId ? sessionStore.getSession(effectiveSessionId) : void 0;
-          const rawPrompt = lastUserMsg?.content;
-          const prompt = typeof rawPrompt === "string" ? rawPrompt : Array.isArray(rawPrompt) ? rawPrompt.filter((b) => b.type === "text").map((b) => b.text ?? "").join(" ") : "";
-          const systemMsg = parsedMessages.find((m) => m.role === "system");
-          const systemPrompt = typeof systemMsg?.content === "string" ? systemMsg.content : void 0;
-          const tools = parsed.tools;
-          hasTools = Array.isArray(tools) && tools.length > 0;
-          if (hasTools && tools) {
-            logger.info(`[ckcloud] Tools detected (${tools.length}), forcing agentic tiers`);
-          }
-          hasVision = parsedMessages.some((m) => {
-            if (Array.isArray(m.content)) {
-              return m.content.some((p) => p.type === "image_url");
-            }
-            return false;
-          });
-          if (hasVision) {
-            logger.info(`[ckcloud] Vision content detected, filtering to vision-capable models`);
+        effectiveSessionId = getSessionId(req.headers) ?? deriveSessionId(parsedMessages);
+        const existingSession = effectiveSessionId ? sessionStore.getSession(effectiveSessionId) : void 0;
+        const rawPrompt = lastUserMsg?.content;
+        const prompt = typeof rawPrompt === "string" ? rawPrompt : Array.isArray(rawPrompt) ? rawPrompt.filter((b) => b.type === "text").map((b) => b.text ?? "").join(" ") : "";
+        const systemMsg = parsedMessages.find((m) => m.role === "system");
+        const systemPrompt = typeof systemMsg?.content === "string" ? systemMsg.content : void 0;
+        const tools = parsed.tools;
+        hasTools = Array.isArray(tools) && tools.length > 0;
+        if (hasTools && tools) {
+          logger.info(`[ckcloud] Tools detected (${tools.length}), forcing agentic tiers`);
+        }
+        hasVision = parsedMessages.some((m) => {
+          if (Array.isArray(m.content)) {
+            return m.content.some((p) => p.type === "image_url");
           }
-          routingDecision = route(prompt, systemPrompt, maxTokens, {
-            ...routerOpts,
-            routingProfile: routingProfile ?? void 0,
-            hasTools
-          });
-          if (existingSession) {
-            const tierRank = {
-              SIMPLE: 0,
-              MEDIUM: 1,
-              COMPLEX: 2,
-              REASONING: 3
-            };
-            const existingRank = tierRank[existingSession.tier] ?? 0;
-            const newRank = tierRank[routingDecision.tier] ?? 0;
-            if (newRank > existingRank) {
-              logger.info(
-                `[ckcloud] Session ${effectiveSessionId?.slice(0, 8)}... upgrading: ${existingSession.tier} \u2192 ${routingDecision.tier} (${routingDecision.model})`
-              );
-              parsed.model = routingDecision.model;
-              modelId = routingDecision.model;
-              bodyModified = true;
-              if (effectiveSessionId) {
-                sessionStore.setSession(
-                  effectiveSessionId,
-                  routingDecision.model,
-                  routingDecision.tier
-                );
-              }
-            } else {
-              logger.info(
-                `[ckcloud] Session ${effectiveSessionId?.slice(0, 8)}... keeping pinned model: ${existingSession.model} (${existingSession.tier} >= ${routingDecision.tier})`
-              );
-              parsed.model = existingSession.model;
-              modelId = existingSession.model;
-              bodyModified = true;
-              sessionStore.touchSession(effectiveSessionId);
-              routingDecision = {
-                ...routingDecision,
-                model: existingSession.model,
-                tier: existingSession.tier
-              };
-            }
-            const lastAssistantMsg = [...parsedMessages].reverse().find((m) => m.role === "assistant");
-            const assistantToolCalls = lastAssistantMsg?.tool_calls;
-            const toolCallNames = Array.isArray(assistantToolCalls) ? assistantToolCalls.map((tc) => tc.function?.name).filter((n) => Boolean(n)) : void 0;
-            const contentHash = hashRequestContent(prompt, toolCallNames);
-            const shouldEscalate = sessionStore.recordRequestHash(effectiveSessionId, contentHash);
-            if (shouldEscalate) {
-              const activeTierConfigs = (() => {
-                if (routingDecision.reasoning?.includes("agentic") && routerOpts.config.agenticTiers) {
-                  return routerOpts.config.agenticTiers;
-                }
-                if (routingProfile === "eco" && routerOpts.config.ecoTiers) {
-                  return routerOpts.config.ecoTiers;
-                }
-                if (routingProfile === "premium" && routerOpts.config.premiumTiers) {
-                  return routerOpts.config.premiumTiers;
-                }
-                return routerOpts.config.tiers;
-              })();
-              const escalation = sessionStore.escalateSession(
-                effectiveSessionId,
-                activeTierConfigs
-              );
-              if (escalation) {
-                logger.info(
-                  `[ckcloud] \u26A1 3-strike escalation: ${existingSession.model} \u2192 ${escalation.model} (${existingSession.tier} \u2192 ${escalation.tier})`
-                );
-                parsed.model = escalation.model;
-                modelId = escalation.model;
-                routingDecision = {
-                  ...routingDecision,
-                  model: escalation.model,
-                  tier: escalation.tier
-                };
-              }
-            }
-          } else {
+          return false;
+        });
+        if (hasVision) {
+          logger.info(`[ckcloud] Vision content detected, filtering to vision-capable models`);
+        }
+        routingDecision = route(prompt, systemPrompt, maxTokens, {
+          ...routerOpts,
+          routingProfile: routingProfile ?? void 0,
+          hasTools
+        });
+        if (existingSession) {
+          const tierRank = {
+            SIMPLE: 0,
+            MEDIUM: 1,
+            COMPLEX: 2,
+            REASONING: 3
+          };
+          const existingRank = tierRank[existingSession.tier] ?? 0;
+          const newRank = tierRank[routingDecision.tier] ?? 0;
+          if (newRank > existingRank) {
+            logger.info(
+              `[ckcloud] Session ${effectiveSessionId?.slice(0, 8)}... upgrading: ${existingSession.tier} \u2192 ${routingDecision.tier} (${routingDecision.model})`
+            );
             parsed.model = routingDecision.model;
             modelId = routingDecision.model;
             bodyModified = true;
@@ -5587,13 +6356,72 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
                 routingDecision.model,
                 routingDecision.tier
               );
+            }
+          } else {
+            logger.info(
+              `[ckcloud] Session ${effectiveSessionId?.slice(0, 8)}... keeping pinned model: ${existingSession.model} (${existingSession.tier} >= ${routingDecision.tier})`
+            );
+            parsed.model = existingSession.model;
+            modelId = existingSession.model;
+            bodyModified = true;
+            sessionStore.touchSession(effectiveSessionId);
+            routingDecision = {
+              ...routingDecision,
+              model: existingSession.model,
+              tier: existingSession.tier
+            };
+          }
+          const lastAssistantMsg = [...parsedMessages].reverse().find((m) => m.role === "assistant");
+          const assistantToolCalls = lastAssistantMsg?.tool_calls;
+          const toolCallNames = Array.isArray(assistantToolCalls) ? assistantToolCalls.map((tc) => tc.function?.name).filter((n) => Boolean(n)) : void 0;
+          const contentHash = hashRequestContent(prompt, toolCallNames);
+          const shouldEscalate = sessionStore.recordRequestHash(effectiveSessionId, contentHash);
+          if (shouldEscalate) {
+            const activeTierConfigs = (() => {
+              if (routingDecision.reasoning?.includes("agentic") && routerOpts.config.agenticTiers) {
+                return routerOpts.config.agenticTiers;
+              }
+              if (routingProfile === "eco" && routerOpts.config.ecoTiers) {
+                return routerOpts.config.ecoTiers;
+              }
+              if (routingProfile === "premium" && routerOpts.config.premiumTiers) {
+                return routerOpts.config.premiumTiers;
+              }
+              return routerOpts.config.tiers;
+            })();
+            const escalation = sessionStore.escalateSession(
+              effectiveSessionId,
+              activeTierConfigs
+            );
+            if (escalation) {
               logger.info(
-                `[ckcloud] Session ${effectiveSessionId.slice(0, 8)}... pinned to model: ${routingDecision.model}`
+                `[ckcloud] \u26A1 3-strike escalation: ${existingSession.model} \u2192 ${escalation.model} (${existingSession.tier} \u2192 ${escalation.tier})`
               );
+              parsed.model = escalation.model;
+              modelId = escalation.model;
+              routingDecision = {
+                ...routingDecision,
+                model: escalation.model,
+                tier: escalation.tier
+              };
             }
           }
-          options.onRouted?.(routingDecision);
+        } else {
+          parsed.model = routingDecision.model;
+          modelId = routingDecision.model;
+          bodyModified = true;
+          if (effectiveSessionId) {
+            sessionStore.setSession(
+              effectiveSessionId,
+              routingDecision.model,
+              routingDecision.tier
+            );
+            logger.info(
+              `[ckcloud] Session ${effectiveSessionId.slice(0, 8)}... pinned to model: ${routingDecision.model}`
+            );
+          }
         }
+        options.onRouted?.(routingDecision);
       }
       if (bodyModified) {
         body = Buffer.from(JSON.stringify(parsed));
@@ -5685,32 +6513,55 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
   }
   deduplicator.markInflight(dedupKey);
   let estimatedCostMicros;
-  let balanceFallbackNotice;
-  const isFreeModel = modelId === FREE_MODEL;
-  if (modelId && !options.skipBalanceCheck && !isFreeModel) {
+  const sendBalanceError = (status, payload) => {
+    if (isStreaming) {
+      res.writeHead(status, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+      res.write(`data: ${JSON.stringify(payload)}
+
+`);
+      res.write("data: [DONE]\n\n");
+      res.end();
+      return;
+    }
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(payload));
+  };
+  if (modelId && !options.skipBalanceCheck) {
     const estimated = estimateAmount(modelId, body.length, maxTokens);
     if (estimated) {
       estimatedCostMicros = BigInt(estimated);
       const bufferedCostMicros = estimatedCostMicros * BigInt(Math.ceil(BALANCE_CHECK_BUFFER * 100)) / 100n;
       const sufficiency = await balanceMonitor.checkSufficient(bufferedCostMicros);
       if (sufficiency.info.isEmpty || !sufficiency.sufficient) {
-        const originalModel = modelId;
+        const balanceMicros = sufficiency.info.balance;
+        const currentUSD = (Number(balanceMicros) / 1e6).toFixed(6);
+        const requiredUSD = (Number(bufferedCostMicros) / 1e6).toFixed(6);
+        const wallet = sufficiency.info.walletAddress;
+        const shortWallet = wallet.length > 12 ? `${wallet.slice(0, 6)}...${wallet.slice(-4)}` : wallet;
         logger.info(
-          `[ckcloud] Wallet ${sufficiency.info.isEmpty ? "empty" : "insufficient"} (${sufficiency.info.balanceUSD}), falling back to free model: ${FREE_MODEL} (requested: ${originalModel})`
+          `[ckcloud] Wallet ${sufficiency.info.isEmpty ? "empty" : "insufficient"} (${sufficiency.info.balanceUSD}), request blocked (model: ${modelId})`
         );
-        modelId = FREE_MODEL;
-        const parsed = JSON.parse(body.toString());
-        parsed.model = FREE_MODEL;
-        body = Buffer.from(JSON.stringify(parsed));
-        balanceFallbackNotice = sufficiency.info.isEmpty ? `> **\u26A0\uFE0F Wallet empty** \u2014 using free model. Fund your wallet to use ${originalModel}.
-
-` : `> **\u26A0\uFE0F Insufficient balance** (${sufficiency.info.balanceUSD}) \u2014 using free model instead of ${originalModel}.
-
-`;
-        options.onLowBalance?.({
+        options.onInsufficientFunds?.({
           balanceUSD: sufficiency.info.balanceUSD,
+          requiredUSD: `$${requiredUSD}`,
           walletAddress: sufficiency.info.walletAddress
         });
+        const payload = {
+          error: {
+            message: sufficiency.info.isEmpty ? "No USDC balance. Fund your wallet to continue." : `Insufficient USDC balance. Current: $${currentUSD}, Required: ~$${requiredUSD}`,
+            type: sufficiency.info.isEmpty ? "empty_wallet" : "insufficient_funds",
+            wallet,
+            current_balance_usd: currentUSD,
+            required_usd: requiredUSD,
+            help: `Fund wallet ${shortWallet} with USDC`
+          }
+        };
+        sendBalanceError(402, payload);
+        return;
       } else if (sufficiency.info.isLow) {
         options.onLowBalance?.({
           balanceUSD: sufficiency.info.balanceUSD,
@@ -5829,9 +6680,6 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
     } else {
       modelsToTry = modelId ? [modelId] : [];
     }
-    if (!modelsToTry.includes(FREE_MODEL)) {
-      modelsToTry.push(FREE_MODEL);
-    }
     let upstream;
     let lastError;
     let actualModelUsed = modelId;
@@ -5882,13 +6730,9 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
         const isPaymentErr = /payment.*verification.*failed|payment.*settlement.*failed|insufficient.*funds|transaction_simulation_failed/i.test(
           result.errorBody || ""
         );
-        if (isPaymentErr && tryModel !== FREE_MODEL) {
-          const freeIdx = modelsToTry.indexOf(FREE_MODEL);
-          if (freeIdx > i + 1) {
-            logger.info(`[ckcloud] Payment error \u2014 skipping to free model: ${FREE_MODEL}`);
-            i = freeIdx - 1;
-            continue;
-          }
+        if (isPaymentErr) {
+          logger.info(`[ckcloud] Payment error \u2014 stopping retries`);
+          break;
         }
         logger.info(
           `[ckcloud] Provider error from ${tryModel}, trying fallback: ${result.errorBody?.slice(0, 100)}`
@@ -6018,25 +6862,6 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
 `;
               safeWrite(res, roleData);
               responseChunks.push(Buffer.from(roleData));
-              if (balanceFallbackNotice) {
-                const noticeChunk = {
-                  ...baseChunk,
-                  choices: [
-                    {
-                      index,
-                      delta: { content: balanceFallbackNotice },
-                      logprobs: null,
-                      finish_reason: null
-                    }
-                  ]
-                };
-                const noticeData = `data: ${JSON.stringify(noticeChunk)}
-
-`;
-                safeWrite(res, noticeData);
-                responseChunks.push(Buffer.from(noticeData));
-                balanceFallbackNotice = void 0;
-              }
               if (content) {
                 const contentChunk = {
                   ...baseChunk,
@@ -6129,17 +6954,6 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
         }
       }
       let responseBody = Buffer.concat(bodyParts);
-      if (balanceFallbackNotice && responseBody.length > 0) {
-        try {
-          const parsed = JSON.parse(responseBody.toString());
-          if (parsed.choices?.[0]?.message?.content !== void 0) {
-            parsed.choices[0].message.content = balanceFallbackNotice + parsed.choices[0].message.content;
-            responseBody = Buffer.from(JSON.stringify(parsed));
-          }
-        } catch {
-        }
-        balanceFallbackNotice = void 0;
-      }
       responseHeaders["content-length"] = String(responseBody.length);
       res.writeHead(upstream.status, responseHeaders);
       safeWrite(res, responseBody);
@@ -6277,6 +7091,13 @@ var plugin = {
         `Failed to refresh models list: ${err instanceof Error ? err.message : String(err)}`
       );
     });
+    createWalletInfoCommand().then((walletCommand) => {
+      api.registerCommand(walletCommand);
+    }).catch((err) => {
+      api.logger.warn(
+        `Failed to register /wallet command: ${err instanceof Error ? err.message : String(err)}`
+      );
+    });
     createStatsCommand().then((statsCommand) => {
       api.registerCommand(statsCommand);
     }).catch((err) => {
@@ -6327,6 +7148,8 @@ var plugin = {
       const healthy = await waitForProxyHealth(port, 5e3);
       if (!healthy) {
         api.logger.warn(`Proxy health check timed out, commands may not work immediately`);
+      } else {
+        api.logger.info(`Proxy health check ok`);
       }
     }).catch((err) => {
       api.logger.error(
@@ -6462,12 +7285,12 @@ function injectModelsConfig(logger2) {
   }
   const model = defaults.model;
   if (!model.primary) {
-    model.primary = "ckcloud/free";
+    model.primary = "ckcloud/auto";
     logger2.info("Set default model");
     needsWrite = true;
   }
   const TOP_MODELS = [
-    "free",
+    "auto",
     "eco",
     "premium"
   ];
@@ -6605,6 +7428,67 @@ async function createStatsCommand() {
     }
   };
 }
+async function createWalletInfoCommand() {
+  return {
+    name: "wallet",
+    description: "Show ckcloud wallet info (address, chain, balance)",
+    acceptsArgs: false,
+    requireAuth: false,
+    handler: async (_ctx) => {
+      try {
+        const wallet = await resolveOrGenerateWalletKey();
+        const chain = await resolvePaymentChain();
+        let solanaAddress;
+        if (wallet.solanaPrivateKeyBytes) {
+          solanaAddress = await getSolanaAddress(wallet.solanaPrivateKeyBytes).catch(() => void 0);
+        }
+        const evmAddress = wallet.address;
+        const solAddress2 = solanaAddress || "(not set up)";
+        let balanceInfo;
+        if (activeProxyHandle) {
+          balanceInfo = await activeProxyHandle.balanceMonitor.checkBalance().catch(() => void 0);
+        }
+        if (!balanceInfo) {
+          if (chain === "solana") {
+            if (solanaAddress) {
+              const monitor = new SolanaBalanceMonitor(solanaAddress);
+              balanceInfo = await monitor.checkBalance().catch(() => void 0);
+            }
+          } else {
+            const monitor = new BalanceMonitor(wallet.address);
+            balanceInfo = await monitor.checkBalance().catch(() => void 0);
+          }
+        }
+        let balanceLine = "Balance: (checking...)";
+        if (chain === "solana" && !solanaAddress) {
+          balanceLine = "Balance: (unavailable \u2014 Solana wallet not set up)";
+        } else if (balanceInfo) {
+          if (balanceInfo.isEmpty) {
+            balanceLine = "Balance: $0.00";
+          } else if (balanceInfo.isLow) {
+            balanceLine = `Balance: ${balanceInfo.balanceUSD} (low)`;
+          } else {
+            balanceLine = `Balance: ${balanceInfo.balanceUSD}`;
+          }
+        }
+        const lines = [
+          "Wallet info",
+          `Chain: ${chain}`,
+          `EVM Address: ${evmAddress}`,
+          `Solana Address: ${solAddress2}`,
+          `Source: ${wallet.source}`,
+          balanceLine
+        ];
+        return { text: lines.join("\n") };
+      } catch (err) {
+        return {
+          text: `Failed to load wallet info: ${err instanceof Error ? err.message : String(err)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
 async function startProxyInBackground(api) {
   const wallet = await resolveOrGenerateWalletKey();
   if (wallet.source === "generated") {
@@ -6655,7 +7539,7 @@ async function startProxyInBackground(api) {
   proxy.balanceMonitor.checkBalance().then((balance) => {
     if (balance.isEmpty) {
       api.logger.info(`Wallet: ${displayAddress} | Balance: $0.00`);
-      api.logger.info(`Using FREE model. Fund wallet for premium models.`);
+      api.logger.info(`Using AUTO model. Fund wallet for premium models.`);
     } else if (balance.isLow) {
       api.logger.info(`Wallet: ${displayAddress} | Balance: ${balance.balanceUSD} (low)`);
     } else {