@blockrun/clawrouter 0.8.31 → 0.9.1

package/dist/cli.js

@@ -1128,9 +1128,10 @@ var DEFAULT_ROUTING_CONFIG = {
       primary: "nvidia/kimi-k2.5",
       // $0.55/$2.5 - best quality/price for simple tasks
       fallback: [
+        "google/gemini-2.5-flash",
+        // 1M context, cost-effective
         "nvidia/gpt-oss-120b",
         // FREE fallback
-        "google/gemini-2.5-flash",
         "deepseek/deepseek-chat"
       ]
     },
@@ -1138,17 +1139,22 @@ var DEFAULT_ROUTING_CONFIG = {
       primary: "xai/grok-code-fast-1",
       // Code specialist, $0.20/$1.50
       fallback: [
-        "xai/grok-4-1-fast-non-reasoning",
-        // Upgraded Grok 4.1
+        "google/gemini-2.5-flash",
+        // 1M context, cost-effective
         "deepseek/deepseek-chat",
-        "google/gemini-2.5-flash"
+        "xai/grok-4-1-fast-non-reasoning"
+        // Upgraded Grok 4.1
       ]
     },
     COMPLEX: {
       primary: "google/gemini-3-pro-preview",
       // Latest Gemini - upgraded from 2.5
       fallback: [
+        "google/gemini-2.5-flash",
+        // CRITICAL: 1M context, cheap failsafe before expensive models
         "google/gemini-2.5-pro",
+        "deepseek/deepseek-chat",
+        // Another cheap option
         "xai/grok-4-0709",
         "openai/gpt-4o",
         "openai/gpt-5.2",
@@ -1159,11 +1165,12 @@ var DEFAULT_ROUTING_CONFIG = {
       primary: "xai/grok-4-1-fast-reasoning",
       // Upgraded Grok 4.1 reasoning $0.20/$0.50
       fallback: [
+        "deepseek/deepseek-reasoner",
+        // Cheap reasoning model as first fallback
         "xai/grok-4-fast-reasoning",
         "openai/o3",
         "openai/o4-mini",
         // Latest o-series mini
-        "deepseek/deepseek-reasoner",
         "moonshot/kimi-k2.5"
       ]
     }
@@ -2168,6 +2175,739 @@ var BalanceMonitor = class {
   }
 };
 
+// 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 crypto2 from "crypto";
+function hashMessage(message) {
+  const parts = [
+    message.role,
+    message.content || "",
+    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 crypto2.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) 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) 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",
+  // BlockRun model aliases (common in prompts)
+  $M01: "blockrun/",
+  $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) {
+  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) 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) 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) 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 && 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 || 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) {
+      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) {
+      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) {
+  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) 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 = msg.content?.length || 0;
+    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) {
+      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) {
+          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
 var DEFAULT_SESSION_CONFIG = {
   enabled: false,
@@ -2363,7 +3103,7 @@ var ROUTING_PROFILES = /* @__PURE__ */ new Set([
 var FREE_MODEL = "nvidia/gpt-oss-120b";
 var HEARTBEAT_INTERVAL_MS = 2e3;
 var DEFAULT_REQUEST_TIMEOUT_MS = 18e4;
-var MAX_FALLBACK_ATTEMPTS = 3;
+var MAX_FALLBACK_ATTEMPTS = 5;
 var HEALTH_CHECK_TIMEOUT_MS = 2e3;
 var RATE_LIMIT_COOLDOWN_MS = 6e4;
 var PORT_RETRY_ATTEMPTS = 5;
@@ -2497,7 +3237,10 @@ var PROVIDER_ERROR_PATTERNS = [
   /overloaded/i,
   /temporarily.*unavailable/i,
   /api.*key.*invalid/i,
-  /authentication.*failed/i
+  /authentication.*failed/i,
+  /request too large/i,
+  /request.*size.*exceeds/i,
+  /payload too large/i
 ];
 var FALLBACK_STATUS_CODES = [
   400,
@@ -3109,7 +3852,9 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
             const tools = parsed.tools;
             const hasTools = Array.isArray(tools) && tools.length > 0;
             if (hasTools) {
-              console.log(`[ClawRouter] Tools detected (${tools.length}), agentic mode via keywords`);
+              console.log(
+                `[ClawRouter] Tools detected (${tools.length}), agentic mode via keywords`
+              );
             }
             routingDecision = route(prompt, systemPrompt, maxTokens, {
               ...routerOpts,
@@ -3137,6 +3882,87 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
       options.onError?.(new Error(`Routing failed: ${errorMsg}`));
     }
   }
+  const autoCompress = options.autoCompressRequests ?? true;
+  const compressionThreshold = options.compressionThresholdKB ?? 180;
+  const sizeLimit = options.maxRequestSizeKB ?? 200;
+  const requestSizeKB = Math.ceil(body.length / 1024);
+  if (autoCompress && requestSizeKB > compressionThreshold) {
+    try {
+      console.log(
+        `[ClawRouter] Request size ${requestSizeKB}KB exceeds threshold ${compressionThreshold}KB, applying compression...`
+      );
+      const parsed = JSON.parse(body.toString());
+      if (parsed.messages && parsed.messages.length > 0 && shouldCompress(parsed.messages)) {
+        const compressionResult = await compressContext(parsed.messages, {
+          enabled: true,
+          preserveRaw: false,
+          // Don't need originals in proxy
+          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
+          }
+        });
+        const compressedSizeKB = Math.ceil(compressionResult.compressedChars / 1024);
+        const savings = ((requestSizeKB - compressedSizeKB) / requestSizeKB * 100).toFixed(1);
+        console.log(
+          `[ClawRouter] Compressed ${requestSizeKB}KB \u2192 ${compressedSizeKB}KB (${savings}% reduction)`
+        );
+        parsed.messages = compressionResult.messages;
+        body = Buffer.from(JSON.stringify(parsed));
+        if (compressedSizeKB > sizeLimit) {
+          const errorMsg = {
+            error: {
+              message: `Request size ${compressedSizeKB}KB still exceeds limit after compression (original: ${requestSizeKB}KB). Please reduce context size.`,
+              type: "request_too_large",
+              original_size_kb: requestSizeKB,
+              compressed_size_kb: compressedSizeKB,
+              limit_kb: sizeLimit,
+              help: "Try: 1) Remove old messages from history, 2) Summarize large tool results, 3) Use direct API for very large contexts"
+            }
+          };
+          res.writeHead(413, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(errorMsg));
+          return;
+        }
+      }
+    } catch (err) {
+      console.warn(
+        `[ClawRouter] Compression failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  const finalSizeKB = Math.ceil(body.length / 1024);
+  if (finalSizeKB > sizeLimit) {
+    const errorMsg = {
+      error: {
+        message: `Request size ${finalSizeKB}KB exceeds limit ${sizeLimit}KB. Please reduce context size.`,
+        type: "request_too_large",
+        size_kb: finalSizeKB,
+        limit_kb: sizeLimit,
+        help: "Try: 1) Remove old messages from history, 2) Summarize large tool results, 3) Enable compression (autoCompressRequests: true)"
+      }
+    };
+    res.writeHead(413, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(errorMsg));
+    return;
+  }
   const dedupKey = RequestDeduplicator.hash(body);
   const cached = deduplicator.getCached(dedupKey);
   if (cached) {