@ckcloudai.com/clawrouter 0.0.6 → 0.0.7

package/dist/index.js

@@ -27,9 +27,23 @@ var RpcError = class extends Error {
   }
 };
 
+// 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,
@@ -62,6 +76,14 @@ var BalanceMonitor = class {
     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;
@@ -69,6 +91,78 @@ var BalanceMonitor = class {
     }
     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.
    *
@@ -157,6 +251,8 @@ 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;
@@ -172,6 +268,14 @@ var SolanaBalanceMonitor = class {
     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;
@@ -179,6 +283,78 @@ var SolanaBalanceMonitor = class {
     }
     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;
@@ -799,17 +975,750 @@ async function logUsage(entry) {
   }
 }
 
-// src/plugin-logger.ts
-var pluginLogger = console;
-function setPluginLogger(logger2) {
-  pluginLogger = logger2 ?? console;
+// 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");
 }
-var logger = {
-  debug: (message) => pluginLogger.debug?.(message),
-  info: (message) => pluginLogger.info(message),
-  warn: (message) => pluginLogger.warn(message),
-  error: (message) => pluginLogger.error(message)
+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);
+    }
+  }
+  let result = parts.join("\n");
+  if (result.length > COMPRESSED_RESULT_MAX) {
+    result = result.slice(0, COMPRESSED_RESULT_MAX - 20) + "\n[...truncated]";
+  }
+  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);
+    }
+  }
+  return phrases;
+}
+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;
+}
+function escapeRegex2(str) {
+  if (!str || typeof str !== "string") return "";
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+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/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;
+}
 
 // src/session.ts
 import { createHash } from "crypto";
@@ -4590,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).`);
@@ -6238,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(
@@ -6627,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 {