@blockrun/clawrouter 0.6.9 → 0.8.0

package/dist/cli.js

@@ -0,0 +1,3416 @@
+#!/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) {
+  const tierConfig = tierConfigs[tier];
+  const model = tierConfig.primary;
+  const pricing = modelPricing.get(model);
+  const inputCost = pricing ? estimatedInputTokens / 1e6 * pricing.inputPrice : 0;
+  const outputCost = pricing ? maxOutputTokens / 1e6 * pricing.outputPrice : 0;
+  const costEstimate = inputCost + outputCost;
+  const opusPricing = modelPricing.get("anthropic/claude-opus-4");
+  const baselineInput = opusPricing ? estimatedInputTokens / 1e6 * opusPricing.inputPrice : 0;
+  const baselineOutput = opusPricing ? maxOutputTokens / 1e6 * opusPricing.outputPrice : 0;
+  const baselineCost = baselineInput + baselineOutput;
+  const savings = 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 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.18,
+      complexReasoning: 0.4
+      // Raised from 0.25 - requires strong reasoning signals
+    },
+    // Sigmoid steepness for confidence calibration
+    confidenceSteepness: 12,
+    // Below this confidence → ambiguous (null tier)
+    confidenceThreshold: 0.7
+  },
+  tiers: {
+    SIMPLE: {
+      primary: "google/gemini-2.5-flash",
+      fallback: ["nvidia/gpt-oss-120b", "deepseek/deepseek-chat", "openai/gpt-4o-mini"]
+    },
+    MEDIUM: {
+      primary: "xai/grok-code-fast-1",
+      // Code specialist, $0.20/$1.50
+      fallback: [
+        "deepseek/deepseek-chat",
+        "xai/grok-4-fast-non-reasoning",
+        "google/gemini-2.5-flash"
+      ]
+    },
+    COMPLEX: {
+      primary: "google/gemini-2.5-pro",
+      fallback: ["anthropic/claude-sonnet-4", "xai/grok-4-0709", "openai/gpt-4o"]
+    },
+    REASONING: {
+      primary: "xai/grok-4-fast-reasoning",
+      // Ultra-cheap reasoning $0.20/$0.50
+      fallback: ["deepseek/deepseek-reasoner", "moonshot/kimi-k2.5", "google/gemini-2.5-pro"]
+    }
+  },
+  // Agentic tier configs - models that excel at multi-step autonomous tasks
+  agenticTiers: {
+    SIMPLE: {
+      primary: "anthropic/claude-haiku-4.5",
+      fallback: ["moonshot/kimi-k2.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", "xai/grok-4-0709", "openai/gpt-4o"]
+    },
+    REASONING: {
+      primary: "anthropic/claude-sonnet-4",
+      // Strong tool use + reasoning for agentic tasks
+      fallback: ["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 agenticScore = ruleResult.agenticScore ?? 0;
+  const isAutoAgentic = agenticScore >= 0.6;
+  const isExplicitAgentic = config.overrides.agenticMode ?? false;
+  const useAgenticTiers = (isAutoAgentic || isExplicitAgentic) && config.agenticTiers != null;
+  const tierConfigs = useAgenticTiers ? config.agenticTiers : config.tiers;
+  if (estimatedTokens > config.overrides.maxTokensForceComplex) {
+    return selectModel(
+      "COMPLEX",
+      0.95,
+      "rules",
+      `Input exceeds ${config.overrides.maxTokensForceComplex} tokens${useAgenticTiers ? " | agentic" : ""}`,
+      tierConfigs,
+      modelPricing,
+      estimatedTokens,
+      maxOutputTokens
+    );
+  }
+  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;
+    }
+  }
+  if (isAutoAgentic) {
+    reasoning += " | auto-agentic";
+  } else if (isExplicitAgentic) {
+    reasoning += " | agentic";
+  }
+  return selectModel(
+    tier,
+    confidence,
+    method,
+    reasoning,
+    tierConfigs,
+    modelPricing,
+    estimatedTokens,
+    maxOutputTokens
+  );
+}
+
+// src/models.ts
+var MODEL_ALIASES = {
+  // Claude
+  claude: "anthropic/claude-sonnet-4",
+  sonnet: "anthropic/claude-sonnet-4",
+  opus: "anthropic/claude-opus-4",
+  haiku: "anthropic/claude-haiku-4.5",
+  // OpenAI
+  gpt: "openai/gpt-4o",
+  gpt4: "openai/gpt-4o",
+  gpt5: "openai/gpt-5.2",
+  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 (free)
+  nvidia: "nvidia/gpt-oss-120b",
+  "gpt-120b": "nvidia/gpt-oss-120b",
+  "gpt-20b": "nvidia/gpt-oss-20b",
+  free: "nvidia/gpt-oss-120b"
+};
+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 model;
+}
+var BLOCKRUN_MODELS = [
+  // Smart routing meta-model — proxy replaces with actual model
+  // NOTE: Model IDs are WITHOUT provider prefix (OpenClaw adds "blockrun/" automatically)
+  {
+    id: "auto",
+    name: "BlockRun Smart Router",
+    inputPrice: 0,
+    outputPrice: 0,
+    contextWindow: 105e4,
+    maxOutput: 128e3
+  },
+  // 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 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
+  },
+  {
+    id: "openai/gpt-4.1-nano",
+    name: "GPT-4.1 Nano",
+    inputPrice: 0.1,
+    outputPrice: 0.4,
+    contextWindow: 128e3,
+    maxOutput: 16384
+  },
+  {
+    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)
+  {
+    id: "openai/o1",
+    name: "o1",
+    inputPrice: 15,
+    outputPrice: 60,
+    contextWindow: 2e5,
+    maxOutput: 1e5,
+    reasoning: true
+  },
+  {
+    id: "openai/o1-mini",
+    name: "o1-mini",
+    inputPrice: 1.1,
+    outputPrice: 4.4,
+    contextWindow: 128e3,
+    maxOutput: 65536,
+    reasoning: true
+  },
+  {
+    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
+  },
+  // 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
+  },
+  {
+    id: "xai/grok-3-fast",
+    name: "Grok 3 Fast",
+    inputPrice: 5,
+    outputPrice: 25,
+    contextWindow: 131072,
+    maxOutput: 16384,
+    reasoning: true
+  },
+  {
+    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: 3,
+    outputPrice: 15,
+    contextWindow: 131072,
+    maxOutput: 16384,
+    reasoning: true
+  },
+  {
+    id: "xai/grok-2-vision",
+    name: "Grok 2 Vision",
+    inputPrice: 2,
+    outputPrice: 10,
+    contextWindow: 131072,
+    maxOutput: 16384,
+    vision: true
+  },
+  // NVIDIA - Free/cheap models
+  {
+    id: "nvidia/gpt-oss-120b",
+    name: "NVIDIA GPT-OSS 120B",
+    inputPrice: 0,
+    outputPrice: 0,
+    contextWindow: 128e3,
+    maxOutput: 16384
+  },
+  {
+    id: "nvidia/gpt-oss-20b",
+    name: "NVIDIA GPT-OSS 20B",
+    inputPrice: 0,
+    outputPrice: 0,
+    contextWindow: 128e3,
+    maxOutput: 16384
+  },
+  {
+    id: "nvidia/kimi-k2.5",
+    name: "NVIDIA Kimi K2.5",
+    inputPrice: 1e-3,
+    outputPrice: 1e-3,
+    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;
+}
+
+// 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 join2 } from "path";
+import { homedir as homedir2 } from "os";
+var LOG_DIR2 = join2(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 = join2(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;
+  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
+  };
+}
+
+// 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;
+    const promise = new Promise((resolve) => {
+      entry.waiters.push(
+        new Promise((r) => {
+          const orig = entry.resolve;
+          entry.resolve = (result) => {
+            orig(result);
+            resolve(result);
+            r(result);
+          };
+        })
+      );
+    });
+    return promise;
+  }
+  /** Mark a request as in-flight. */
+  markInflight(key) {
+    this.inflight.set(key, {
+      resolve: () => {
+      },
+      waiters: []
+    });
+  }
+  /** 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) {
+      entry.resolve(result);
+      this.inflight.delete(key);
+    }
+    this.prune();
+  }
+  /** Remove an in-flight entry on error (don't cache failures). */
+  removeInflight(key) {
+    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/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/version.ts
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join as join3 } from "path";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var require2 = createRequire(import.meta.url);
+var pkg = require2(join3(__dirname, "..", "package.json"));
+var VERSION = pkg.version;
+var USER_AGENT = `clawrouter/${VERSION}`;
+
+// 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/proxy.ts
+var BLOCKRUN_API = "https://blockrun.ai/api";
+var AUTO_MODEL = "blockrun/auto";
+var AUTO_MODEL_SHORT = "auto";
+var FREE_MODEL = "nvidia/gpt-oss-120b";
+var HEARTBEAT_INTERVAL_MS = 2e3;
+var DEFAULT_REQUEST_TIMEOUT_MS = 18e4;
+var DEFAULT_PORT = 8402;
+var MAX_FALLBACK_ATTEMPTS = 3;
+var HEALTH_CHECK_TIMEOUT_MS = 2e3;
+var RATE_LIMIT_COOLDOWN_MS = 6e4;
+var PORT_RETRY_ATTEMPTS = 5;
+var PORT_RETRY_DELAY_MS = 1e3;
+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() {
+  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;
+}
+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
+];
+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
+  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.tool_calls && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0 && msg.reasoning_content === void 0) {
+      hasChanges = true;
+      return { ...msg, reasoning_content: "" };
+    }
+    return msg;
+  });
+  return hasChanges ? normalized : messages;
+}
+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 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 === "/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
+      );
+    } 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);
+  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 = sanitizeToolIds(parsed.messages);
+    }
+    if (isGoogleModel(modelId) && Array.isArray(parsed.messages)) {
+      parsed.messages = normalizeMessagesForGoogle(parsed.messages);
+    }
+    if (parsed.thinking && 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) {
+  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;
+  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 isAutoModel = normalizedModel === AUTO_MODEL.toLowerCase() || normalizedModel === AUTO_MODEL_SHORT.toLowerCase();
+      console.log(
+        `[ClawRouter] Received model: "${parsed.model}" -> normalized: "${normalizedModel}"${wasAlias ? ` -> alias: "${resolvedModel}"` : ""}, isAuto: ${isAutoModel}`
+      );
+      if (wasAlias && !isAutoModel) {
+        parsed.model = resolvedModel;
+        modelId = resolvedModel;
+        bodyModified = true;
+      }
+      if (isAutoModel) {
+        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);
+          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 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 {
+      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) {
+      routingDecision = {
+        ...routingDecision,
+        model: actualModelUsed,
+        reasoning: `${routingDecision.reasoning} | fallback to ${actualModelUsed}`
+      };
+      options.onRouted?.(routingDecision);
+    }
+    if (!upstream) {
+      const errBody = lastError?.body || "All models in fallback chain failed";
+      const errStatus = lastError?.status || 502;
+      if (headersSentEarly) {
+        const errEvent = `data: ${JSON.stringify({ error: { message: errBody, type: "provider_error", status: errStatus } })}
+
+`;
+        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(
+          JSON.stringify({
+            error: { message: errBody, type: "provider_error" }
+          })
+        );
+        deduplicator.complete(dedupKey, {
+          status: errStatus,
+          headers: { "content-type": "application/json" },
+          body: Buffer.from(
+            JSON.stringify({ error: { message: errBody, type: "provider_error" } })
+          ),
+          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: 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();
+      deduplicator.complete(dedupKey, {
+        status: upstream.status,
+        headers: responseHeaders,
+        body: Buffer.concat(responseChunks),
+        completedAt: Date.now()
+      });
+    }
+    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 entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      model: routingDecision.model,
+      tier: routingDecision.tier,
+      cost: routingDecision.costEstimate,
+      baselineCost: routingDecision.baselineCost,
+      savings: routingDecision.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) return key;
+  } catch {
+  }
+  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 });
+  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