npm - @blockrun/clawrouter - Versions diffs - 0.9.9 → 0.9.11 - Mend

@blockrun/clawrouter 0.9.9 → 0.9.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/cli.js DELETED Viewed

@@ -1,4803 +0,0 @@
-#!/usr/bin/env node
-// src/proxy.ts
-import { createServer } from "http";
-import { finished } from "stream";
-import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
-// src/x402.ts
-import { signTypedData, privateKeyToAccount } from "viem/accounts";
-// src/payment-cache.ts
-var DEFAULT_TTL_MS = 36e5;
-var PaymentCache = class {
-  cache = /* @__PURE__ */ new Map();
-  ttlMs;
-  constructor(ttlMs = DEFAULT_TTL_MS) {
-    this.ttlMs = ttlMs;
-  }
-  /** Get cached payment params for an endpoint path. */
-  get(endpointPath) {
-    const entry = this.cache.get(endpointPath);
-    if (!entry) return void 0;
-    if (Date.now() - entry.cachedAt > this.ttlMs) {
-      this.cache.delete(endpointPath);
-      return void 0;
-    }
-    return entry;
-  }
-  /** Cache payment params from a 402 response. */
-  set(endpointPath, params) {
-    this.cache.set(endpointPath, { ...params, cachedAt: Date.now() });
-  }
-  /** Invalidate cache for an endpoint (e.g., if payTo changed). */
-  invalidate(endpointPath) {
-    this.cache.delete(endpointPath);
-  }
-};
-// src/x402.ts
-var BASE_CHAIN_ID = 8453;
-var USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-var USDC_DOMAIN = {
-  name: "USD Coin",
-  version: "2",
-  chainId: BASE_CHAIN_ID,
-  verifyingContract: USDC_BASE
-};
-var TRANSFER_TYPES = {
-  TransferWithAuthorization: [
-    { name: "from", type: "address" },
-    { name: "to", type: "address" },
-    { name: "value", type: "uint256" },
-    { name: "validAfter", type: "uint256" },
-    { name: "validBefore", type: "uint256" },
-    { name: "nonce", type: "bytes32" }
-  ]
-};
-function createNonce() {
-  const bytes = new Uint8Array(32);
-  crypto.getRandomValues(bytes);
-  return `0x${Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
-}
-function parsePaymentRequired(headerValue) {
-  const decoded = atob(headerValue);
-  return JSON.parse(decoded);
-}
-async function createPaymentPayload(privateKey, fromAddress, recipient, amount, resourceUrl) {
-  const now = Math.floor(Date.now() / 1e3);
-  const validAfter = now - 600;
-  const validBefore = now + 300;
-  const nonce = createNonce();
-  const signature = await signTypedData({
-    privateKey,
-    domain: USDC_DOMAIN,
-    types: TRANSFER_TYPES,
-    primaryType: "TransferWithAuthorization",
-    message: {
-      from: fromAddress,
-      to: recipient,
-      value: BigInt(amount),
-      validAfter: BigInt(validAfter),
-      validBefore: BigInt(validBefore),
-      nonce
-    }
-  });
-  const paymentData = {
-    x402Version: 2,
-    resource: {
-      url: resourceUrl,
-      description: "BlockRun AI API call",
-      mimeType: "application/json"
-    },
-    accepted: {
-      scheme: "exact",
-      network: "eip155:8453",
-      amount,
-      asset: USDC_BASE,
-      payTo: recipient,
-      maxTimeoutSeconds: 300,
-      extra: { name: "USD Coin", version: "2" }
-    },
-    payload: {
-      signature,
-      authorization: {
-        from: fromAddress,
-        to: recipient,
-        value: amount,
-        validAfter: validAfter.toString(),
-        validBefore: validBefore.toString(),
-        nonce
-      }
-    },
-    extensions: {}
-  };
-  return btoa(JSON.stringify(paymentData));
-}
-function createPaymentFetch(privateKey) {
-  const account = privateKeyToAccount(privateKey);
-  const walletAddress = account.address;
-  const paymentCache = new PaymentCache();
-  const payFetch = async (input, init, preAuth) => {
-    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-    const endpointPath = new URL(url).pathname;
-    const cached = paymentCache.get(endpointPath);
-    if (cached && preAuth?.estimatedAmount) {
-      const paymentPayload = await createPaymentPayload(
-        privateKey,
-        walletAddress,
-        cached.payTo,
-        preAuth.estimatedAmount,
-        url
-      );
-      const preAuthHeaders = new Headers(init?.headers);
-      preAuthHeaders.set("payment-signature", paymentPayload);
-      const response2 = await fetch(input, { ...init, headers: preAuthHeaders });
-      if (response2.status !== 402) {
-        return response2;
-      }
-      const paymentHeader2 = response2.headers.get("x-payment-required");
-      if (paymentHeader2) {
-        return handle402(input, init, url, endpointPath, paymentHeader2);
-      }
-      paymentCache.invalidate(endpointPath);
-      const cleanResponse = await fetch(input, init);
-      if (cleanResponse.status !== 402) {
-        return cleanResponse;
-      }
-      const cleanHeader = cleanResponse.headers.get("x-payment-required");
-      if (!cleanHeader) {
-        throw new Error("402 response missing x-payment-required header");
-      }
-      return handle402(input, init, url, endpointPath, cleanHeader);
-    }
-    const response = await fetch(input, init);
-    if (response.status !== 402) {
-      return response;
-    }
-    const paymentHeader = response.headers.get("x-payment-required");
-    if (!paymentHeader) {
-      throw new Error("402 response missing x-payment-required header");
-    }
-    return handle402(input, init, url, endpointPath, paymentHeader);
-  };
-  async function handle402(input, init, url, endpointPath, paymentHeader) {
-    const paymentRequired = parsePaymentRequired(paymentHeader);
-    const option = paymentRequired.accepts?.[0];
-    if (!option) {
-      throw new Error("No payment options in 402 response");
-    }
-    const amount = option.amount || option.maxAmountRequired;
-    if (!amount) {
-      throw new Error("No amount in payment requirements");
-    }
-    paymentCache.set(endpointPath, {
-      payTo: option.payTo,
-      asset: option.asset,
-      scheme: option.scheme,
-      network: option.network,
-      extra: option.extra,
-      maxTimeoutSeconds: option.maxTimeoutSeconds
-    });
-    const paymentPayload = await createPaymentPayload(
-      privateKey,
-      walletAddress,
-      option.payTo,
-      amount,
-      url
-    );
-    const retryHeaders = new Headers(init?.headers);
-    retryHeaders.set("payment-signature", paymentPayload);
-    return fetch(input, {
-      ...init,
-      headers: retryHeaders
-    });
-  }
-  return { fetch: payFetch, cache: paymentCache };
-}
-// src/router/rules.ts
-function scoreTokenCount(estimatedTokens, thresholds) {
-  if (estimatedTokens < thresholds.simple) {
-    return { name: "tokenCount", score: -1, signal: `short (${estimatedTokens} tokens)` };
-  }
-  if (estimatedTokens > thresholds.complex) {
-    return { name: "tokenCount", score: 1, signal: `long (${estimatedTokens} tokens)` };
-  }
-  return { name: "tokenCount", score: 0, signal: null };
-}
-function scoreKeywordMatch(text, keywords, name, signalLabel, thresholds, scores) {
-  const matches = keywords.filter((kw) => text.includes(kw.toLowerCase()));
-  if (matches.length >= thresholds.high) {
-    return {
-      name,
-      score: scores.high,
-      signal: `${signalLabel} (${matches.slice(0, 3).join(", ")})`
-    };
-  }
-  if (matches.length >= thresholds.low) {
-    return {
-      name,
-      score: scores.low,
-      signal: `${signalLabel} (${matches.slice(0, 3).join(", ")})`
-    };
-  }
-  return { name, score: scores.none, signal: null };
-}
-function scoreMultiStep(text) {
-  const patterns = [/first.*then/i, /step \d/i, /\d\.\s/];
-  const hits = patterns.filter((p) => p.test(text));
-  if (hits.length > 0) {
-    return { name: "multiStepPatterns", score: 0.5, signal: "multi-step" };
-  }
-  return { name: "multiStepPatterns", score: 0, signal: null };
-}
-function scoreQuestionComplexity(prompt) {
-  const count = (prompt.match(/\?/g) || []).length;
-  if (count > 3) {
-    return { name: "questionComplexity", score: 0.5, signal: `${count} questions` };
-  }
-  return { name: "questionComplexity", score: 0, signal: null };
-}
-function scoreAgenticTask(text, keywords) {
-  let matchCount = 0;
-  const signals = [];
-  for (const keyword of keywords) {
-    if (text.includes(keyword.toLowerCase())) {
-      matchCount++;
-      if (signals.length < 3) {
-        signals.push(keyword);
-      }
-    }
-  }
-  if (matchCount >= 4) {
-    return {
-      dimensionScore: {
-        name: "agenticTask",
-        score: 1,
-        signal: `agentic (${signals.join(", ")})`
-      },
-      agenticScore: 1
-    };
-  } else if (matchCount >= 3) {
-    return {
-      dimensionScore: {
-        name: "agenticTask",
-        score: 0.6,
-        signal: `agentic (${signals.join(", ")})`
-      },
-      agenticScore: 0.6
-    };
-  } else if (matchCount >= 1) {
-    return {
-      dimensionScore: {
-        name: "agenticTask",
-        score: 0.2,
-        signal: `agentic-light (${signals.join(", ")})`
-      },
-      agenticScore: 0.2
-    };
-  }
-  return {
-    dimensionScore: { name: "agenticTask", score: 0, signal: null },
-    agenticScore: 0
-  };
-}
-function classifyByRules(prompt, systemPrompt, estimatedTokens, config) {
-  const text = `${systemPrompt ?? ""} ${prompt}`.toLowerCase();
-  const userText = prompt.toLowerCase();
-  const dimensions = [
-    // Original 8 dimensions
-    scoreTokenCount(estimatedTokens, config.tokenCountThresholds),
-    scoreKeywordMatch(
-      text,
-      config.codeKeywords,
-      "codePresence",
-      "code",
-      { low: 1, high: 2 },
-      { none: 0, low: 0.5, high: 1 }
-    ),
-    // Reasoning markers use USER prompt only — system prompt "step by step" shouldn't trigger reasoning
-    scoreKeywordMatch(
-      userText,
-      config.reasoningKeywords,
-      "reasoningMarkers",
-      "reasoning",
-      { low: 1, high: 2 },
-      { none: 0, low: 0.7, high: 1 }
-    ),
-    scoreKeywordMatch(
-      text,
-      config.technicalKeywords,
-      "technicalTerms",
-      "technical",
-      { low: 2, high: 4 },
-      { none: 0, low: 0.5, high: 1 }
-    ),
-    scoreKeywordMatch(
-      text,
-      config.creativeKeywords,
-      "creativeMarkers",
-      "creative",
-      { low: 1, high: 2 },
-      { none: 0, low: 0.5, high: 0.7 }
-    ),
-    scoreKeywordMatch(
-      text,
-      config.simpleKeywords,
-      "simpleIndicators",
-      "simple",
-      { low: 1, high: 2 },
-      { none: 0, low: -1, high: -1 }
-    ),
-    scoreMultiStep(text),
-    scoreQuestionComplexity(prompt),
-    // 6 new dimensions
-    scoreKeywordMatch(
-      text,
-      config.imperativeVerbs,
-      "imperativeVerbs",
-      "imperative",
-      { low: 1, high: 2 },
-      { none: 0, low: 0.3, high: 0.5 }
-    ),
-    scoreKeywordMatch(
-      text,
-      config.constraintIndicators,
-      "constraintCount",
-      "constraints",
-      { low: 1, high: 3 },
-      { none: 0, low: 0.3, high: 0.7 }
-    ),
-    scoreKeywordMatch(
-      text,
-      config.outputFormatKeywords,
-      "outputFormat",
-      "format",
-      { low: 1, high: 2 },
-      { none: 0, low: 0.4, high: 0.7 }
-    ),
-    scoreKeywordMatch(
-      text,
-      config.referenceKeywords,
-      "referenceComplexity",
-      "references",
-      { low: 1, high: 2 },
-      { none: 0, low: 0.3, high: 0.5 }
-    ),
-    scoreKeywordMatch(
-      text,
-      config.negationKeywords,
-      "negationComplexity",
-      "negation",
-      { low: 2, high: 3 },
-      { none: 0, low: 0.3, high: 0.5 }
-    ),
-    scoreKeywordMatch(
-      text,
-      config.domainSpecificKeywords,
-      "domainSpecificity",
-      "domain-specific",
-      { low: 1, high: 2 },
-      { none: 0, low: 0.5, high: 0.8 }
-    )
-  ];
-  const agenticResult = scoreAgenticTask(text, config.agenticTaskKeywords);
-  dimensions.push(agenticResult.dimensionScore);
-  const agenticScore = agenticResult.agenticScore;
-  const signals = dimensions.filter((d) => d.signal !== null).map((d) => d.signal);
-  const weights = config.dimensionWeights;
-  let weightedScore = 0;
-  for (const d of dimensions) {
-    const w = weights[d.name] ?? 0;
-    weightedScore += d.score * w;
-  }
-  const reasoningMatches = config.reasoningKeywords.filter(
-    (kw) => userText.includes(kw.toLowerCase())
-  );
-  if (reasoningMatches.length >= 2) {
-    const confidence2 = calibrateConfidence(
-      Math.max(weightedScore, 0.3),
-      // ensure positive for confidence calc
-      config.confidenceSteepness
-    );
-    return {
-      score: weightedScore,
-      tier: "REASONING",
-      confidence: Math.max(confidence2, 0.85),
-      signals,
-      agenticScore
-    };
-  }
-  const { simpleMedium, mediumComplex, complexReasoning } = config.tierBoundaries;
-  let tier;
-  let distanceFromBoundary;
-  if (weightedScore < simpleMedium) {
-    tier = "SIMPLE";
-    distanceFromBoundary = simpleMedium - weightedScore;
-  } else if (weightedScore < mediumComplex) {
-    tier = "MEDIUM";
-    distanceFromBoundary = Math.min(weightedScore - simpleMedium, mediumComplex - weightedScore);
-  } else if (weightedScore < complexReasoning) {
-    tier = "COMPLEX";
-    distanceFromBoundary = Math.min(
-      weightedScore - mediumComplex,
-      complexReasoning - weightedScore
-    );
-  } else {
-    tier = "REASONING";
-    distanceFromBoundary = weightedScore - complexReasoning;
-  }
-  const confidence = calibrateConfidence(distanceFromBoundary, config.confidenceSteepness);
-  if (confidence < config.confidenceThreshold) {
-    return { score: weightedScore, tier: null, confidence, signals, agenticScore };
-  }
-  return { score: weightedScore, tier, confidence, signals, agenticScore };
-}
-function calibrateConfidence(distance, steepness) {
-  return 1 / (1 + Math.exp(-steepness * distance));
-}
-// src/router/selector.ts
-function selectModel(tier, confidence, method, reasoning, tierConfigs, modelPricing, estimatedInputTokens, maxOutputTokens, routingProfile) {
-  const tierConfig = tierConfigs[tier];
-  const model = tierConfig.primary;
-  const pricing = modelPricing.get(model);
-  const inputPrice = pricing?.inputPrice ?? 0;
-  const outputPrice = pricing?.outputPrice ?? 0;
-  const inputCost = estimatedInputTokens / 1e6 * inputPrice;
-  const outputCost = maxOutputTokens / 1e6 * outputPrice;
-  const costEstimate = inputCost + outputCost;
-  const opusPricing = modelPricing.get("anthropic/claude-opus-4.5");
-  const opusInputPrice = opusPricing?.inputPrice ?? 0;
-  const opusOutputPrice = opusPricing?.outputPrice ?? 0;
-  const baselineInput = estimatedInputTokens / 1e6 * opusInputPrice;
-  const baselineOutput = maxOutputTokens / 1e6 * opusOutputPrice;
-  const baselineCost = baselineInput + baselineOutput;
-  const savings = routingProfile === "premium" ? 0 : baselineCost > 0 ? Math.max(0, (baselineCost - costEstimate) / baselineCost) : 0;
-  return {
-    model,
-    tier,
-    confidence,
-    method,
-    reasoning,
-    costEstimate,
-    baselineCost,
-    savings
-  };
-}
-function getFallbackChain(tier, tierConfigs) {
-  const config = tierConfigs[tier];
-  return [config.primary, ...config.fallback];
-}
-function calculateModelCost(model, modelPricing, estimatedInputTokens, maxOutputTokens, routingProfile) {
-  const pricing = modelPricing.get(model);
-  const inputPrice = pricing?.inputPrice ?? 0;
-  const outputPrice = pricing?.outputPrice ?? 0;
-  const inputCost = estimatedInputTokens / 1e6 * inputPrice;
-  const outputCost = maxOutputTokens / 1e6 * outputPrice;
-  const costEstimate = inputCost + outputCost;
-  const opusPricing = modelPricing.get("anthropic/claude-opus-4.5");
-  const opusInputPrice = opusPricing?.inputPrice ?? 0;
-  const opusOutputPrice = opusPricing?.outputPrice ?? 0;
-  const baselineInput = estimatedInputTokens / 1e6 * opusInputPrice;
-  const baselineOutput = maxOutputTokens / 1e6 * opusOutputPrice;
-  const baselineCost = baselineInput + baselineOutput;
-  const savings = routingProfile === "premium" ? 0 : baselineCost > 0 ? Math.max(0, (baselineCost - costEstimate) / baselineCost) : 0;
-  return { costEstimate, baselineCost, savings };
-}
-function getFallbackChainFiltered(tier, tierConfigs, estimatedTotalTokens, getContextWindow) {
-  const fullChain = getFallbackChain(tier, tierConfigs);
-  const filtered = fullChain.filter((modelId) => {
-    const contextWindow = getContextWindow(modelId);
-    if (contextWindow === void 0) {
-      return true;
-    }
-    return contextWindow >= estimatedTotalTokens * 1.1;
-  });
-  if (filtered.length === 0) {
-    return fullChain;
-  }
-  return filtered;
-}
-// src/router/config.ts
-var DEFAULT_ROUTING_CONFIG = {
-  version: "2.0",
-  classifier: {
-    llmModel: "google/gemini-2.5-flash",
-    llmMaxTokens: 10,
-    llmTemperature: 0,
-    promptTruncationChars: 500,
-    cacheTtlMs: 36e5
-    // 1 hour
-  },
-  scoring: {
-    tokenCountThresholds: { simple: 50, complex: 500 },
-    // Multilingual keywords: English + Chinese (中文) + Japanese (日本語) + Russian (Русский) + German (Deutsch)
-    codeKeywords: [
-      // English
-      "function",
-      "class",
-      "import",
-      "def",
-      "SELECT",
-      "async",
-      "await",
-      "const",
-      "let",
-      "var",
-      "return",
-      "```",
-      // Chinese
-      "\u51FD\u6570",
-      "\u7C7B",
-      "\u5BFC\u5165",
-      "\u5B9A\u4E49",
-      "\u67E5\u8BE2",
-      "\u5F02\u6B65",
-      "\u7B49\u5F85",
-      "\u5E38\u91CF",
-      "\u53D8\u91CF",
-      "\u8FD4\u56DE",
-      // Japanese
-      "\u95A2\u6570",
-      "\u30AF\u30E9\u30B9",
-      "\u30A4\u30F3\u30DD\u30FC\u30C8",
-      "\u975E\u540C\u671F",
-      "\u5B9A\u6570",
-      "\u5909\u6570",
-      // Russian
-      "\u0444\u0443\u043D\u043A\u0446\u0438\u044F",
-      "\u043A\u043B\u0430\u0441\u0441",
-      "\u0438\u043C\u043F\u043E\u0440\u0442",
-      "\u043E\u043F\u0440\u0435\u0434\u0435\u043B",
-      "\u0437\u0430\u043F\u0440\u043E\u0441",
-      "\u0430\u0441\u0438\u043D\u0445\u0440\u043E\u043D\u043D\u044B\u0439",
-      "\u043E\u0436\u0438\u0434\u0430\u0442\u044C",
-      "\u043A\u043E\u043D\u0441\u0442\u0430\u043D\u0442\u0430",
-      "\u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u0430\u044F",
-      "\u0432\u0435\u0440\u043D\u0443\u0442\u044C",
-      // German
-      "funktion",
-      "klasse",
-      "importieren",
-      "definieren",
-      "abfrage",
-      "asynchron",
-      "erwarten",
-      "konstante",
-      "variable",
-      "zur\xFCckgeben"
-    ],
-    reasoningKeywords: [
-      // English
-      "prove",
-      "theorem",
-      "derive",
-      "step by step",
-      "chain of thought",
-      "formally",
-      "mathematical",
-      "proof",
-      "logically",
-      // Chinese
-      "\u8BC1\u660E",
-      "\u5B9A\u7406",
-      "\u63A8\u5BFC",
-      "\u9010\u6B65",
-      "\u601D\u7EF4\u94FE",
-      "\u5F62\u5F0F\u5316",
-      "\u6570\u5B66",
-      "\u903B\u8F91",
-      // Japanese
-      "\u8A3C\u660E",
-      "\u5B9A\u7406",
-      "\u5C0E\u51FA",
-      "\u30B9\u30C6\u30C3\u30D7\u30D0\u30A4\u30B9\u30C6\u30C3\u30D7",
-      "\u8AD6\u7406\u7684",
-      // Russian
-      "\u0434\u043E\u043A\u0430\u0437\u0430\u0442\u044C",
-      "\u0434\u043E\u043A\u0430\u0436\u0438",
-      "\u0434\u043E\u043A\u0430\u0437\u0430\u0442\u0435\u043B\u044C\u0441\u0442\u0432",
-      "\u0442\u0435\u043E\u0440\u0435\u043C\u0430",
-      "\u0432\u044B\u0432\u0435\u0441\u0442\u0438",
-      "\u0448\u0430\u0433 \u0437\u0430 \u0448\u0430\u0433\u043E\u043C",
-      "\u043F\u043E\u0448\u0430\u0433\u043E\u0432\u043E",
-      "\u043F\u043E\u044D\u0442\u0430\u043F\u043D\u043E",
-      "\u0446\u0435\u043F\u043E\u0447\u043A\u0430 \u0440\u0430\u0441\u0441\u0443\u0436\u0434\u0435\u043D\u0438\u0439",
-      "\u0440\u0430\u0441\u0441\u0443\u0436\u0434\u0435\u043D\u0438",
-      "\u0444\u043E\u0440\u043C\u0430\u043B\u044C\u043D\u043E",
-      "\u043C\u0430\u0442\u0435\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0438",
-      "\u043B\u043E\u0433\u0438\u0447\u0435\u0441\u043A\u0438",
-      // German
-      "beweisen",
-      "beweis",
-      "theorem",
-      "ableiten",
-      "schritt f\xFCr schritt",
-      "gedankenkette",
-      "formal",
-      "mathematisch",
-      "logisch"
-    ],
-    simpleKeywords: [
-      // English
-      "what is",
-      "define",
-      "translate",
-      "hello",
-      "yes or no",
-      "capital of",
-      "how old",
-      "who is",
-      "when was",
-      // Chinese
-      "\u4EC0\u4E48\u662F",
-      "\u5B9A\u4E49",
-      "\u7FFB\u8BD1",
-      "\u4F60\u597D",
-      "\u662F\u5426",
-      "\u9996\u90FD",
-      "\u591A\u5927",
-      "\u8C01\u662F",
-      "\u4F55\u65F6",
-      // Japanese
-      "\u3068\u306F",
-      "\u5B9A\u7FA9",
-      "\u7FFB\u8A33",
-      "\u3053\u3093\u306B\u3061\u306F",
-      "\u306F\u3044\u304B\u3044\u3044\u3048",
-      "\u9996\u90FD",
-      "\u8AB0",
-      // Russian
-      "\u0447\u0442\u043E \u0442\u0430\u043A\u043E\u0435",
-      "\u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0435\u043D\u0438\u0435",
-      "\u043F\u0435\u0440\u0435\u0432\u0435\u0441\u0442\u0438",
-      "\u043F\u0435\u0440\u0435\u0432\u0435\u0434\u0438",
-      "\u043F\u0440\u0438\u0432\u0435\u0442",
-      "\u0434\u0430 \u0438\u043B\u0438 \u043D\u0435\u0442",
-      "\u0441\u0442\u043E\u043B\u0438\u0446\u0430",
-      "\u0441\u043A\u043E\u043B\u044C\u043A\u043E \u043B\u0435\u0442",
-      "\u043A\u0442\u043E \u0442\u0430\u043A\u043E\u0439",
-      "\u043A\u043E\u0433\u0434\u0430",
-      "\u043E\u0431\u044A\u044F\u0441\u043D\u0438",
-      // German
-      "was ist",
-      "definiere",
-      "\xFCbersetze",
-      "hallo",
-      "ja oder nein",
-      "hauptstadt",
-      "wie alt",
-      "wer ist",
-      "wann",
-      "erkl\xE4re"
-    ],
-    technicalKeywords: [
-      // English
-      "algorithm",
-      "optimize",
-      "architecture",
-      "distributed",
-      "kubernetes",
-      "microservice",
-      "database",
-      "infrastructure",
-      // Chinese
-      "\u7B97\u6CD5",
-      "\u4F18\u5316",
-      "\u67B6\u6784",
-      "\u5206\u5E03\u5F0F",
-      "\u5FAE\u670D\u52A1",
-      "\u6570\u636E\u5E93",
-      "\u57FA\u7840\u8BBE\u65BD",
-      // Japanese
-      "\u30A2\u30EB\u30B4\u30EA\u30BA\u30E0",
-      "\u6700\u9069\u5316",
-      "\u30A2\u30FC\u30AD\u30C6\u30AF\u30C1\u30E3",
-      "\u5206\u6563",
-      "\u30DE\u30A4\u30AF\u30ED\u30B5\u30FC\u30D3\u30B9",
-      "\u30C7\u30FC\u30BF\u30D9\u30FC\u30B9",
-      // Russian
-      "\u0430\u043B\u0433\u043E\u0440\u0438\u0442\u043C",
-      "\u043E\u043F\u0442\u0438\u043C\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u0442\u044C",
-      "\u043E\u043F\u0442\u0438\u043C\u0438\u0437\u0430\u0446\u0438",
-      "\u043E\u043F\u0442\u0438\u043C\u0438\u0437\u0438\u0440\u0443\u0439",
-      "\u0430\u0440\u0445\u0438\u0442\u0435\u043A\u0442\u0443\u0440\u0430",
-      "\u0440\u0430\u0441\u043F\u0440\u0435\u0434\u0435\u043B\u0451\u043D\u043D\u044B\u0439",
-      "\u043C\u0438\u043A\u0440\u043E\u0441\u0435\u0440\u0432\u0438\u0441",
-      "\u0431\u0430\u0437\u0430 \u0434\u0430\u043D\u043D\u044B\u0445",
-      "\u0438\u043D\u0444\u0440\u0430\u0441\u0442\u0440\u0443\u043A\u0442\u0443\u0440\u0430",
-      // German
-      "algorithmus",
-      "optimieren",
-      "architektur",
-      "verteilt",
-      "kubernetes",
-      "mikroservice",
-      "datenbank",
-      "infrastruktur"
-    ],
-    creativeKeywords: [
-      // English
-      "story",
-      "poem",
-      "compose",
-      "brainstorm",
-      "creative",
-      "imagine",
-      "write a",
-      // Chinese
-      "\u6545\u4E8B",
-      "\u8BD7",
-      "\u521B\u4F5C",
-      "\u5934\u8111\u98CE\u66B4",
-      "\u521B\u610F",
-      "\u60F3\u8C61",
-      "\u5199\u4E00\u4E2A",
-      // Japanese
-      "\u7269\u8A9E",
-      "\u8A69",
-      "\u4F5C\u66F2",
-      "\u30D6\u30EC\u30A4\u30F3\u30B9\u30C8\u30FC\u30E0",
-      "\u5275\u9020\u7684",
-      "\u60F3\u50CF",
-      // Russian
-      "\u0438\u0441\u0442\u043E\u0440\u0438\u044F",
-      "\u0440\u0430\u0441\u0441\u043A\u0430\u0437",
-      "\u0441\u0442\u0438\u0445\u043E\u0442\u0432\u043E\u0440\u0435\u043D\u0438\u0435",
-      "\u0441\u043E\u0447\u0438\u043D\u0438\u0442\u044C",
-      "\u0441\u043E\u0447\u0438\u043D\u0438",
-      "\u043C\u043E\u0437\u0433\u043E\u0432\u043E\u0439 \u0448\u0442\u0443\u0440\u043C",
-      "\u0442\u0432\u043E\u0440\u0447\u0435\u0441\u043A\u0438\u0439",
-      "\u043F\u0440\u0435\u0434\u0441\u0442\u0430\u0432\u0438\u0442\u044C",
-      "\u043F\u0440\u0438\u0434\u0443\u043C\u0430\u0439",
-      "\u043D\u0430\u043F\u0438\u0448\u0438",
-      // German
-      "geschichte",
-      "gedicht",
-      "komponieren",
-      "brainstorming",
-      "kreativ",
-      "vorstellen",
-      "schreibe",
-      "erz\xE4hlung"
-    ],
-    // New dimension keyword lists (multilingual)
-    imperativeVerbs: [
-      // English
-      "build",
-      "create",
-      "implement",
-      "design",
-      "develop",
-      "construct",
-      "generate",
-      "deploy",
-      "configure",
-      "set up",
-      // Chinese
-      "\u6784\u5EFA",
-      "\u521B\u5EFA",
-      "\u5B9E\u73B0",
-      "\u8BBE\u8BA1",
-      "\u5F00\u53D1",
-      "\u751F\u6210",
-      "\u90E8\u7F72",
-      "\u914D\u7F6E",
-      "\u8BBE\u7F6E",
-      // Japanese
-      "\u69CB\u7BC9",
-      "\u4F5C\u6210",
-      "\u5B9F\u88C5",
-      "\u8A2D\u8A08",
-      "\u958B\u767A",
-      "\u751F\u6210",
-      "\u30C7\u30D7\u30ED\u30A4",
-      "\u8A2D\u5B9A",
-      // Russian
-      "\u043F\u043E\u0441\u0442\u0440\u043E\u0438\u0442\u044C",
-      "\u043F\u043E\u0441\u0442\u0440\u043E\u0439",
-      "\u0441\u043E\u0437\u0434\u0430\u0442\u044C",
-      "\u0441\u043E\u0437\u0434\u0430\u0439",
-      "\u0440\u0435\u0430\u043B\u0438\u0437\u043E\u0432\u0430\u0442\u044C",
-      "\u0440\u0435\u0430\u043B\u0438\u0437\u0443\u0439",
-      "\u0441\u043F\u0440\u043E\u0435\u043A\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C",
-      "\u0440\u0430\u0437\u0440\u0430\u0431\u043E\u0442\u0430\u0442\u044C",
-      "\u0440\u0430\u0437\u0440\u0430\u0431\u043E\u0442\u0430\u0439",
-      "\u0441\u043A\u043E\u043D\u0441\u0442\u0440\u0443\u0438\u0440\u043E\u0432\u0430\u0442\u044C",
-      "\u0441\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u043E\u0432\u0430\u0442\u044C",
-      "\u0441\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u0443\u0439",
-      "\u0440\u0430\u0437\u0432\u0435\u0440\u043D\u0443\u0442\u044C",
-      "\u0440\u0430\u0437\u0432\u0435\u0440\u043D\u0438",
-      "\u043D\u0430\u0441\u0442\u0440\u043E\u0438\u0442\u044C",
-      "\u043D\u0430\u0441\u0442\u0440\u043E\u0439",
-      // German
-      "erstellen",
-      "bauen",
-      "implementieren",
-      "entwerfen",
-      "entwickeln",
-      "konstruieren",
-      "generieren",
-      "bereitstellen",
-      "konfigurieren",
-      "einrichten"
-    ],
-    constraintIndicators: [
-      // English
-      "under",
-      "at most",
-      "at least",
-      "within",
-      "no more than",
-      "o(",
-      "maximum",
-      "minimum",
-      "limit",
-      "budget",
-      // Chinese
-      "\u4E0D\u8D85\u8FC7",
-      "\u81F3\u5C11",
-      "\u6700\u591A",
-      "\u5728\u5185",
-      "\u6700\u5927",
-      "\u6700\u5C0F",
-      "\u9650\u5236",
-      "\u9884\u7B97",
-      // Japanese
-      "\u4EE5\u4E0B",
-      "\u6700\u5927",
-      "\u6700\u5C0F",
-      "\u5236\u9650",
-      "\u4E88\u7B97",
-      // Russian
-      "\u043D\u0435 \u0431\u043E\u043B\u0435\u0435",
-      "\u043D\u0435 \u043C\u0435\u043D\u0435\u0435",
-      "\u043A\u0430\u043A \u043C\u0438\u043D\u0438\u043C\u0443\u043C",
-      "\u0432 \u043F\u0440\u0435\u0434\u0435\u043B\u0430\u0445",
-      "\u043C\u0430\u043A\u0441\u0438\u043C\u0443\u043C",
-      "\u043C\u0438\u043D\u0438\u043C\u0443\u043C",
-      "\u043E\u0433\u0440\u0430\u043D\u0438\u0447\u0435\u043D\u0438\u0435",
-      "\u0431\u044E\u0434\u0436\u0435\u0442",
-      // German
-      "h\xF6chstens",
-      "mindestens",
-      "innerhalb",
-      "nicht mehr als",
-      "maximal",
-      "minimal",
-      "grenze",
-      "budget"
-    ],
-    outputFormatKeywords: [
-      // English
-      "json",
-      "yaml",
-      "xml",
-      "table",
-      "csv",
-      "markdown",
-      "schema",
-      "format as",
-      "structured",
-      // Chinese
-      "\u8868\u683C",
-      "\u683C\u5F0F\u5316\u4E3A",
-      "\u7ED3\u6784\u5316",
-      // Japanese
-      "\u30C6\u30FC\u30D6\u30EB",
-      "\u30D5\u30A9\u30FC\u30DE\u30C3\u30C8",
-      "\u69CB\u9020\u5316",
-      // Russian
-      "\u0442\u0430\u0431\u043B\u0438\u0446\u0430",
-      "\u0444\u043E\u0440\u043C\u0430\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u043A\u0430\u043A",
-      "\u0441\u0442\u0440\u0443\u043A\u0442\u0443\u0440\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u044B\u0439",
-      // German
-      "tabelle",
-      "formatieren als",
-      "strukturiert"
-    ],
-    referenceKeywords: [
-      // English
-      "above",
-      "below",
-      "previous",
-      "following",
-      "the docs",
-      "the api",
-      "the code",
-      "earlier",
-      "attached",
-      // Chinese
-      "\u4E0A\u9762",
-      "\u4E0B\u9762",
-      "\u4E4B\u524D",
-      "\u63A5\u4E0B\u6765",
-      "\u6587\u6863",
-      "\u4EE3\u7801",
-      "\u9644\u4EF6",
-      // Japanese
-      "\u4E0A\u8A18",
-      "\u4E0B\u8A18",
-      "\u524D\u306E",
-      "\u6B21\u306E",
-      "\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8",
-      "\u30B3\u30FC\u30C9",
-      // Russian
-      "\u0432\u044B\u0448\u0435",
-      "\u043D\u0438\u0436\u0435",
-      "\u043F\u0440\u0435\u0434\u044B\u0434\u0443\u0449\u0438\u0439",
-      "\u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u0439",
-      "\u0434\u043E\u043A\u0443\u043C\u0435\u043D\u0442\u0430\u0446\u0438\u044F",
-      "\u043A\u043E\u0434",
-      "\u0440\u0430\u043D\u0435\u0435",
-      "\u0432\u043B\u043E\u0436\u0435\u043D\u0438\u0435",
-      // German
-      "oben",
-      "unten",
-      "vorherige",
-      "folgende",
-      "dokumentation",
-      "der code",
-      "fr\xFCher",
-      "anhang"
-    ],
-    negationKeywords: [
-      // English
-      "don't",
-      "do not",
-      "avoid",
-      "never",
-      "without",
-      "except",
-      "exclude",
-      "no longer",
-      // Chinese
-      "\u4E0D\u8981",
-      "\u907F\u514D",
-      "\u4ECE\u4E0D",
-      "\u6CA1\u6709",
-      "\u9664\u4E86",
-      "\u6392\u9664",
-      // Japanese
-      "\u3057\u306A\u3044\u3067",
-      "\u907F\u3051\u308B",
-      "\u6C7A\u3057\u3066",
-      "\u306A\u3057\u3067",
-      "\u9664\u304F",
-      // Russian
-      "\u043D\u0435 \u0434\u0435\u043B\u0430\u0439",
-      "\u043D\u0435 \u043D\u0430\u0434\u043E",
-      "\u043D\u0435\u043B\u044C\u0437\u044F",
-      "\u0438\u0437\u0431\u0435\u0433\u0430\u0442\u044C",
-      "\u043D\u0438\u043A\u043E\u0433\u0434\u0430",
-      "\u0431\u0435\u0437",
-      "\u043A\u0440\u043E\u043C\u0435",
-      "\u0438\u0441\u043A\u043B\u044E\u0447\u0438\u0442\u044C",
-      "\u0431\u043E\u043B\u044C\u0448\u0435 \u043D\u0435",
-      // German
-      "nicht",
-      "vermeide",
-      "niemals",
-      "ohne",
-      "au\xDFer",
-      "ausschlie\xDFen",
-      "nicht mehr"
-    ],
-    domainSpecificKeywords: [
-      // English
-      "quantum",
-      "fpga",
-      "vlsi",
-      "risc-v",
-      "asic",
-      "photonics",
-      "genomics",
-      "proteomics",
-      "topological",
-      "homomorphic",
-      "zero-knowledge",
-      "lattice-based",
-      // Chinese
-      "\u91CF\u5B50",
-      "\u5149\u5B50\u5B66",
-      "\u57FA\u56E0\u7EC4\u5B66",
-      "\u86CB\u767D\u8D28\u7EC4\u5B66",
-      "\u62D3\u6251",
-      "\u540C\u6001",
-      "\u96F6\u77E5\u8BC6",
-      "\u683C\u5BC6\u7801",
-      // Japanese
-      "\u91CF\u5B50",
-      "\u30D5\u30A9\u30C8\u30CB\u30AF\u30B9",
-      "\u30B2\u30CE\u30DF\u30AF\u30B9",
-      "\u30C8\u30DD\u30ED\u30B8\u30AB\u30EB",
-      // Russian
-      "\u043A\u0432\u0430\u043D\u0442\u043E\u0432\u044B\u0439",
-      "\u0444\u043E\u0442\u043E\u043D\u0438\u043A\u0430",
-      "\u0433\u0435\u043D\u043E\u043C\u0438\u043A\u0430",
-      "\u043F\u0440\u043E\u0442\u0435\u043E\u043C\u0438\u043A\u0430",
-      "\u0442\u043E\u043F\u043E\u043B\u043E\u0433\u0438\u0447\u0435\u0441\u043A\u0438\u0439",
-      "\u0433\u043E\u043C\u043E\u043C\u043E\u0440\u0444\u043D\u044B\u0439",
-      "\u0441 \u043D\u0443\u043B\u0435\u0432\u044B\u043C \u0440\u0430\u0437\u0433\u043B\u0430\u0448\u0435\u043D\u0438\u0435\u043C",
-      "\u043D\u0430 \u043E\u0441\u043D\u043E\u0432\u0435 \u0440\u0435\u0448\u0451\u0442\u043E\u043A",
-      // German
-      "quanten",
-      "photonik",
-      "genomik",
-      "proteomik",
-      "topologisch",
-      "homomorph",
-      "zero-knowledge",
-      "gitterbasiert"
-    ],
-    // Agentic task keywords - file ops, execution, multi-step, iterative work
-    // Pruned: removed overly common words like "then", "first", "run", "test", "build"
-    agenticTaskKeywords: [
-      // English - File operations (clearly agentic)
-      "read file",
-      "read the file",
-      "look at",
-      "check the",
-      "open the",
-      "edit",
-      "modify",
-      "update the",
-      "change the",
-      "write to",
-      "create file",
-      // English - Execution (specific commands only)
-      "execute",
-      "deploy",
-      "install",
-      "npm",
-      "pip",
-      "compile",
-      // English - Multi-step patterns (specific only)
-      "after that",
-      "and also",
-      "once done",
-      "step 1",
-      "step 2",
-      // English - Iterative work
-      "fix",
-      "debug",
-      "until it works",
-      "keep trying",
-      "iterate",
-      "make sure",
-      "verify",
-      "confirm",
-      // Chinese (keep specific ones)
-      "\u8BFB\u53D6\u6587\u4EF6",
-      "\u67E5\u770B",
-      "\u6253\u5F00",
-      "\u7F16\u8F91",
-      "\u4FEE\u6539",
-      "\u66F4\u65B0",
-      "\u521B\u5EFA",
-      "\u6267\u884C",
-      "\u90E8\u7F72",
-      "\u5B89\u88C5",
-      "\u7B2C\u4E00\u6B65",
-      "\u7B2C\u4E8C\u6B65",
-      "\u4FEE\u590D",
-      "\u8C03\u8BD5",
-      "\u76F4\u5230",
-      "\u786E\u8BA4",
-      "\u9A8C\u8BC1"
-    ],
-    // Dimension weights (sum to 1.0)
-    dimensionWeights: {
-      tokenCount: 0.08,
-      codePresence: 0.15,
-      reasoningMarkers: 0.18,
-      technicalTerms: 0.1,
-      creativeMarkers: 0.05,
-      simpleIndicators: 0.02,
-      // Reduced from 0.12 to make room for agenticTask
-      multiStepPatterns: 0.12,
-      questionComplexity: 0.05,
-      imperativeVerbs: 0.03,
-      constraintCount: 0.04,
-      outputFormat: 0.03,
-      referenceComplexity: 0.02,
-      negationComplexity: 0.01,
-      domainSpecificity: 0.02,
-      agenticTask: 0.04
-      // Reduced - agentic signals influence tier selection, not dominate it
-    },
-    // Tier boundaries on weighted score axis
-    tierBoundaries: {
-      simpleMedium: 0,
-      mediumComplex: 0.3,
-      // Raised from 0.18 - prevent simple tasks from reaching expensive COMPLEX tier
-      complexReasoning: 0.5
-      // Raised from 0.4 - reserve for true reasoning tasks
-    },
-    // Sigmoid steepness for confidence calibration
-    confidenceSteepness: 12,
-    // Below this confidence → ambiguous (null tier)
-    confidenceThreshold: 0.7
-  },
-  // Auto (balanced) tier configs - current default smart routing
-  tiers: {
-    SIMPLE: {
-      primary: "moonshot/kimi-k2.5",
-      // $0.50/$2.40 - best quality/price for simple tasks
-      fallback: [
-        "google/gemini-2.5-flash",
-        // 1M context, cost-effective
-        "nvidia/gpt-oss-120b",
-        // FREE fallback
-        "deepseek/deepseek-chat"
-      ]
-    },
-    MEDIUM: {
-      primary: "xai/grok-code-fast-1",
-      // Code specialist, $0.20/$1.50
-      fallback: [
-        "google/gemini-2.5-flash",
-        // 1M context, cost-effective
-        "deepseek/deepseek-chat",
-        "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",
-        "anthropic/claude-sonnet-4"
-      ]
-    },
-    REASONING: {
-      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
-        "moonshot/kimi-k2.5"
-      ]
-    }
-  },
-  // Eco tier configs - ultra cost-optimized (blockrun/eco)
-  ecoTiers: {
-    SIMPLE: {
-      primary: "moonshot/kimi-k2.5",
-      // $0.50/$2.40
-      fallback: ["nvidia/gpt-oss-120b", "deepseek/deepseek-chat", "google/gemini-2.5-flash"]
-    },
-    MEDIUM: {
-      primary: "deepseek/deepseek-chat",
-      // $0.14/$0.28
-      fallback: ["xai/grok-code-fast-1", "google/gemini-2.5-flash", "moonshot/kimi-k2.5"]
-    },
-    COMPLEX: {
-      primary: "xai/grok-4-0709",
-      // $0.20/$1.50
-      fallback: ["deepseek/deepseek-chat", "google/gemini-2.5-flash", "openai/gpt-4o-mini"]
-    },
-    REASONING: {
-      primary: "deepseek/deepseek-reasoner",
-      // $0.55/$2.19
-      fallback: ["xai/grok-4-fast-reasoning", "moonshot/kimi-k2.5"]
-    }
-  },
-  // Premium tier configs - best quality (blockrun/premium)
-  // codex=complex coding, kimi=simple coding, sonnet=reasoning/instructions, opus=architecture/PM/audits
-  premiumTiers: {
-    SIMPLE: {
-      primary: "moonshot/kimi-k2.5",
-      // $0.50/$2.40 - good for simple coding
-      fallback: ["anthropic/claude-haiku-4.5", "google/gemini-2.5-flash", "xai/grok-code-fast-1"]
-    },
-    MEDIUM: {
-      primary: "anthropic/claude-sonnet-4",
-      // $3/$15 - reasoning/instructions
-      fallback: [
-        "openai/gpt-5.2-codex",
-        "moonshot/kimi-k2.5",
-        "google/gemini-2.5-pro",
-        "xai/grok-4-0709"
-      ]
-    },
-    COMPLEX: {
-      primary: "openai/gpt-5.2-codex",
-      // $2.50/$10 - complex coding (78% cost savings vs Opus)
-      fallback: [
-        "anthropic/claude-opus-4.6",
-        "anthropic/claude-opus-4.5",
-        "anthropic/claude-sonnet-4",
-        "google/gemini-3-pro-preview",
-        "moonshot/kimi-k2.5"
-      ]
-    },
-    REASONING: {
-      primary: "anthropic/claude-sonnet-4",
-      // $3/$15 - best for reasoning/instructions
-      fallback: [
-        "anthropic/claude-opus-4.6",
-        "anthropic/claude-opus-4.5",
-        "openai/o3",
-        "xai/grok-4-1-fast-reasoning"
-      ]
-    }
-  },
-  // Agentic tier configs - models that excel at multi-step autonomous tasks
-  agenticTiers: {
-    SIMPLE: {
-      primary: "moonshot/kimi-k2.5",
-      // Cheaper than Haiku ($0.5/$2.4 vs $1/$5), larger context
-      fallback: [
-        "anthropic/claude-haiku-4.5",
-        "xai/grok-4-fast-non-reasoning",
-        "openai/gpt-4o-mini"
-      ]
-    },
-    MEDIUM: {
-      primary: "xai/grok-code-fast-1",
-      // Code specialist for agentic coding
-      fallback: ["moonshot/kimi-k2.5", "anthropic/claude-haiku-4.5", "anthropic/claude-sonnet-4"]
-    },
-    COMPLEX: {
-      primary: "anthropic/claude-sonnet-4",
-      fallback: [
-        "anthropic/claude-opus-4.6",
-        // Latest Opus - best agentic
-        "openai/gpt-5.2",
-        "google/gemini-3-pro-preview",
-        "xai/grok-4-0709"
-      ]
-    },
-    REASONING: {
-      primary: "anthropic/claude-sonnet-4",
-      // Strong tool use + reasoning for agentic tasks
-      fallback: [
-        "anthropic/claude-opus-4.6",
-        "xai/grok-4-fast-reasoning",
-        "moonshot/kimi-k2.5",
-        "deepseek/deepseek-reasoner"
-      ]
-    }
-  },
-  overrides: {
-    maxTokensForceComplex: 1e5,
-    structuredOutputMinTier: "MEDIUM",
-    ambiguousDefaultTier: "MEDIUM",
-    agenticMode: false
-  }
-};
-// src/router/index.ts
-function route(prompt, systemPrompt, maxOutputTokens, options) {
-  const { config, modelPricing } = options;
-  const fullText = `${systemPrompt ?? ""} ${prompt}`;
-  const estimatedTokens = Math.ceil(fullText.length / 4);
-  const ruleResult = classifyByRules(prompt, systemPrompt, estimatedTokens, config.scoring);
-  const { routingProfile } = options;
-  let tierConfigs;
-  let profileSuffix = "";
-  if (routingProfile === "eco" && config.ecoTiers) {
-    tierConfigs = config.ecoTiers;
-    profileSuffix = " | eco";
-  } else if (routingProfile === "premium" && config.premiumTiers) {
-    tierConfigs = config.premiumTiers;
-    profileSuffix = " | premium";
-  } else {
-    const agenticScore = ruleResult.agenticScore ?? 0;
-    const isAutoAgentic = agenticScore >= 0.5;
-    const isExplicitAgentic = config.overrides.agenticMode ?? false;
-    const useAgenticTiers = (isAutoAgentic || isExplicitAgentic) && config.agenticTiers != null;
-    tierConfigs = useAgenticTiers ? config.agenticTiers : config.tiers;
-    profileSuffix = useAgenticTiers ? " | agentic" : "";
-  }
-  if (estimatedTokens > config.overrides.maxTokensForceComplex) {
-    return selectModel(
-      "COMPLEX",
-      0.95,
-      "rules",
-      `Input exceeds ${config.overrides.maxTokensForceComplex} tokens${profileSuffix}`,
-      tierConfigs,
-      modelPricing,
-      estimatedTokens,
-      maxOutputTokens,
-      routingProfile
-    );
-  }
-  const hasStructuredOutput = systemPrompt ? /json|structured|schema/i.test(systemPrompt) : false;
-  let tier;
-  let confidence;
-  const method = "rules";
-  let reasoning = `score=${ruleResult.score.toFixed(2)} | ${ruleResult.signals.join(", ")}`;
-  if (ruleResult.tier !== null) {
-    tier = ruleResult.tier;
-    confidence = ruleResult.confidence;
-  } else {
-    tier = config.overrides.ambiguousDefaultTier;
-    confidence = 0.5;
-    reasoning += ` | ambiguous -> default: ${tier}`;
-  }
-  if (hasStructuredOutput) {
-    const tierRank = { SIMPLE: 0, MEDIUM: 1, COMPLEX: 2, REASONING: 3 };
-    const minTier = config.overrides.structuredOutputMinTier;
-    if (tierRank[tier] < tierRank[minTier]) {
-      reasoning += ` | upgraded to ${minTier} (structured output)`;
-      tier = minTier;
-    }
-  }
-  reasoning += profileSuffix;
-  return selectModel(
-    tier,
-    confidence,
-    method,
-    reasoning,
-    tierConfigs,
-    modelPricing,
-    estimatedTokens,
-    maxOutputTokens,
-    routingProfile
-  );
-}
-// src/models.ts
-var MODEL_ALIASES = {
-  // Claude
-  claude: "anthropic/claude-sonnet-4",
-  sonnet: "anthropic/claude-sonnet-4",
-  opus: "anthropic/claude-opus-4.6",
-  // Updated to latest Opus 4.6
-  "opus-46": "anthropic/claude-opus-4.6",
-  "opus-45": "anthropic/claude-opus-4.5",
-  haiku: "anthropic/claude-haiku-4.5",
-  // OpenAI
-  gpt: "openai/gpt-4o",
-  gpt4: "openai/gpt-4o",
-  gpt5: "openai/gpt-5.2",
-  codex: "openai/gpt-5.2-codex",
-  mini: "openai/gpt-4o-mini",
-  o3: "openai/o3",
-  // DeepSeek
-  deepseek: "deepseek/deepseek-chat",
-  reasoner: "deepseek/deepseek-reasoner",
-  // Kimi / Moonshot
-  kimi: "moonshot/kimi-k2.5",
-  // Google
-  gemini: "google/gemini-2.5-pro",
-  flash: "google/gemini-2.5-flash",
-  // 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"
-  // Note: auto, free, eco, premium are virtual routing profiles registered in BLOCKRUN_MODELS
-  // They don't need aliases since they're already top-level model IDs
-};
-function resolveModelAlias(model) {
-  const normalized = model.trim().toLowerCase();
-  const resolved = MODEL_ALIASES[normalized];
-  if (resolved) return resolved;
-  if (normalized.startsWith("blockrun/")) {
-    const withoutPrefix = normalized.slice("blockrun/".length);
-    const resolvedWithoutPrefix = MODEL_ALIASES[withoutPrefix];
-    if (resolvedWithoutPrefix) return resolvedWithoutPrefix;
-    return withoutPrefix;
-  }
-  return model;
-}
-var BLOCKRUN_MODELS = [
-  // Smart routing meta-models — proxy replaces with actual model
-  // NOTE: Model IDs are WITHOUT provider prefix (OpenClaw adds "blockrun/" automatically)
-  {
-    id: "auto",
-    name: "Auto (Smart Router - Balanced)",
-    inputPrice: 0,
-    outputPrice: 0,
-    contextWindow: 105e4,
-    maxOutput: 128e3
-  },
-  {
-    id: "free",
-    name: "Free (NVIDIA GPT-OSS-120B only)",
-    inputPrice: 0,
-    outputPrice: 0,
-    contextWindow: 128e3,
-    maxOutput: 4096
-  },
-  {
-    id: "eco",
-    name: "Eco (Smart Router - Cost Optimized)",
-    inputPrice: 0,
-    outputPrice: 0,
-    contextWindow: 105e4,
-    maxOutput: 128e3
-  },
-  {
-    id: "premium",
-    name: "Premium (Smart Router - Best Quality)",
-    inputPrice: 0,
-    outputPrice: 0,
-    contextWindow: 2e6,
-    maxOutput: 2e5
-  },
-  // OpenAI GPT-5 Family
-  {
-    id: "openai/gpt-5.2",
-    name: "GPT-5.2",
-    inputPrice: 1.75,
-    outputPrice: 14,
-    contextWindow: 4e5,
-    maxOutput: 128e3,
-    reasoning: true,
-    vision: true,
-    agentic: true
-  },
-  {
-    id: "openai/gpt-5-mini",
-    name: "GPT-5 Mini",
-    inputPrice: 0.25,
-    outputPrice: 2,
-    contextWindow: 2e5,
-    maxOutput: 65536
-  },
-  {
-    id: "openai/gpt-5-nano",
-    name: "GPT-5 Nano",
-    inputPrice: 0.05,
-    outputPrice: 0.4,
-    contextWindow: 128e3,
-    maxOutput: 32768
-  },
-  {
-    id: "openai/gpt-5.2-pro",
-    name: "GPT-5.2 Pro",
-    inputPrice: 21,
-    outputPrice: 168,
-    contextWindow: 4e5,
-    maxOutput: 128e3,
-    reasoning: true
-  },
-  // OpenAI Codex Family
-  {
-    id: "openai/gpt-5.2-codex",
-    name: "GPT-5.2 Codex",
-    inputPrice: 2.5,
-    outputPrice: 12,
-    contextWindow: 128e3,
-    maxOutput: 32e3,
-    agentic: true
-  },
-  // OpenAI GPT-4 Family
-  {
-    id: "openai/gpt-4.1",
-    name: "GPT-4.1",
-    inputPrice: 2,
-    outputPrice: 8,
-    contextWindow: 128e3,
-    maxOutput: 16384,
-    vision: true
-  },
-  {
-    id: "openai/gpt-4.1-mini",
-    name: "GPT-4.1 Mini",
-    inputPrice: 0.4,
-    outputPrice: 1.6,
-    contextWindow: 128e3,
-    maxOutput: 16384
-  },
-  // gpt-4.1-nano removed - replaced by gpt-5-nano
-  {
-    id: "openai/gpt-4o",
-    name: "GPT-4o",
-    inputPrice: 2.5,
-    outputPrice: 10,
-    contextWindow: 128e3,
-    maxOutput: 16384,
-    vision: true,
-    agentic: true
-  },
-  {
-    id: "openai/gpt-4o-mini",
-    name: "GPT-4o Mini",
-    inputPrice: 0.15,
-    outputPrice: 0.6,
-    contextWindow: 128e3,
-    maxOutput: 16384
-  },
-  // OpenAI O-series (Reasoning) - o1/o1-mini removed, replaced by o3/o4
-  {
-    id: "openai/o3",
-    name: "o3",
-    inputPrice: 2,
-    outputPrice: 8,
-    contextWindow: 2e5,
-    maxOutput: 1e5,
-    reasoning: true
-  },
-  {
-    id: "openai/o3-mini",
-    name: "o3-mini",
-    inputPrice: 1.1,
-    outputPrice: 4.4,
-    contextWindow: 128e3,
-    maxOutput: 65536,
-    reasoning: true
-  },
-  {
-    id: "openai/o4-mini",
-    name: "o4-mini",
-    inputPrice: 1.1,
-    outputPrice: 4.4,
-    contextWindow: 128e3,
-    maxOutput: 65536,
-    reasoning: true
-  },
-  // Anthropic - all Claude models excel at agentic workflows
-  {
-    id: "anthropic/claude-haiku-4.5",
-    name: "Claude Haiku 4.5",
-    inputPrice: 1,
-    outputPrice: 5,
-    contextWindow: 2e5,
-    maxOutput: 8192,
-    agentic: true
-  },
-  {
-    id: "anthropic/claude-sonnet-4",
-    name: "Claude Sonnet 4",
-    inputPrice: 3,
-    outputPrice: 15,
-    contextWindow: 2e5,
-    maxOutput: 64e3,
-    reasoning: true,
-    agentic: true
-  },
-  {
-    id: "anthropic/claude-opus-4",
-    name: "Claude Opus 4",
-    inputPrice: 15,
-    outputPrice: 75,
-    contextWindow: 2e5,
-    maxOutput: 32e3,
-    reasoning: true,
-    agentic: true
-  },
-  {
-    id: "anthropic/claude-opus-4.5",
-    name: "Claude Opus 4.5",
-    inputPrice: 5,
-    outputPrice: 25,
-    contextWindow: 2e5,
-    maxOutput: 32e3,
-    reasoning: true,
-    agentic: true
-  },
-  {
-    id: "anthropic/claude-opus-4.6",
-    name: "Claude Opus 4.6",
-    inputPrice: 5,
-    outputPrice: 25,
-    contextWindow: 2e5,
-    maxOutput: 64e3,
-    reasoning: true,
-    vision: true,
-    agentic: true
-  },
-  // Google
-  {
-    id: "google/gemini-3-pro-preview",
-    name: "Gemini 3 Pro Preview",
-    inputPrice: 2,
-    outputPrice: 12,
-    contextWindow: 105e4,
-    maxOutput: 65536,
-    reasoning: true,
-    vision: true
-  },
-  {
-    id: "google/gemini-2.5-pro",
-    name: "Gemini 2.5 Pro",
-    inputPrice: 1.25,
-    outputPrice: 10,
-    contextWindow: 105e4,
-    maxOutput: 65536,
-    reasoning: true,
-    vision: true
-  },
-  {
-    id: "google/gemini-2.5-flash",
-    name: "Gemini 2.5 Flash",
-    inputPrice: 0.15,
-    outputPrice: 0.6,
-    contextWindow: 1e6,
-    maxOutput: 65536
-  },
-  // DeepSeek
-  {
-    id: "deepseek/deepseek-chat",
-    name: "DeepSeek V3.2 Chat",
-    inputPrice: 0.28,
-    outputPrice: 0.42,
-    contextWindow: 128e3,
-    maxOutput: 8192
-  },
-  {
-    id: "deepseek/deepseek-reasoner",
-    name: "DeepSeek V3.2 Reasoner",
-    inputPrice: 0.28,
-    outputPrice: 0.42,
-    contextWindow: 128e3,
-    maxOutput: 8192,
-    reasoning: true
-  },
-  // Moonshot / Kimi - optimized for agentic workflows
-  {
-    id: "moonshot/kimi-k2.5",
-    name: "Kimi K2.5",
-    inputPrice: 0.5,
-    outputPrice: 2.4,
-    contextWindow: 262144,
-    maxOutput: 8192,
-    reasoning: true,
-    vision: true,
-    agentic: true
-  },
-  // xAI / Grok
-  {
-    id: "xai/grok-3",
-    name: "Grok 3",
-    inputPrice: 3,
-    outputPrice: 15,
-    contextWindow: 131072,
-    maxOutput: 16384,
-    reasoning: true
-  },
-  // grok-3-fast removed - too expensive ($5/$25), use grok-4-fast instead
-  {
-    id: "xai/grok-3-mini",
-    name: "Grok 3 Mini",
-    inputPrice: 0.3,
-    outputPrice: 0.5,
-    contextWindow: 131072,
-    maxOutput: 16384
-  },
-  // xAI Grok 4 Family - Ultra-cheap fast models
-  {
-    id: "xai/grok-4-fast-reasoning",
-    name: "Grok 4 Fast Reasoning",
-    inputPrice: 0.2,
-    outputPrice: 0.5,
-    contextWindow: 131072,
-    maxOutput: 16384,
-    reasoning: true
-  },
-  {
-    id: "xai/grok-4-fast-non-reasoning",
-    name: "Grok 4 Fast",
-    inputPrice: 0.2,
-    outputPrice: 0.5,
-    contextWindow: 131072,
-    maxOutput: 16384
-  },
-  {
-    id: "xai/grok-4-1-fast-reasoning",
-    name: "Grok 4.1 Fast Reasoning",
-    inputPrice: 0.2,
-    outputPrice: 0.5,
-    contextWindow: 131072,
-    maxOutput: 16384,
-    reasoning: true
-  },
-  {
-    id: "xai/grok-4-1-fast-non-reasoning",
-    name: "Grok 4.1 Fast",
-    inputPrice: 0.2,
-    outputPrice: 0.5,
-    contextWindow: 131072,
-    maxOutput: 16384
-  },
-  {
-    id: "xai/grok-code-fast-1",
-    name: "Grok Code Fast",
-    inputPrice: 0.2,
-    outputPrice: 1.5,
-    contextWindow: 131072,
-    maxOutput: 16384,
-    agentic: true
-    // Good for coding tasks
-  },
-  {
-    id: "xai/grok-4-0709",
-    name: "Grok 4 (0709)",
-    inputPrice: 0.2,
-    outputPrice: 1.5,
-    contextWindow: 131072,
-    maxOutput: 16384,
-    reasoning: true
-  },
-  // grok-2-vision removed - old, 0 transactions
-  // NVIDIA - Free/cheap models
-  {
-    id: "nvidia/gpt-oss-120b",
-    name: "NVIDIA GPT-OSS 120B",
-    inputPrice: 0,
-    outputPrice: 0,
-    contextWindow: 128e3,
-    maxOutput: 16384
-  },
-  {
-    id: "nvidia/kimi-k2.5",
-    name: "NVIDIA Kimi K2.5",
-    inputPrice: 0.55,
-    outputPrice: 2.5,
-    contextWindow: 262144,
-    maxOutput: 16384
-  }
-];
-function toOpenClawModel(m) {
-  return {
-    id: m.id,
-    name: m.name,
-    api: "openai-completions",
-    reasoning: m.reasoning ?? false,
-    input: m.vision ? ["text", "image"] : ["text"],
-    cost: {
-      input: m.inputPrice,
-      output: m.outputPrice,
-      cacheRead: 0,
-      cacheWrite: 0
-    },
-    contextWindow: m.contextWindow,
-    maxTokens: m.maxOutput
-  };
-}
-var ALIAS_MODELS = Object.entries(MODEL_ALIASES).map(([alias, targetId]) => {
-  const target = BLOCKRUN_MODELS.find((m) => m.id === targetId);
-  if (!target) return null;
-  return toOpenClawModel({ ...target, id: alias, name: `${alias} \u2192 ${target.name}` });
-}).filter((m) => m !== null);
-var OPENCLAW_MODELS = [
-  ...BLOCKRUN_MODELS.map(toOpenClawModel),
-  ...ALIAS_MODELS
-];
-function getModelContextWindow(modelId) {
-  const normalized = modelId.replace("blockrun/", "");
-  const model = BLOCKRUN_MODELS.find((m) => m.id === normalized);
-  return model?.contextWindow;
-}
-function isReasoningModel(modelId) {
-  const normalized = modelId.replace("blockrun/", "");
-  const model = BLOCKRUN_MODELS.find((m) => m.id === normalized);
-  return model?.reasoning ?? false;
-}
-// src/logger.ts
-import { appendFile, mkdir } from "fs/promises";
-import { join } from "path";
-import { homedir } from "os";
-var LOG_DIR = join(homedir(), ".openclaw", "blockrun", "logs");
-var dirReady = false;
-async function ensureDir() {
-  if (dirReady) return;
-  await mkdir(LOG_DIR, { recursive: true });
-  dirReady = true;
-}
-async function logUsage(entry) {
-  try {
-    await ensureDir();
-    const date = entry.timestamp.slice(0, 10);
-    const file = join(LOG_DIR, `usage-${date}.jsonl`);
-    await appendFile(file, JSON.stringify(entry) + "\n");
-  } catch {
-  }
-}
-// src/stats.ts
-import { readFile, readdir } from "fs/promises";
-import { join as join3 } from "path";
-import { homedir as homedir2 } from "os";
-// src/version.ts
-import { createRequire } from "module";
-import { fileURLToPath } from "url";
-import { dirname, join as join2 } from "path";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-var require2 = createRequire(import.meta.url);
-var pkg = require2(join2(__dirname, "..", "package.json"));
-var VERSION = pkg.version;
-var USER_AGENT = `clawrouter/${VERSION}`;
-// src/stats.ts
-var LOG_DIR2 = join3(homedir2(), ".openclaw", "blockrun", "logs");
-async function parseLogFile(filePath) {
-  try {
-    const content = await readFile(filePath, "utf-8");
-    const lines = content.trim().split("\n").filter(Boolean);
-    return lines.map((line) => {
-      const entry = JSON.parse(line);
-      return {
-        timestamp: entry.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-        model: entry.model || "unknown",
-        tier: entry.tier || "UNKNOWN",
-        cost: entry.cost || 0,
-        baselineCost: entry.baselineCost || entry.cost || 0,
-        savings: entry.savings || 0,
-        latencyMs: entry.latencyMs || 0
-      };
-    });
-  } catch {
-    return [];
-  }
-}
-async function getLogFiles() {
-  try {
-    const files = await readdir(LOG_DIR2);
-    return files.filter((f) => f.startsWith("usage-") && f.endsWith(".jsonl")).sort().reverse();
-  } catch {
-    return [];
-  }
-}
-function aggregateDay(date, entries) {
-  const byTier = {};
-  const byModel = {};
-  let totalLatency = 0;
-  for (const entry of entries) {
-    if (!byTier[entry.tier]) byTier[entry.tier] = { count: 0, cost: 0 };
-    byTier[entry.tier].count++;
-    byTier[entry.tier].cost += entry.cost;
-    if (!byModel[entry.model]) byModel[entry.model] = { count: 0, cost: 0 };
-    byModel[entry.model].count++;
-    byModel[entry.model].cost += entry.cost;
-    totalLatency += entry.latencyMs;
-  }
-  const totalCost = entries.reduce((sum, e) => sum + e.cost, 0);
-  const totalBaselineCost = entries.reduce((sum, e) => sum + e.baselineCost, 0);
-  return {
-    date,
-    totalRequests: entries.length,
-    totalCost,
-    totalBaselineCost,
-    totalSavings: totalBaselineCost - totalCost,
-    avgLatencyMs: entries.length > 0 ? totalLatency / entries.length : 0,
-    byTier,
-    byModel
-  };
-}
-async function getStats(days = 7) {
-  const logFiles = await getLogFiles();
-  const filesToRead = logFiles.slice(0, days);
-  const dailyBreakdown = [];
-  const allByTier = {};
-  const allByModel = {};
-  let totalRequests = 0;
-  let totalCost = 0;
-  let totalBaselineCost = 0;
-  let totalLatency = 0;
-  for (const file of filesToRead) {
-    const date = file.replace("usage-", "").replace(".jsonl", "");
-    const filePath = join3(LOG_DIR2, file);
-    const entries = await parseLogFile(filePath);
-    if (entries.length === 0) continue;
-    const dayStats = aggregateDay(date, entries);
-    dailyBreakdown.push(dayStats);
-    totalRequests += dayStats.totalRequests;
-    totalCost += dayStats.totalCost;
-    totalBaselineCost += dayStats.totalBaselineCost;
-    totalLatency += dayStats.avgLatencyMs * dayStats.totalRequests;
-    for (const [tier, stats] of Object.entries(dayStats.byTier)) {
-      if (!allByTier[tier]) allByTier[tier] = { count: 0, cost: 0 };
-      allByTier[tier].count += stats.count;
-      allByTier[tier].cost += stats.cost;
-    }
-    for (const [model, stats] of Object.entries(dayStats.byModel)) {
-      if (!allByModel[model]) allByModel[model] = { count: 0, cost: 0 };
-      allByModel[model].count += stats.count;
-      allByModel[model].cost += stats.cost;
-    }
-  }
-  const byTierWithPercentage = {};
-  for (const [tier, stats] of Object.entries(allByTier)) {
-    byTierWithPercentage[tier] = {
-      ...stats,
-      percentage: totalRequests > 0 ? stats.count / totalRequests * 100 : 0
-    };
-  }
-  const byModelWithPercentage = {};
-  for (const [model, stats] of Object.entries(allByModel)) {
-    byModelWithPercentage[model] = {
-      ...stats,
-      percentage: totalRequests > 0 ? stats.count / totalRequests * 100 : 0
-    };
-  }
-  const totalSavings = totalBaselineCost - totalCost;
-  const savingsPercentage = totalBaselineCost > 0 ? totalSavings / totalBaselineCost * 100 : 0;
-  let entriesWithBaseline = 0;
-  for (const day of dailyBreakdown) {
-    if (day.totalBaselineCost !== day.totalCost) {
-      entriesWithBaseline += day.totalRequests;
-    }
-  }
-  return {
-    period: days === 1 ? "today" : `last ${days} days`,
-    totalRequests,
-    totalCost,
-    totalBaselineCost,
-    totalSavings,
-    savingsPercentage,
-    avgLatencyMs: totalRequests > 0 ? totalLatency / totalRequests : 0,
-    avgCostPerRequest: totalRequests > 0 ? totalCost / totalRequests : 0,
-    byTier: byTierWithPercentage,
-    byModel: byModelWithPercentage,
-    dailyBreakdown: dailyBreakdown.reverse(),
-    // Oldest first for charts
-    entriesWithBaseline
-    // How many entries have valid baseline tracking
-  };
-}
-// src/dedup.ts
-import { createHash } from "crypto";
-var DEFAULT_TTL_MS2 = 3e4;
-var MAX_BODY_SIZE = 1048576;
-function canonicalize(obj) {
-  if (obj === null || typeof obj !== "object") {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map(canonicalize);
-  }
-  const sorted = {};
-  for (const key of Object.keys(obj).sort()) {
-    sorted[key] = canonicalize(obj[key]);
-  }
-  return sorted;
-}
-var TIMESTAMP_PATTERN = /^\[\w{3}\s+\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}\s+\w+\]\s*/;
-function stripTimestamps(obj) {
-  if (obj === null || typeof obj !== "object") {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map(stripTimestamps);
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (key === "content" && typeof value === "string") {
-      result[key] = value.replace(TIMESTAMP_PATTERN, "");
-    } else {
-      result[key] = stripTimestamps(value);
-    }
-  }
-  return result;
-}
-var RequestDeduplicator = class {
-  inflight = /* @__PURE__ */ new Map();
-  completed = /* @__PURE__ */ new Map();
-  ttlMs;
-  constructor(ttlMs = DEFAULT_TTL_MS2) {
-    this.ttlMs = ttlMs;
-  }
-  /** Hash request body to create a dedup key. */
-  static hash(body) {
-    let content = body;
-    try {
-      const parsed = JSON.parse(body.toString());
-      const stripped = stripTimestamps(parsed);
-      const canonical = canonicalize(stripped);
-      content = Buffer.from(JSON.stringify(canonical));
-    } catch {
-    }
-    return createHash("sha256").update(content).digest("hex").slice(0, 16);
-  }
-  /** Check if a response is cached for this key. */
-  getCached(key) {
-    const entry = this.completed.get(key);
-    if (!entry) return void 0;
-    if (Date.now() - entry.completedAt > this.ttlMs) {
-      this.completed.delete(key);
-      return void 0;
-    }
-    return entry;
-  }
-  /** Check if a request with this key is currently in-flight. Returns a promise to wait on. */
-  getInflight(key) {
-    const entry = this.inflight.get(key);
-    if (!entry) return void 0;
-    return new Promise((resolve) => {
-      entry.resolvers.push(resolve);
-    });
-  }
-  /** Mark a request as in-flight. */
-  markInflight(key) {
-    this.inflight.set(key, {
-      resolvers: []
-    });
-  }
-  /** Complete an in-flight request — cache result and notify waiters. */
-  complete(key, result) {
-    if (result.body.length <= MAX_BODY_SIZE) {
-      this.completed.set(key, result);
-    }
-    const entry = this.inflight.get(key);
-    if (entry) {
-      for (const resolve of entry.resolvers) {
-        resolve(result);
-      }
-      this.inflight.delete(key);
-    }
-    this.prune();
-  }
-  /** Remove an in-flight entry on error (don't cache failures).
-   *  Also rejects any waiters so they can retry independently. */
-  removeInflight(key) {
-    const entry = this.inflight.get(key);
-    if (entry) {
-      const errorBody = Buffer.from(
-        JSON.stringify({
-          error: { message: "Original request failed, please retry", type: "dedup_origin_failed" }
-        })
-      );
-      for (const resolve of entry.resolvers) {
-        resolve({
-          status: 503,
-          headers: { "content-type": "application/json" },
-          body: errorBody,
-          completedAt: Date.now()
-        });
-      }
-      this.inflight.delete(key);
-    }
-  }
-  /** Prune expired completed entries. */
-  prune() {
-    const now = Date.now();
-    for (const [key, entry] of this.completed) {
-      if (now - entry.completedAt > this.ttlMs) {
-        this.completed.delete(key);
-      }
-    }
-  }
-};
-// src/response-cache.ts
-import { createHash as createHash2 } from "crypto";
-var DEFAULT_CONFIG = {
-  maxSize: 200,
-  defaultTTL: 600,
-  maxItemSize: 1048576,
-  // 1MB
-  enabled: true
-};
-function canonicalize2(obj) {
-  if (obj === null || typeof obj !== "object") {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map(canonicalize2);
-  }
-  const sorted = {};
-  for (const key of Object.keys(obj).sort()) {
-    sorted[key] = canonicalize2(obj[key]);
-  }
-  return sorted;
-}
-var TIMESTAMP_PATTERN2 = /^\[\w{3}\s+\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}\s+\w+\]\s*/;
-function normalizeForCache(obj) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (["stream", "user", "request_id", "x-request-id"].includes(key)) {
-      continue;
-    }
-    if (key === "messages" && Array.isArray(value)) {
-      result[key] = value.map((msg) => {
-        if (typeof msg === "object" && msg !== null) {
-          const m = msg;
-          if (typeof m.content === "string") {
-            return { ...m, content: m.content.replace(TIMESTAMP_PATTERN2, "") };
-          }
-        }
-        return msg;
-      });
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-var ResponseCache = class {
-  cache = /* @__PURE__ */ new Map();
-  expirationHeap = [];
-  config;
-  // Stats for monitoring
-  stats = {
-    hits: 0,
-    misses: 0,
-    evictions: 0
-  };
-  constructor(config = {}) {
-    const filtered = Object.fromEntries(
-      Object.entries(config).filter(([, v]) => v !== void 0)
-    );
-    this.config = { ...DEFAULT_CONFIG, ...filtered };
-  }
-  /**
-   * Generate cache key from request body.
-   * Hashes: model + messages + temperature + max_tokens + other params
-   */
-  static generateKey(body) {
-    try {
-      const parsed = JSON.parse(typeof body === "string" ? body : body.toString());
-      const normalized = normalizeForCache(parsed);
-      const canonical = canonicalize2(normalized);
-      const keyContent = JSON.stringify(canonical);
-      return createHash2("sha256").update(keyContent).digest("hex").slice(0, 32);
-    } catch {
-      const content = typeof body === "string" ? body : body.toString();
-      return createHash2("sha256").update(content).digest("hex").slice(0, 32);
-    }
-  }
-  /**
-   * Check if caching is enabled for this request.
-   * Respects cache control headers and request params.
-   */
-  shouldCache(body, headers) {
-    if (!this.config.enabled) return false;
-    if (headers?.["cache-control"]?.includes("no-cache")) {
-      return false;
-    }
-    try {
-      const parsed = JSON.parse(typeof body === "string" ? body : body.toString());
-      if (parsed.cache === false || parsed.no_cache === true) {
-        return false;
-      }
-    } catch {
-    }
-    return true;
-  }
-  /**
-   * Get cached response if available and not expired.
-   */
-  get(key) {
-    const entry = this.cache.get(key);
-    if (!entry) {
-      this.stats.misses++;
-      return void 0;
-    }
-    if (Date.now() > entry.expiresAt) {
-      this.cache.delete(key);
-      this.stats.misses++;
-      return void 0;
-    }
-    this.stats.hits++;
-    return entry;
-  }
-  /**
-   * Cache a response with optional custom TTL.
-   */
-  set(key, response, ttlSeconds) {
-    if (!this.config.enabled || this.config.maxSize <= 0) return;
-    if (response.body.length > this.config.maxItemSize) {
-      console.log(`[ResponseCache] Skipping cache - item too large: ${response.body.length} bytes`);
-      return;
-    }
-    if (response.status >= 400) {
-      return;
-    }
-    if (this.cache.size >= this.config.maxSize) {
-      this.evict();
-    }
-    const now = Date.now();
-    const ttl = ttlSeconds ?? this.config.defaultTTL;
-    const expiresAt = now + ttl * 1e3;
-    const entry = {
-      ...response,
-      cachedAt: now,
-      expiresAt
-    };
-    this.cache.set(key, entry);
-    this.expirationHeap.push({ expiresAt, key });
-  }
-  /**
-   * Evict expired and oldest entries to make room.
-   */
-  evict() {
-    const now = Date.now();
-    this.expirationHeap.sort((a, b) => a.expiresAt - b.expiresAt);
-    while (this.expirationHeap.length > 0) {
-      const oldest = this.expirationHeap[0];
-      const entry = this.cache.get(oldest.key);
-      if (!entry || entry.expiresAt !== oldest.expiresAt) {
-        this.expirationHeap.shift();
-        continue;
-      }
-      if (oldest.expiresAt <= now) {
-        this.cache.delete(oldest.key);
-        this.expirationHeap.shift();
-        this.stats.evictions++;
-      } else {
-        break;
-      }
-    }
-    while (this.cache.size >= this.config.maxSize && this.expirationHeap.length > 0) {
-      const oldest = this.expirationHeap.shift();
-      if (this.cache.has(oldest.key)) {
-        this.cache.delete(oldest.key);
-        this.stats.evictions++;
-      }
-    }
-  }
-  /**
-   * Get cache statistics.
-   */
-  getStats() {
-    const total = this.stats.hits + this.stats.misses;
-    const hitRate = total > 0 ? (this.stats.hits / total * 100).toFixed(1) + "%" : "0%";
-    return {
-      size: this.cache.size,
-      maxSize: this.config.maxSize,
-      hits: this.stats.hits,
-      misses: this.stats.misses,
-      evictions: this.stats.evictions,
-      hitRate
-    };
-  }
-  /**
-   * Clear all cached entries.
-   */
-  clear() {
-    this.cache.clear();
-    this.expirationHeap = [];
-  }
-  /**
-   * Check if cache is enabled.
-   */
-  isEnabled() {
-    return this.config.enabled;
-  }
-};
-// 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_BASE2 = "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 && now - this.cachedAt < CACHE_TTL_MS) {
-      return this.buildInfo(this.cachedBalance);
-    }
-    const balance = await this.fetchBalance();
-    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_BASE2,
-        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/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,
-  timeoutMs: 30 * 60 * 1e3,
-  // 30 minutes
-  headerName: "x-session-id"
-};
-var SessionStore = class {
-  sessions = /* @__PURE__ */ new Map();
-  config;
-  cleanupInterval = null;
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_SESSION_CONFIG, ...config };
-    if (this.config.enabled) {
-      this.cleanupInterval = setInterval(() => this.cleanup(), 5 * 60 * 1e3);
-    }
-  }
-  /**
-   * Get the pinned model for a session, if any.
-   */
-  getSession(sessionId) {
-    if (!this.config.enabled || !sessionId) {
-      return void 0;
-    }
-    const entry = this.sessions.get(sessionId);
-    if (!entry) {
-      return void 0;
-    }
-    const now = Date.now();
-    if (now - entry.lastUsedAt > this.config.timeoutMs) {
-      this.sessions.delete(sessionId);
-      return void 0;
-    }
-    return entry;
-  }
-  /**
-   * Pin a model to a session.
-   */
-  setSession(sessionId, model, tier) {
-    if (!this.config.enabled || !sessionId) {
-      return;
-    }
-    const existing = this.sessions.get(sessionId);
-    const now = Date.now();
-    if (existing) {
-      existing.lastUsedAt = now;
-      existing.requestCount++;
-      if (existing.model !== model) {
-        existing.model = model;
-        existing.tier = tier;
-      }
-    } else {
-      this.sessions.set(sessionId, {
-        model,
-        tier,
-        createdAt: now,
-        lastUsedAt: now,
-        requestCount: 1
-      });
-    }
-  }
-  /**
-   * Touch a session to extend its timeout.
-   */
-  touchSession(sessionId) {
-    if (!this.config.enabled || !sessionId) {
-      return;
-    }
-    const entry = this.sessions.get(sessionId);
-    if (entry) {
-      entry.lastUsedAt = Date.now();
-      entry.requestCount++;
-    }
-  }
-  /**
-   * Clear a specific session.
-   */
-  clearSession(sessionId) {
-    this.sessions.delete(sessionId);
-  }
-  /**
-   * Clear all sessions.
-   */
-  clearAll() {
-    this.sessions.clear();
-  }
-  /**
-   * Get session stats for debugging.
-   */
-  getStats() {
-    const now = Date.now();
-    const sessions = Array.from(this.sessions.entries()).map(([id, entry]) => ({
-      id: id.slice(0, 8) + "...",
-      model: entry.model,
-      age: Math.round((now - entry.createdAt) / 1e3)
-    }));
-    return { count: this.sessions.size, sessions };
-  }
-  /**
-   * Clean up expired sessions.
-   */
-  cleanup() {
-    const now = Date.now();
-    for (const [id, entry] of this.sessions) {
-      if (now - entry.lastUsedAt > this.config.timeoutMs) {
-        this.sessions.delete(id);
-      }
-    }
-  }
-  /**
-   * Stop the cleanup interval.
-   */
-  close() {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-  }
-};
-function getSessionId(headers, headerName = DEFAULT_SESSION_CONFIG.headerName) {
-  const value = headers[headerName] || headers[headerName.toLowerCase()];
-  if (typeof value === "string" && value.length > 0) {
-    return value;
-  }
-  if (Array.isArray(value) && value.length > 0) {
-    return value[0];
-  }
-  return void 0;
-}
-// src/updater.ts
-var NPM_REGISTRY = "https://registry.npmjs.org/@blockrun/clawrouter/latest";
-var UPDATE_URL = "https://blockrun.ai/ClawRouter-update";
-var CHECK_TIMEOUT_MS = 5e3;
-function compareSemver(a, b) {
-  const pa = a.split(".").map(Number);
-  const pb = b.split(".").map(Number);
-  for (let i = 0; i < 3; i++) {
-    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
-    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
-  }
-  return 0;
-}
-async function checkForUpdates() {
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS);
-    const res = await fetch(NPM_REGISTRY, {
-      signal: controller.signal,
-      headers: { Accept: "application/json" }
-    });
-    clearTimeout(timeout);
-    if (!res.ok) return;
-    const data = await res.json();
-    const latest = data.version;
-    if (!latest) return;
-    if (compareSemver(latest, VERSION) > 0) {
-      console.log("");
-      console.log(`\x1B[33m\u2B06\uFE0F  ClawRouter ${latest} available (you have ${VERSION})\x1B[0m`);
-      console.log(`   Run: \x1B[36mcurl -fsSL ${UPDATE_URL} | bash\x1B[0m`);
-      console.log("");
-    }
-  } catch {
-  }
-}
-// src/config.ts
-var DEFAULT_PORT = 8402;
-var PROXY_PORT = (() => {
-  const envPort = process.env.BLOCKRUN_PROXY_PORT;
-  if (envPort) {
-    const parsed = parseInt(envPort, 10);
-    if (!isNaN(parsed) && parsed > 0 && parsed < 65536) {
-      return parsed;
-    }
-  }
-  return DEFAULT_PORT;
-})();
-// src/proxy.ts
-var BLOCKRUN_API = "https://blockrun.ai/api";
-var AUTO_MODEL = "blockrun/auto";
-var ROUTING_PROFILES = /* @__PURE__ */ new Set([
-  "blockrun/free",
-  "free",
-  "blockrun/eco",
-  "eco",
-  "blockrun/auto",
-  "auto",
-  "blockrun/premium",
-  "premium"
-]);
-var FREE_MODEL = "nvidia/gpt-oss-120b";
-var MAX_MESSAGES = 200;
-var HEARTBEAT_INTERVAL_MS = 2e3;
-var DEFAULT_REQUEST_TIMEOUT_MS = 18e4;
-var MAX_FALLBACK_ATTEMPTS = 5;
-var HEALTH_CHECK_TIMEOUT_MS = 2e3;
-var RATE_LIMIT_COOLDOWN_MS = 6e4;
-var PORT_RETRY_ATTEMPTS = 5;
-var PORT_RETRY_DELAY_MS = 1e3;
-function transformPaymentError(errorBody) {
-  try {
-    const parsed = JSON.parse(errorBody);
-    if (parsed.error === "Payment verification failed" && parsed.details) {
-      const match = parsed.details.match(/Verification failed:\s*(\{.*\})/s);
-      if (match) {
-        const innerJson = JSON.parse(match[1]);
-        if (innerJson.invalidReason === "insufficient_funds" && innerJson.invalidMessage) {
-          const balanceMatch = innerJson.invalidMessage.match(
-            /insufficient balance:\s*(\d+)\s*<\s*(\d+)/i
-          );
-          if (balanceMatch) {
-            const currentMicros = parseInt(balanceMatch[1], 10);
-            const requiredMicros = parseInt(balanceMatch[2], 10);
-            const currentUSD = (currentMicros / 1e6).toFixed(6);
-            const requiredUSD = (requiredMicros / 1e6).toFixed(6);
-            const wallet = innerJson.payer || "unknown";
-            const shortWallet = wallet.length > 12 ? `${wallet.slice(0, 6)}...${wallet.slice(-4)}` : wallet;
-            return JSON.stringify({
-              error: {
-                message: `Insufficient USDC balance. Current: $${currentUSD}, Required: ~$${requiredUSD}`,
-                type: "insufficient_funds",
-                wallet,
-                current_balance_usd: currentUSD,
-                required_usd: requiredUSD,
-                help: `Fund wallet ${shortWallet} with USDC on Base, or use free model: /model free`
-              }
-            });
-          }
-        }
-        if (innerJson.invalidReason === "invalid_payload") {
-          return JSON.stringify({
-            error: {
-              message: "Payment signature invalid. This may be a temporary issue.",
-              type: "invalid_payload",
-              help: "Try again. If this persists, reinstall ClawRouter: curl -fsSL https://blockrun.ai/ClawRouter-update | bash"
-            }
-          });
-        }
-      }
-    }
-    if (parsed.error === "Settlement failed" || parsed.details?.includes("Settlement failed")) {
-      const details = parsed.details || "";
-      const gasError = details.includes("unable to estimate gas");
-      return JSON.stringify({
-        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"
-        }
-      });
-    }
-  } catch {
-  }
-  return errorBody;
-}
-var rateLimitedModels = /* @__PURE__ */ new Map();
-function isRateLimited(modelId) {
-  const hitTime = rateLimitedModels.get(modelId);
-  if (!hitTime) return false;
-  const elapsed = Date.now() - hitTime;
-  if (elapsed >= RATE_LIMIT_COOLDOWN_MS) {
-    rateLimitedModels.delete(modelId);
-    return false;
-  }
-  return true;
-}
-function markRateLimited(modelId) {
-  rateLimitedModels.set(modelId, Date.now());
-  console.log(`[ClawRouter] Model ${modelId} rate-limited, will deprioritize for 60s`);
-}
-function prioritizeNonRateLimited(models) {
-  const available = [];
-  const rateLimited = [];
-  for (const model of models) {
-    if (isRateLimited(model)) {
-      rateLimited.push(model);
-    } else {
-      available.push(model);
-    }
-  }
-  return [...available, ...rateLimited];
-}
-function canWrite(res) {
-  return !res.writableEnded && !res.destroyed && res.socket !== null && !res.socket.destroyed && res.socket.writable;
-}
-function safeWrite(res, data) {
-  if (!canWrite(res)) {
-    return false;
-  }
-  return res.write(data);
-}
-var BALANCE_CHECK_BUFFER = 1.5;
-function getProxyPort() {
-  return PROXY_PORT;
-}
-async function checkExistingProxy(port) {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), HEALTH_CHECK_TIMEOUT_MS);
-  try {
-    const response = await fetch(`http://127.0.0.1:${port}/health`, {
-      signal: controller.signal
-    });
-    clearTimeout(timeoutId);
-    if (response.ok) {
-      const data = await response.json();
-      if (data.status === "ok" && data.wallet) {
-        return data.wallet;
-      }
-    }
-    return void 0;
-  } catch {
-    clearTimeout(timeoutId);
-    return void 0;
-  }
-}
-var PROVIDER_ERROR_PATTERNS = [
-  /billing/i,
-  /insufficient.*balance/i,
-  /credits/i,
-  /quota.*exceeded/i,
-  /rate.*limit/i,
-  /model.*unavailable/i,
-  /model.*not.*available/i,
-  /service.*unavailable/i,
-  /capacity/i,
-  /overloaded/i,
-  /temporarily.*unavailable/i,
-  /api.*key.*invalid/i,
-  /authentication.*failed/i,
-  /request too large/i,
-  /request.*size.*exceeds/i,
-  /payload too large/i
-];
-var FALLBACK_STATUS_CODES = [
-  400,
-  // Bad request - sometimes used for billing errors
-  401,
-  // Unauthorized - provider API key issues
-  402,
-  // Payment required - but from upstream, not x402
-  403,
-  // Forbidden - provider restrictions
-  413,
-  // Payload too large - request exceeds model's context limit
-  429,
-  // Rate limited
-  500,
-  // Internal server error
-  502,
-  // Bad gateway
-  503,
-  // Service unavailable
-  504
-  // Gateway timeout
-];
-function isProviderError(status, body) {
-  if (!FALLBACK_STATUS_CODES.includes(status)) {
-    return false;
-  }
-  if (status >= 500) {
-    return true;
-  }
-  return PROVIDER_ERROR_PATTERNS.some((pattern) => pattern.test(body));
-}
-var VALID_ROLES = /* @__PURE__ */ new Set(["system", "user", "assistant", "tool", "function"]);
-var ROLE_MAPPINGS = {
-  developer: "system",
-  // OpenAI's newer API uses "developer" for system messages
-  model: "assistant"
-  // Some APIs use "model" instead of "assistant"
-};
-var VALID_TOOL_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
-function sanitizeToolId(id) {
-  if (!id || typeof id !== "string") return id;
-  if (VALID_TOOL_ID_PATTERN.test(id)) return id;
-  return id.replace(/[^a-zA-Z0-9_-]/g, "_");
-}
-function sanitizeToolIds(messages) {
-  if (!messages || messages.length === 0) return messages;
-  let hasChanges = false;
-  const sanitized = messages.map((msg) => {
-    const typedMsg = msg;
-    let msgChanged = false;
-    let newMsg = { ...msg };
-    if (typedMsg.tool_calls && Array.isArray(typedMsg.tool_calls)) {
-      const newToolCalls = typedMsg.tool_calls.map((tc) => {
-        if (tc.id && typeof tc.id === "string") {
-          const sanitized2 = sanitizeToolId(tc.id);
-          if (sanitized2 !== tc.id) {
-            msgChanged = true;
-            return { ...tc, id: sanitized2 };
-          }
-        }
-        return tc;
-      });
-      if (msgChanged) {
-        newMsg = { ...newMsg, tool_calls: newToolCalls };
-      }
-    }
-    if (typedMsg.tool_call_id && typeof typedMsg.tool_call_id === "string") {
-      const sanitized2 = sanitizeToolId(typedMsg.tool_call_id);
-      if (sanitized2 !== typedMsg.tool_call_id) {
-        msgChanged = true;
-        newMsg = { ...newMsg, tool_call_id: sanitized2 };
-      }
-    }
-    if (Array.isArray(typedMsg.content)) {
-      const newContent = typedMsg.content.map((block) => {
-        if (!block || typeof block !== "object") return block;
-        let blockChanged = false;
-        let newBlock = { ...block };
-        if (block.type === "tool_use" && block.id && typeof block.id === "string") {
-          const sanitized2 = sanitizeToolId(block.id);
-          if (sanitized2 !== block.id) {
-            blockChanged = true;
-            newBlock = { ...newBlock, id: sanitized2 };
-          }
-        }
-        if (block.type === "tool_result" && block.tool_use_id && typeof block.tool_use_id === "string") {
-          const sanitized2 = sanitizeToolId(block.tool_use_id);
-          if (sanitized2 !== block.tool_use_id) {
-            blockChanged = true;
-            newBlock = { ...newBlock, tool_use_id: sanitized2 };
-          }
-        }
-        if (blockChanged) {
-          msgChanged = true;
-          return newBlock;
-        }
-        return block;
-      });
-      if (msgChanged) {
-        newMsg = { ...newMsg, content: newContent };
-      }
-    }
-    if (msgChanged) {
-      hasChanges = true;
-      return newMsg;
-    }
-    return msg;
-  });
-  return hasChanges ? sanitized : messages;
-}
-function normalizeMessageRoles(messages) {
-  if (!messages || messages.length === 0) return messages;
-  let hasChanges = false;
-  const normalized = messages.map((msg) => {
-    if (VALID_ROLES.has(msg.role)) return msg;
-    const mappedRole = ROLE_MAPPINGS[msg.role];
-    if (mappedRole) {
-      hasChanges = true;
-      return { ...msg, role: mappedRole };
-    }
-    hasChanges = true;
-    return { ...msg, role: "user" };
-  });
-  return hasChanges ? normalized : messages;
-}
-function normalizeMessagesForGoogle(messages) {
-  if (!messages || messages.length === 0) return messages;
-  let firstNonSystemIdx = -1;
-  for (let i = 0; i < messages.length; i++) {
-    if (messages[i].role !== "system") {
-      firstNonSystemIdx = i;
-      break;
-    }
-  }
-  if (firstNonSystemIdx === -1) return messages;
-  const firstRole = messages[firstNonSystemIdx].role;
-  if (firstRole === "user") return messages;
-  if (firstRole === "assistant" || firstRole === "model") {
-    const normalized = [...messages];
-    normalized.splice(firstNonSystemIdx, 0, {
-      role: "user",
-      content: "(continuing conversation)"
-    });
-    return normalized;
-  }
-  return messages;
-}
-function isGoogleModel(modelId) {
-  return modelId.startsWith("google/") || modelId.startsWith("gemini");
-}
-function normalizeMessagesForThinking(messages) {
-  if (!messages || messages.length === 0) return messages;
-  let hasChanges = false;
-  const normalized = messages.map((msg) => {
-    if (msg.role !== "assistant" || msg.reasoning_content !== void 0) {
-      return msg;
-    }
-    const hasOpenAIToolCalls = msg.tool_calls && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
-    const hasAnthropicToolUse = Array.isArray(msg.content) && msg.content.some((block) => block?.type === "tool_use");
-    if (hasOpenAIToolCalls || hasAnthropicToolUse) {
-      hasChanges = true;
-      return { ...msg, reasoning_content: "" };
-    }
-    return msg;
-  });
-  return hasChanges ? normalized : messages;
-}
-function truncateMessages(messages) {
-  if (!messages || messages.length <= MAX_MESSAGES) return messages;
-  const systemMsgs = messages.filter((m) => m.role === "system");
-  const conversationMsgs = messages.filter((m) => m.role !== "system");
-  const maxConversation = MAX_MESSAGES - systemMsgs.length;
-  const truncatedConversation = conversationMsgs.slice(-maxConversation);
-  console.log(
-    `[ClawRouter] Truncated messages: ${messages.length} \u2192 ${systemMsgs.length + truncatedConversation.length} (kept ${systemMsgs.length} system + ${truncatedConversation.length} recent)`
-  );
-  return [...systemMsgs, ...truncatedConversation];
-}
-var KIMI_BLOCK_RE = /<[｜|][^<>]*begin[^<>]*[｜|]>[\s\S]*?<[｜|][^<>]*end[^<>]*[｜|]>/gi;
-var KIMI_TOKEN_RE = /<[｜|][^<>]*[｜|]>/g;
-var THINKING_TAG_RE = /<\s*\/?\s*(?:think(?:ing)?|thought|antthinking)\b[^>]*>/gi;
-var THINKING_BLOCK_RE = /<\s*(?:think(?:ing)?|thought|antthinking)\b[^>]*>[\s\S]*?<\s*\/\s*(?:think(?:ing)?|thought|antthinking)\s*>/gi;
-function stripThinkingTokens(content) {
-  if (!content) return content;
-  let cleaned = content.replace(KIMI_BLOCK_RE, "");
-  cleaned = cleaned.replace(KIMI_TOKEN_RE, "");
-  cleaned = cleaned.replace(THINKING_BLOCK_RE, "");
-  cleaned = cleaned.replace(THINKING_TAG_RE, "");
-  return cleaned;
-}
-function buildModelPricing() {
-  const map = /* @__PURE__ */ new Map();
-  for (const m of BLOCKRUN_MODELS) {
-    if (m.id === AUTO_MODEL) continue;
-    map.set(m.id, { inputPrice: m.inputPrice, outputPrice: m.outputPrice });
-  }
-  return map;
-}
-function mergeRoutingConfig(overrides) {
-  if (!overrides) return DEFAULT_ROUTING_CONFIG;
-  return {
-    ...DEFAULT_ROUTING_CONFIG,
-    ...overrides,
-    classifier: { ...DEFAULT_ROUTING_CONFIG.classifier, ...overrides.classifier },
-    scoring: { ...DEFAULT_ROUTING_CONFIG.scoring, ...overrides.scoring },
-    tiers: { ...DEFAULT_ROUTING_CONFIG.tiers, ...overrides.tiers },
-    overrides: { ...DEFAULT_ROUTING_CONFIG.overrides, ...overrides.overrides }
-  };
-}
-function estimateAmount(modelId, bodyLength, maxTokens) {
-  const model = BLOCKRUN_MODELS.find((m) => m.id === modelId);
-  if (!model) return void 0;
-  const estimatedInputTokens = Math.ceil(bodyLength / 4);
-  const estimatedOutputTokens = maxTokens || model.maxOutput || 4096;
-  const costUsd = estimatedInputTokens / 1e6 * model.inputPrice + estimatedOutputTokens / 1e6 * model.outputPrice;
-  const amountMicros = Math.max(100, Math.ceil(costUsd * 1.2 * 1e6));
-  return amountMicros.toString();
-}
-async function startProxy(options) {
-  const apiBase = options.apiBase ?? BLOCKRUN_API;
-  const listenPort = options.port ?? getProxyPort();
-  const existingWallet = await checkExistingProxy(listenPort);
-  if (existingWallet) {
-    const account2 = privateKeyToAccount2(options.walletKey);
-    const balanceMonitor2 = new BalanceMonitor(account2.address);
-    const baseUrl2 = `http://127.0.0.1:${listenPort}`;
-    if (existingWallet !== account2.address) {
-      console.warn(
-        `[ClawRouter] Existing proxy on port ${listenPort} uses wallet ${existingWallet}, but current config uses ${account2.address}. Reusing existing proxy.`
-      );
-    }
-    options.onReady?.(listenPort);
-    return {
-      port: listenPort,
-      baseUrl: baseUrl2,
-      walletAddress: existingWallet,
-      balanceMonitor: balanceMonitor2,
-      close: async () => {
-      }
-    };
-  }
-  const account = privateKeyToAccount2(options.walletKey);
-  const { fetch: payFetch } = createPaymentFetch(options.walletKey);
-  const balanceMonitor = new BalanceMonitor(account.address);
-  const routingConfig = mergeRoutingConfig(options.routingConfig);
-  const modelPricing = buildModelPricing();
-  const routerOpts = {
-    config: routingConfig,
-    modelPricing
-  };
-  const deduplicator = new RequestDeduplicator();
-  const responseCache = new ResponseCache(options.cacheConfig);
-  const sessionStore = new SessionStore(options.sessionConfig);
-  const connections = /* @__PURE__ */ new Set();
-  const server = createServer(async (req, res) => {
-    req.on("error", (err) => {
-      console.error(`[ClawRouter] Request stream error: ${err.message}`);
-    });
-    res.on("error", (err) => {
-      console.error(`[ClawRouter] Response stream error: ${err.message}`);
-    });
-    finished(res, (err) => {
-      if (err && err.code !== "ERR_STREAM_DESTROYED") {
-        console.error(`[ClawRouter] Response finished with error: ${err.message}`);
-      }
-    });
-    finished(req, (err) => {
-      if (err && err.code !== "ERR_STREAM_DESTROYED") {
-        console.error(`[ClawRouter] Request finished with error: ${err.message}`);
-      }
-    });
-    if (req.url === "/health" || req.url?.startsWith("/health?")) {
-      const url = new URL(req.url, "http://localhost");
-      const full = url.searchParams.get("full") === "true";
-      const response = {
-        status: "ok",
-        wallet: account.address
-      };
-      if (full) {
-        try {
-          const balanceInfo = await balanceMonitor.checkBalance();
-          response.balance = balanceInfo.balanceUSD;
-          response.isLow = balanceInfo.isLow;
-          response.isEmpty = balanceInfo.isEmpty;
-        } catch {
-          response.balanceError = "Could not fetch balance";
-        }
-      }
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify(response));
-      return;
-    }
-    if (req.url === "/cache" || req.url?.startsWith("/cache?")) {
-      const stats = responseCache.getStats();
-      res.writeHead(200, {
-        "Content-Type": "application/json",
-        "Cache-Control": "no-cache"
-      });
-      res.end(JSON.stringify(stats, null, 2));
-      return;
-    }
-    if (req.url === "/stats" || req.url?.startsWith("/stats?")) {
-      try {
-        const url = new URL(req.url, "http://localhost");
-        const days = parseInt(url.searchParams.get("days") || "7", 10);
-        const stats = await getStats(Math.min(days, 30));
-        res.writeHead(200, {
-          "Content-Type": "application/json",
-          "Cache-Control": "no-cache"
-        });
-        res.end(JSON.stringify(stats, null, 2));
-      } catch (err) {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(
-          JSON.stringify({
-            error: `Failed to get stats: ${err instanceof Error ? err.message : String(err)}`
-          })
-        );
-      }
-      return;
-    }
-    if (req.url === "/v1/models" && req.method === "GET") {
-      const models = BLOCKRUN_MODELS.filter((m) => m.id !== "blockrun/auto").map((m) => ({
-        id: m.id,
-        object: "model",
-        created: Math.floor(Date.now() / 1e3),
-        owned_by: m.id.split("/")[0] || "unknown"
-      }));
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ object: "list", data: models }));
-      return;
-    }
-    if (!req.url?.startsWith("/v1")) {
-      res.writeHead(404, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "Not found" }));
-      return;
-    }
-    try {
-      await proxyRequest(
-        req,
-        res,
-        apiBase,
-        payFetch,
-        options,
-        routerOpts,
-        deduplicator,
-        balanceMonitor,
-        sessionStore,
-        responseCache
-      );
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      options.onError?.(error);
-      if (!res.headersSent) {
-        res.writeHead(502, { "Content-Type": "application/json" });
-        res.end(
-          JSON.stringify({
-            error: { message: `Proxy error: ${error.message}`, type: "proxy_error" }
-          })
-        );
-      } else if (!res.writableEnded) {
-        res.write(
-          `data: ${JSON.stringify({ error: { message: error.message, type: "proxy_error" } })}
-`
-        );
-        res.write("data: [DONE]\n\n");
-        res.end();
-      }
-    }
-  });
-  const tryListen = (attempt) => {
-    return new Promise((resolveAttempt, rejectAttempt) => {
-      const onError = async (err) => {
-        server.removeListener("error", onError);
-        if (err.code === "EADDRINUSE") {
-          const existingWallet2 = await checkExistingProxy(listenPort);
-          if (existingWallet2) {
-            console.log(`[ClawRouter] Existing proxy detected on port ${listenPort}, reusing`);
-            rejectAttempt({ code: "REUSE_EXISTING", wallet: existingWallet2 });
-            return;
-          }
-          if (attempt < PORT_RETRY_ATTEMPTS) {
-            console.log(
-              `[ClawRouter] Port ${listenPort} in TIME_WAIT, retrying in ${PORT_RETRY_DELAY_MS}ms (attempt ${attempt}/${PORT_RETRY_ATTEMPTS})`
-            );
-            rejectAttempt({ code: "RETRY", attempt });
-            return;
-          }
-          console.error(
-            `[ClawRouter] Port ${listenPort} still in use after ${PORT_RETRY_ATTEMPTS} attempts`
-          );
-          rejectAttempt(err);
-          return;
-        }
-        rejectAttempt(err);
-      };
-      server.once("error", onError);
-      server.listen(listenPort, "127.0.0.1", () => {
-        server.removeListener("error", onError);
-        resolveAttempt();
-      });
-    });
-  };
-  let lastError;
-  for (let attempt = 1; attempt <= PORT_RETRY_ATTEMPTS; attempt++) {
-    try {
-      await tryListen(attempt);
-      break;
-    } catch (err) {
-      const error = err;
-      if (error.code === "REUSE_EXISTING" && error.wallet) {
-        const baseUrl2 = `http://127.0.0.1:${listenPort}`;
-        options.onReady?.(listenPort);
-        return {
-          port: listenPort,
-          baseUrl: baseUrl2,
-          walletAddress: error.wallet,
-          balanceMonitor,
-          close: async () => {
-          }
-        };
-      }
-      if (error.code === "RETRY") {
-        await new Promise((r) => setTimeout(r, PORT_RETRY_DELAY_MS));
-        continue;
-      }
-      lastError = err;
-      break;
-    }
-  }
-  if (lastError) {
-    throw lastError;
-  }
-  const addr = server.address();
-  const port = addr.port;
-  const baseUrl = `http://127.0.0.1:${port}`;
-  options.onReady?.(port);
-  checkForUpdates();
-  server.on("error", (err) => {
-    console.error(`[ClawRouter] Server runtime error: ${err.message}`);
-    options.onError?.(err);
-  });
-  server.on("clientError", (err, socket) => {
-    console.error(`[ClawRouter] Client error: ${err.message}`);
-    if (socket.writable && !socket.destroyed) {
-      socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
-    }
-  });
-  server.on("connection", (socket) => {
-    connections.add(socket);
-    socket.setTimeout(3e5);
-    socket.on("timeout", () => {
-      console.error(`[ClawRouter] Socket timeout, destroying connection`);
-      socket.destroy();
-    });
-    socket.on("end", () => {
-    });
-    socket.on("error", (err) => {
-      console.error(`[ClawRouter] Socket error: ${err.message}`);
-    });
-    socket.on("close", () => {
-      connections.delete(socket);
-    });
-  });
-  return {
-    port,
-    baseUrl,
-    walletAddress: account.address,
-    balanceMonitor,
-    close: () => new Promise((res, rej) => {
-      const timeout = setTimeout(() => {
-        rej(new Error("[ClawRouter] Close timeout after 4s"));
-      }, 4e3);
-      sessionStore.close();
-      for (const socket of connections) {
-        socket.destroy();
-      }
-      connections.clear();
-      server.close((err) => {
-        clearTimeout(timeout);
-        if (err) {
-          rej(err);
-        } else {
-          res();
-        }
-      });
-    })
-  };
-}
-async function tryModelRequest(upstreamUrl, method, headers, body, modelId, maxTokens, payFetch, balanceMonitor, signal) {
-  let requestBody = body;
-  try {
-    const parsed = JSON.parse(body.toString());
-    parsed.model = modelId;
-    if (Array.isArray(parsed.messages)) {
-      parsed.messages = normalizeMessageRoles(parsed.messages);
-    }
-    if (Array.isArray(parsed.messages)) {
-      parsed.messages = truncateMessages(parsed.messages);
-    }
-    if (Array.isArray(parsed.messages)) {
-      parsed.messages = sanitizeToolIds(parsed.messages);
-    }
-    if (isGoogleModel(modelId) && Array.isArray(parsed.messages)) {
-      parsed.messages = normalizeMessagesForGoogle(parsed.messages);
-    }
-    const hasThinkingEnabled = !!(parsed.thinking || parsed.extended_thinking || isReasoningModel(modelId));
-    if (hasThinkingEnabled && Array.isArray(parsed.messages)) {
-      parsed.messages = normalizeMessagesForThinking(parsed.messages);
-    }
-    requestBody = Buffer.from(JSON.stringify(parsed));
-  } catch {
-  }
-  const estimated = estimateAmount(modelId, requestBody.length, maxTokens);
-  const preAuth = estimated ? { estimatedAmount: estimated } : void 0;
-  try {
-    const response = await payFetch(
-      upstreamUrl,
-      {
-        method,
-        headers,
-        body: requestBody.length > 0 ? new Uint8Array(requestBody) : void 0,
-        signal
-      },
-      preAuth
-    );
-    if (response.status !== 200) {
-      const errorBody = await response.text();
-      const isProviderErr = isProviderError(response.status, errorBody);
-      return {
-        success: false,
-        errorBody,
-        errorStatus: response.status,
-        isProviderError: isProviderErr
-      };
-    }
-    return { success: true, response };
-  } catch (err) {
-    const errorMsg = err instanceof Error ? err.message : String(err);
-    return {
-      success: false,
-      errorBody: errorMsg,
-      errorStatus: 500,
-      isProviderError: true
-      // Network errors are retryable
-    };
-  }
-}
-async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, deduplicator, balanceMonitor, sessionStore, responseCache) {
-  const startTime = Date.now();
-  const upstreamUrl = `${apiBase}${req.url}`;
-  const bodyChunks = [];
-  for await (const chunk of req) {
-    bodyChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-  }
-  let body = Buffer.concat(bodyChunks);
-  let routingDecision;
-  let isStreaming = false;
-  let modelId = "";
-  let maxTokens = 4096;
-  let routingProfile = null;
-  const isChatCompletion = req.url?.includes("/chat/completions");
-  if (isChatCompletion && body.length > 0) {
-    try {
-      const parsed = JSON.parse(body.toString());
-      isStreaming = parsed.stream === true;
-      modelId = parsed.model || "";
-      maxTokens = parsed.max_tokens || 4096;
-      let bodyModified = false;
-      if (parsed.stream === true) {
-        parsed.stream = false;
-        bodyModified = true;
-      }
-      const normalizedModel = typeof parsed.model === "string" ? parsed.model.trim().toLowerCase() : "";
-      const resolvedModel = resolveModelAlias(normalizedModel);
-      const wasAlias = resolvedModel !== normalizedModel;
-      const isRoutingProfile = ROUTING_PROFILES.has(normalizedModel);
-      if (isRoutingProfile) {
-        const profileName = normalizedModel.replace("blockrun/", "");
-        routingProfile = profileName;
-      }
-      console.log(
-        `[ClawRouter] Received model: "${parsed.model}" -> normalized: "${normalizedModel}"${wasAlias ? ` -> alias: "${resolvedModel}"` : ""}${routingProfile ? `, profile: ${routingProfile}` : ""}`
-      );
-      if (wasAlias && !isRoutingProfile) {
-        parsed.model = resolvedModel;
-        modelId = resolvedModel;
-        bodyModified = true;
-      }
-      if (isRoutingProfile) {
-        if (routingProfile === "free") {
-          const freeModel = "nvidia/gpt-oss-120b";
-          console.log(`[ClawRouter] 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 {
-          const sessionId = getSessionId(
-            req.headers
-          );
-          const existingSession = sessionId ? sessionStore.getSession(sessionId) : void 0;
-          if (existingSession) {
-            console.log(
-              `[ClawRouter] Session ${sessionId?.slice(0, 8)}... using pinned model: ${existingSession.model}`
-            );
-            parsed.model = existingSession.model;
-            modelId = existingSession.model;
-            bodyModified = true;
-            sessionStore.touchSession(sessionId);
-          } else {
-            const messages = parsed.messages;
-            let lastUserMsg;
-            if (messages) {
-              for (let i = messages.length - 1; i >= 0; i--) {
-                if (messages[i].role === "user") {
-                  lastUserMsg = messages[i];
-                  break;
-                }
-              }
-            }
-            const systemMsg = messages?.find((m) => m.role === "system");
-            const prompt = typeof lastUserMsg?.content === "string" ? lastUserMsg.content : "";
-            const systemPrompt = typeof systemMsg?.content === "string" ? systemMsg.content : void 0;
-            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`
-              );
-            }
-            routingDecision = route(prompt, systemPrompt, maxTokens, {
-              ...routerOpts,
-              routingProfile: routingProfile ?? void 0
-            });
-            parsed.model = routingDecision.model;
-            modelId = routingDecision.model;
-            bodyModified = true;
-            if (sessionId) {
-              sessionStore.setSession(sessionId, routingDecision.model, routingDecision.tier);
-              console.log(
-                `[ClawRouter] Session ${sessionId.slice(0, 8)}... pinned to model: ${routingDecision.model}`
-              );
-            }
-            options.onRouted?.(routingDecision);
-          }
-        }
-      }
-      if (bodyModified) {
-        body = Buffer.from(JSON.stringify(parsed));
-      }
-    } catch (err) {
-      const errorMsg = err instanceof Error ? err.message : String(err);
-      console.error(`[ClawRouter] Routing error: ${errorMsg}`);
-      options.onError?.(new Error(`Routing failed: ${errorMsg}`));
-    }
-  }
-  const autoCompress = options.autoCompressRequests ?? true;
-  const compressionThreshold = options.compressionThresholdKB ?? 180;
-  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));
-      }
-    } catch (err) {
-      console.warn(
-        `[ClawRouter] Compression failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  const cacheKey = ResponseCache.generateKey(body);
-  const reqHeaders = {};
-  for (const [key, value] of Object.entries(req.headers)) {
-    if (typeof value === "string") reqHeaders[key] = value;
-  }
-  if (responseCache.shouldCache(body, reqHeaders)) {
-    const cachedResponse = responseCache.get(cacheKey);
-    if (cachedResponse) {
-      console.log(`[ClawRouter] Cache HIT for ${cachedResponse.model} (saved API call)`);
-      res.writeHead(cachedResponse.status, cachedResponse.headers);
-      res.end(cachedResponse.body);
-      return;
-    }
-  }
-  const dedupKey = RequestDeduplicator.hash(body);
-  const cached = deduplicator.getCached(dedupKey);
-  if (cached) {
-    res.writeHead(cached.status, cached.headers);
-    res.end(cached.body);
-    return;
-  }
-  const inflight = deduplicator.getInflight(dedupKey);
-  if (inflight) {
-    const result = await inflight;
-    res.writeHead(result.status, result.headers);
-    res.end(result.body);
-    return;
-  }
-  deduplicator.markInflight(dedupKey);
-  let estimatedCostMicros;
-  const isFreeModel = modelId === FREE_MODEL;
-  if (modelId && !options.skipBalanceCheck && !isFreeModel) {
-    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;
-        console.log(
-          `[ClawRouter] Wallet ${sufficiency.info.isEmpty ? "empty" : "insufficient"} ($${sufficiency.info.balanceUSD}), falling back to free model: ${FREE_MODEL} (requested: ${originalModel})`
-        );
-        modelId = FREE_MODEL;
-        const parsed = JSON.parse(body.toString());
-        parsed.model = FREE_MODEL;
-        body = Buffer.from(JSON.stringify(parsed));
-        options.onLowBalance?.({
-          balanceUSD: sufficiency.info.balanceUSD,
-          walletAddress: sufficiency.info.walletAddress
-        });
-      } else if (sufficiency.info.isLow) {
-        options.onLowBalance?.({
-          balanceUSD: sufficiency.info.balanceUSD,
-          walletAddress: sufficiency.info.walletAddress
-        });
-      }
-    }
-  }
-  let heartbeatInterval;
-  let headersSentEarly = false;
-  if (isStreaming) {
-    res.writeHead(200, {
-      "content-type": "text/event-stream",
-      "cache-control": "no-cache",
-      connection: "keep-alive"
-    });
-    headersSentEarly = true;
-    safeWrite(res, ": heartbeat\n\n");
-    heartbeatInterval = setInterval(() => {
-      if (canWrite(res)) {
-        safeWrite(res, ": heartbeat\n\n");
-      } else {
-        clearInterval(heartbeatInterval);
-        heartbeatInterval = void 0;
-      }
-    }, HEARTBEAT_INTERVAL_MS);
-  }
-  const headers = {};
-  for (const [key, value] of Object.entries(req.headers)) {
-    if (key === "host" || key === "connection" || key === "transfer-encoding" || key === "content-length")
-      continue;
-    if (typeof value === "string") {
-      headers[key] = value;
-    }
-  }
-  if (!headers["content-type"]) {
-    headers["content-type"] = "application/json";
-  }
-  headers["user-agent"] = USER_AGENT;
-  let completed = false;
-  res.on("close", () => {
-    if (heartbeatInterval) {
-      clearInterval(heartbeatInterval);
-      heartbeatInterval = void 0;
-    }
-    if (!completed) {
-      deduplicator.removeInflight(dedupKey);
-    }
-  });
-  const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    let modelsToTry;
-    if (routingDecision) {
-      const estimatedInputTokens = Math.ceil(body.length / 4);
-      const estimatedTotalTokens = estimatedInputTokens + maxTokens;
-      const useAgenticTiers = routingDecision.reasoning?.includes("agentic") && routerOpts.config.agenticTiers;
-      const tierConfigs = useAgenticTiers ? routerOpts.config.agenticTiers : routerOpts.config.tiers;
-      const fullChain = getFallbackChain(routingDecision.tier, tierConfigs);
-      const contextFiltered = getFallbackChainFiltered(
-        routingDecision.tier,
-        tierConfigs,
-        estimatedTotalTokens,
-        getModelContextWindow
-      );
-      const contextExcluded = fullChain.filter((m) => !contextFiltered.includes(m));
-      if (contextExcluded.length > 0) {
-        console.log(
-          `[ClawRouter] Context filter (~${estimatedTotalTokens} tokens): excluded ${contextExcluded.join(", ")}`
-        );
-      }
-      modelsToTry = contextFiltered.slice(0, MAX_FALLBACK_ATTEMPTS);
-      modelsToTry = prioritizeNonRateLimited(modelsToTry);
-    } else {
-      if (modelId && modelId !== FREE_MODEL) {
-        modelsToTry = [modelId, FREE_MODEL];
-      } else {
-        modelsToTry = modelId ? [modelId] : [];
-      }
-    }
-    let upstream;
-    let lastError;
-    let actualModelUsed = modelId;
-    for (let i = 0; i < modelsToTry.length; i++) {
-      const tryModel = modelsToTry[i];
-      const isLastAttempt = i === modelsToTry.length - 1;
-      console.log(`[ClawRouter] Trying model ${i + 1}/${modelsToTry.length}: ${tryModel}`);
-      const result = await tryModelRequest(
-        upstreamUrl,
-        req.method ?? "POST",
-        headers,
-        body,
-        tryModel,
-        maxTokens,
-        payFetch,
-        balanceMonitor,
-        controller.signal
-      );
-      if (result.success && result.response) {
-        upstream = result.response;
-        actualModelUsed = tryModel;
-        console.log(`[ClawRouter] Success with model: ${tryModel}`);
-        break;
-      }
-      lastError = {
-        body: result.errorBody || "Unknown error",
-        status: result.errorStatus || 500
-      };
-      if (result.isProviderError && !isLastAttempt) {
-        if (result.errorStatus === 429) {
-          markRateLimited(tryModel);
-        }
-        console.log(
-          `[ClawRouter] Provider error from ${tryModel}, trying fallback: ${result.errorBody?.slice(0, 100)}`
-        );
-        continue;
-      }
-      if (!result.isProviderError) {
-        console.log(
-          `[ClawRouter] Non-provider error from ${tryModel}, not retrying: ${result.errorBody?.slice(0, 100)}`
-        );
-      }
-      break;
-    }
-    clearTimeout(timeoutId);
-    if (heartbeatInterval) {
-      clearInterval(heartbeatInterval);
-      heartbeatInterval = void 0;
-    }
-    if (routingDecision && actualModelUsed !== routingDecision.model) {
-      const estimatedInputTokens = Math.ceil(body.length / 4);
-      const newCosts = calculateModelCost(
-        actualModelUsed,
-        routerOpts.modelPricing,
-        estimatedInputTokens,
-        maxTokens,
-        routingProfile ?? void 0
-      );
-      routingDecision = {
-        ...routingDecision,
-        model: actualModelUsed,
-        reasoning: `${routingDecision.reasoning} | fallback to ${actualModelUsed}`,
-        costEstimate: newCosts.costEstimate,
-        baselineCost: newCosts.baselineCost,
-        savings: newCosts.savings
-      };
-      options.onRouted?.(routingDecision);
-    }
-    if (!upstream) {
-      const rawErrBody = lastError?.body || "All models in fallback chain failed";
-      const errStatus = lastError?.status || 502;
-      const transformedErr = transformPaymentError(rawErrBody);
-      if (headersSentEarly) {
-        let errPayload;
-        try {
-          const parsed = JSON.parse(transformedErr);
-          errPayload = JSON.stringify(parsed);
-        } catch {
-          errPayload = JSON.stringify({
-            error: { message: rawErrBody, type: "provider_error", status: errStatus }
-          });
-        }
-        const errEvent = `data: ${errPayload}
-`;
-        safeWrite(res, errEvent);
-        safeWrite(res, "data: [DONE]\n\n");
-        res.end();
-        const errBuf = Buffer.from(errEvent + "data: [DONE]\n\n");
-        deduplicator.complete(dedupKey, {
-          status: 200,
-          headers: { "content-type": "text/event-stream" },
-          body: errBuf,
-          completedAt: Date.now()
-        });
-      } else {
-        res.writeHead(errStatus, { "Content-Type": "application/json" });
-        res.end(transformedErr);
-        deduplicator.complete(dedupKey, {
-          status: errStatus,
-          headers: { "content-type": "application/json" },
-          body: Buffer.from(transformedErr),
-          completedAt: Date.now()
-        });
-      }
-      return;
-    }
-    const responseChunks = [];
-    if (headersSentEarly) {
-      if (upstream.body) {
-        const reader = upstream.body.getReader();
-        const chunks = [];
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            chunks.push(value);
-          }
-        } finally {
-          reader.releaseLock();
-        }
-        const jsonBody = Buffer.concat(chunks);
-        const jsonStr = jsonBody.toString();
-        try {
-          const rsp = JSON.parse(jsonStr);
-          const baseChunk = {
-            id: rsp.id ?? `chatcmpl-${Date.now()}`,
-            object: "chat.completion.chunk",
-            created: rsp.created ?? Math.floor(Date.now() / 1e3),
-            model: rsp.model ?? "unknown",
-            system_fingerprint: null
-          };
-          if (rsp.choices && Array.isArray(rsp.choices)) {
-            for (const choice of rsp.choices) {
-              const rawContent = choice.message?.content ?? choice.delta?.content ?? "";
-              const content = stripThinkingTokens(rawContent);
-              const role = choice.message?.role ?? choice.delta?.role ?? "assistant";
-              const index = choice.index ?? 0;
-              const roleChunk = {
-                ...baseChunk,
-                choices: [{ index, delta: { role }, logprobs: null, finish_reason: null }]
-              };
-              const roleData = `data: ${JSON.stringify(roleChunk)}
-`;
-              safeWrite(res, roleData);
-              responseChunks.push(Buffer.from(roleData));
-              if (content) {
-                const contentChunk = {
-                  ...baseChunk,
-                  choices: [{ index, delta: { content }, logprobs: null, finish_reason: null }]
-                };
-                const contentData = `data: ${JSON.stringify(contentChunk)}
-`;
-                safeWrite(res, contentData);
-                responseChunks.push(Buffer.from(contentData));
-              }
-              const toolCalls = choice.message?.tool_calls ?? choice.delta?.tool_calls;
-              if (toolCalls && toolCalls.length > 0) {
-                const toolCallChunk = {
-                  ...baseChunk,
-                  choices: [
-                    {
-                      index,
-                      delta: { tool_calls: toolCalls },
-                      logprobs: null,
-                      finish_reason: null
-                    }
-                  ]
-                };
-                const toolCallData = `data: ${JSON.stringify(toolCallChunk)}
-`;
-                safeWrite(res, toolCallData);
-                responseChunks.push(Buffer.from(toolCallData));
-              }
-              const finishChunk = {
-                ...baseChunk,
-                choices: [
-                  {
-                    index,
-                    delta: {},
-                    logprobs: null,
-                    finish_reason: toolCalls && toolCalls.length > 0 ? "tool_calls" : choice.finish_reason ?? "stop"
-                  }
-                ]
-              };
-              const finishData = `data: ${JSON.stringify(finishChunk)}
-`;
-              safeWrite(res, finishData);
-              responseChunks.push(Buffer.from(finishData));
-            }
-          }
-        } catch {
-          const sseData = `data: ${jsonStr}
-`;
-          safeWrite(res, sseData);
-          responseChunks.push(Buffer.from(sseData));
-        }
-      }
-      safeWrite(res, "data: [DONE]\n\n");
-      responseChunks.push(Buffer.from("data: [DONE]\n\n"));
-      res.end();
-      deduplicator.complete(dedupKey, {
-        status: 200,
-        headers: { "content-type": "text/event-stream" },
-        body: Buffer.concat(responseChunks),
-        completedAt: Date.now()
-      });
-    } else {
-      const responseHeaders = {};
-      upstream.headers.forEach((value, key) => {
-        if (key === "transfer-encoding" || key === "connection" || key === "content-encoding")
-          return;
-        responseHeaders[key] = value;
-      });
-      res.writeHead(upstream.status, responseHeaders);
-      if (upstream.body) {
-        const reader = upstream.body.getReader();
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            const chunk = Buffer.from(value);
-            safeWrite(res, chunk);
-            responseChunks.push(chunk);
-          }
-        } finally {
-          reader.releaseLock();
-        }
-      }
-      res.end();
-      const responseBody = Buffer.concat(responseChunks);
-      deduplicator.complete(dedupKey, {
-        status: upstream.status,
-        headers: responseHeaders,
-        body: responseBody,
-        completedAt: Date.now()
-      });
-      if (upstream.status === 200 && responseCache.shouldCache(body)) {
-        responseCache.set(cacheKey, {
-          body: responseBody,
-          status: upstream.status,
-          headers: responseHeaders,
-          model: modelId
-        });
-        console.log(`[ClawRouter] Cached response for ${modelId} (${responseBody.length} bytes)`);
-      }
-    }
-    if (estimatedCostMicros !== void 0) {
-      balanceMonitor.deductEstimated(estimatedCostMicros);
-    }
-    completed = true;
-  } catch (err) {
-    clearTimeout(timeoutId);
-    if (heartbeatInterval) {
-      clearInterval(heartbeatInterval);
-      heartbeatInterval = void 0;
-    }
-    deduplicator.removeInflight(dedupKey);
-    balanceMonitor.invalidate();
-    if (err instanceof Error && err.name === "AbortError") {
-      throw new Error(`Request timed out after ${timeoutMs}ms`);
-    }
-    throw err;
-  }
-  if (routingDecision) {
-    const estimatedInputTokens = Math.ceil(body.length / 4);
-    const accurateCosts = calculateModelCost(
-      routingDecision.model,
-      routerOpts.modelPricing,
-      estimatedInputTokens,
-      maxTokens,
-      routingProfile ?? void 0
-    );
-    const costWithBuffer = accurateCosts.costEstimate * 1.2;
-    const baselineWithBuffer = accurateCosts.baselineCost * 1.2;
-    const entry = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      model: routingDecision.model,
-      tier: routingDecision.tier,
-      cost: costWithBuffer,
-      baselineCost: baselineWithBuffer,
-      savings: accurateCosts.savings,
-      latencyMs: Date.now() - startTime
-    };
-    logUsage(entry).catch(() => {
-    });
-  }
-}
-// src/auth.ts
-import { writeFile, readFile as readFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join4 } from "path";
-import { homedir as homedir3 } from "os";
-import { generatePrivateKey, privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
-var WALLET_DIR = join4(homedir3(), ".openclaw", "blockrun");
-var WALLET_FILE = join4(WALLET_DIR, "wallet.key");
-async function loadSavedWallet() {
-  try {
-    const key = (await readFile2(WALLET_FILE, "utf-8")).trim();
-    if (key.startsWith("0x") && key.length === 66) {
-      console.log(`[ClawRouter] \u2713 Loaded existing wallet from ${WALLET_FILE}`);
-      return key;
-    }
-    console.warn(`[ClawRouter] \u26A0 Wallet file exists but is invalid (wrong format)`);
-  } catch (err) {
-    if (err.code !== "ENOENT") {
-      console.error(
-        `[ClawRouter] \u2717 Failed to read wallet file: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  return void 0;
-}
-async function generateAndSaveWallet() {
-  const key = generatePrivateKey();
-  const account = privateKeyToAccount3(key);
-  await mkdir2(WALLET_DIR, { recursive: true });
-  await writeFile(WALLET_FILE, key + "\n", { mode: 384 });
-  try {
-    const verification = (await readFile2(WALLET_FILE, "utf-8")).trim();
-    if (verification !== key) {
-      throw new Error("Wallet file verification failed - content mismatch");
-    }
-    console.log(`[ClawRouter] \u2713 Wallet saved and verified at ${WALLET_FILE}`);
-  } catch (err) {
-    throw new Error(
-      `Failed to verify wallet file after creation: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  return { key, address: account.address };
-}
-async function resolveOrGenerateWalletKey() {
-  const saved = await loadSavedWallet();
-  if (saved) {
-    const account = privateKeyToAccount3(saved);
-    return { key: saved, address: account.address, source: "saved" };
-  }
-  const envKey = process.env.BLOCKRUN_WALLET_KEY;
-  if (typeof envKey === "string" && envKey.startsWith("0x") && envKey.length === 66) {
-    const account = privateKeyToAccount3(envKey);
-    return { key: envKey, address: account.address, source: "env" };
-  }
-  const { key, address } = await generateAndSaveWallet();
-  return { key, address, source: "generated" };
-}
-// src/cli.ts
-function printHelp() {
-  console.log(`
-ClawRouter v${VERSION} - Smart LLM Router
-Usage:
-  clawrouter [options]
-Options:
-  --version, -v     Show version number
-  --help, -h        Show this help message
-  --port <number>   Port to listen on (default: ${getProxyPort()})
-Examples:
-  # Start standalone proxy (survives gateway restarts)
-  npx @blockrun/clawrouter
-  # Start on custom port
-  npx @blockrun/clawrouter --port 9000
-  # Production deployment with PM2
-  pm2 start "npx @blockrun/clawrouter" --name clawrouter
-Environment Variables:
-  BLOCKRUN_WALLET_KEY     Private key for x402 payments (auto-generated if not set)
-  BLOCKRUN_PROXY_PORT     Default proxy port (default: 8402)
-For more info: https://github.com/BlockRunAI/ClawRouter
-`);
-}
-function parseArgs(args) {
-  const result = { version: false, help: false, port: void 0 };
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "--version" || arg === "-v") {
-      result.version = true;
-    } else if (arg === "--help" || arg === "-h") {
-      result.help = true;
-    } else if (arg === "--port" && args[i + 1]) {
-      result.port = parseInt(args[i + 1], 10);
-      i++;
-    }
-  }
-  return result;
-}
-async function main() {
-  const args = parseArgs(process.argv.slice(2));
-  if (args.version) {
-    console.log(VERSION);
-    process.exit(0);
-  }
-  if (args.help) {
-    printHelp();
-    process.exit(0);
-  }
-  const { key: walletKey, address, source } = await resolveOrGenerateWalletKey();
-  if (source === "generated") {
-    console.log(`[ClawRouter] Generated new wallet: ${address}`);
-  } else if (source === "saved") {
-    console.log(`[ClawRouter] Using saved wallet: ${address}`);
-  } else {
-    console.log(`[ClawRouter] Using wallet from BLOCKRUN_WALLET_KEY: ${address}`);
-  }
-  const proxy = await startProxy({
-    walletKey,
-    port: args.port,
-    onReady: (port) => {
-      console.log(`[ClawRouter] Proxy listening on http://127.0.0.1:${port}`);
-      console.log(`[ClawRouter] Health check: http://127.0.0.1:${port}/health`);
-    },
-    onError: (error) => {
-      console.error(`[ClawRouter] Error: ${error.message}`);
-    },
-    onRouted: (decision) => {
-      const cost = decision.costEstimate.toFixed(4);
-      const saved = (decision.savings * 100).toFixed(0);
-      console.log(`[ClawRouter] [${decision.tier}] ${decision.model} $${cost} (saved ${saved}%)`);
-    },
-    onLowBalance: (info) => {
-      console.warn(`[ClawRouter] Low balance: ${info.balanceUSD}. Fund: ${info.walletAddress}`);
-    },
-    onInsufficientFunds: (info) => {
-      console.error(
-        `[ClawRouter] Insufficient funds. Balance: ${info.balanceUSD}, Need: ${info.requiredUSD}`
-      );
-    }
-  });
-  const monitor = new BalanceMonitor(address);
-  try {
-    const balance = await monitor.checkBalance();
-    if (balance.isEmpty) {
-      console.log(`[ClawRouter] Wallet balance: $0.00 (using FREE model)`);
-      console.log(`[ClawRouter] Fund wallet for premium models: ${address}`);
-    } else if (balance.isLow) {
-      console.log(`[ClawRouter] Wallet balance: ${balance.balanceUSD} (low)`);
-    } else {
-      console.log(`[ClawRouter] Wallet balance: ${balance.balanceUSD}`);
-    }
-  } catch {
-    console.log(`[ClawRouter] Wallet: ${address} (balance check pending)`);
-  }
-  console.log(`[ClawRouter] Ready - Ctrl+C to stop`);
-  const shutdown = async (signal) => {
-    console.log(`
-[ClawRouter] Received ${signal}, shutting down...`);
-    try {
-      await proxy.close();
-      console.log(`[ClawRouter] Proxy closed`);
-      process.exit(0);
-    } catch (err) {
-      console.error(`[ClawRouter] Error during shutdown: ${err}`);
-      process.exit(1);
-    }
-  };
-  process.on("SIGINT", () => shutdown("SIGINT"));
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
-  await new Promise(() => {
-  });
-}
-main().catch((err) => {
-  console.error(`[ClawRouter] Fatal error: ${err.message}`);
-  process.exit(1);
-});
-//# sourceMappingURL=cli.js.map