@blockrun/clawrouter 0.4.7 → 0.5.0

package/dist/index.js

@@ -1,4 +1,42 @@
 // 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
+  "nvidia": "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)
@@ -19,7 +57,8 @@ var BLOCKRUN_MODELS = [
     contextWindow: 4e5,
     maxOutput: 128e3,
     reasoning: true,
-    vision: true
+    vision: true,
+    agentic: true
   },
   {
     id: "openai/gpt-5-mini",
@@ -79,7 +118,8 @@ var BLOCKRUN_MODELS = [
     outputPrice: 10,
     contextWindow: 128e3,
     maxOutput: 16384,
-    vision: true
+    vision: true,
+    agentic: true
   },
   {
     id: "openai/gpt-4o-mini",
@@ -127,14 +167,15 @@ var BLOCKRUN_MODELS = [
     reasoning: true
   },
   // o4-mini: Placeholder removed - model not yet released by OpenAI
-  // Anthropic
+  // 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
+    maxOutput: 8192,
+    agentic: true
   },
   {
     id: "anthropic/claude-sonnet-4",
@@ -143,7 +184,8 @@ var BLOCKRUN_MODELS = [
     outputPrice: 15,
     contextWindow: 2e5,
     maxOutput: 64e3,
-    reasoning: true
+    reasoning: true,
+    agentic: true
   },
   {
     id: "anthropic/claude-opus-4",
@@ -152,7 +194,8 @@ var BLOCKRUN_MODELS = [
     outputPrice: 75,
     contextWindow: 2e5,
     maxOutput: 32e3,
-    reasoning: true
+    reasoning: true,
+    agentic: true
   },
   {
     id: "anthropic/claude-opus-4.5",
@@ -161,7 +204,8 @@ var BLOCKRUN_MODELS = [
     outputPrice: 25,
     contextWindow: 2e5,
     maxOutput: 32e3,
-    reasoning: true
+    reasoning: true,
+    agentic: true
   },
   // Google
   {
@@ -210,7 +254,7 @@ var BLOCKRUN_MODELS = [
     maxOutput: 8192,
     reasoning: true
   },
-  // Moonshot / Kimi
+  // Moonshot / Kimi - optimized for agentic workflows
   {
     id: "moonshot/kimi-k2.5",
     name: "Kimi K2.5",
@@ -219,7 +263,8 @@ var BLOCKRUN_MODELS = [
     contextWindow: 262144,
     maxOutput: 8192,
     reasoning: true,
-    vision: true
+    vision: true,
+    agentic: true
   },
   // xAI / Grok
   {
@@ -247,6 +292,86 @@ var BLOCKRUN_MODELS = [
     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: 8192
+  },
+  {
+    id: "nvidia/kimi-k2.5",
+    name: "NVIDIA Kimi K2.5",
+    inputPrice: 1e-3,
+    outputPrice: 1e-3,
+    contextWindow: 262144,
+    maxOutput: 8192
   }
 ];
 function toOpenClawModel(m) {
@@ -274,6 +399,20 @@ function buildProviderModels(baseUrl) {
     models: OPENCLAW_MODELS
   };
 }
+function isAgenticModel(modelId) {
+  const model = BLOCKRUN_MODELS.find(
+    (m) => m.id === modelId || m.id === modelId.replace("blockrun/", "")
+  );
+  return model?.agentic ?? false;
+}
+function getAgenticModels() {
+  return BLOCKRUN_MODELS.filter((m) => m.agentic).map((m) => m.id);
+}
+function getModelContextWindow(modelId) {
+  const normalized = modelId.replace("blockrun/", "");
+  const model = BLOCKRUN_MODELS.find((m) => m.id === normalized);
+  return model?.contextWindow;
+}
 
 // src/provider.ts
 var activeProxy = null;
@@ -537,6 +676,50 @@ function scoreQuestionComplexity(prompt) {
   }
   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 >= 3) {
+    return {
+      dimensionScore: {
+        name: "agenticTask",
+        score: 1,
+        signal: `agentic (${signals.join(", ")})`
+      },
+      agenticScore: 1
+    };
+  } else if (matchCount >= 2) {
+    return {
+      dimensionScore: {
+        name: "agenticTask",
+        score: 0.6,
+        signal: `agentic (${signals.join(", ")})`
+      },
+      agenticScore: 0.6
+    };
+  } else if (matchCount >= 1) {
+    return {
+      dimensionScore: {
+        name: "agenticTask",
+        score: 0.3,
+        signal: `agentic (${signals.join(", ")})`
+      },
+      agenticScore: 0.3
+    };
+  }
+  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();
@@ -636,6 +819,9 @@ function classifyByRules(prompt, systemPrompt, estimatedTokens, config) {
       { 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;
@@ -656,7 +842,8 @@ function classifyByRules(prompt, systemPrompt, estimatedTokens, config) {
       score: weightedScore,
       tier: "REASONING",
       confidence: Math.max(confidence2, 0.85),
-      signals
+      signals,
+      agenticScore
     };
   }
   const { simpleMedium, mediumComplex, complexReasoning } = config.tierBoundaries;
@@ -680,9 +867,9 @@ function classifyByRules(prompt, systemPrompt, estimatedTokens, config) {
   }
   const confidence = calibrateConfidence(distanceFromBoundary, config.confidenceSteepness);
   if (confidence < config.confidenceThreshold) {
-    return { score: weightedScore, tier: null, confidence, signals };
+    return { score: weightedScore, tier: null, confidence, signals, agenticScore };
   }
-  return { score: weightedScore, tier, confidence, signals };
+  return { score: weightedScore, tier, confidence, signals, agenticScore };
 }
 function calibrateConfidence(distance, steepness) {
   return 1 / (1 + Math.exp(-steepness * distance));
@@ -716,6 +903,20 @@ 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 = {
@@ -1249,6 +1450,78 @@ var DEFAULT_ROUTING_CONFIG = {
       "zero-knowledge",
       "gitterbasiert"
     ],
+    // Agentic task keywords - file ops, execution, multi-step, iterative work
+    agenticTaskKeywords: [
+      // English - File operations
+      "read file",
+      "read the file",
+      "look at",
+      "check the",
+      "open the",
+      "edit",
+      "modify",
+      "update the",
+      "change the",
+      "write to",
+      "create file",
+      // English - Execution
+      "run",
+      "execute",
+      "test",
+      "build",
+      "deploy",
+      "install",
+      "npm",
+      "pip",
+      "compile",
+      "start",
+      "launch",
+      // English - Multi-step patterns
+      "then",
+      "after that",
+      "next",
+      "and also",
+      "finally",
+      "once done",
+      "step 1",
+      "step 2",
+      "first",
+      "second",
+      "lastly",
+      // English - Iterative work
+      "fix",
+      "debug",
+      "until it works",
+      "keep trying",
+      "iterate",
+      "make sure",
+      "verify",
+      "confirm",
+      // Chinese
+      "\u8BFB\u53D6\u6587\u4EF6",
+      "\u67E5\u770B",
+      "\u6253\u5F00",
+      "\u7F16\u8F91",
+      "\u4FEE\u6539",
+      "\u66F4\u65B0",
+      "\u521B\u5EFA",
+      "\u8FD0\u884C",
+      "\u6267\u884C",
+      "\u6D4B\u8BD5",
+      "\u6784\u5EFA",
+      "\u90E8\u7F72",
+      "\u5B89\u88C5",
+      "\u7136\u540E",
+      "\u63A5\u4E0B\u6765",
+      "\u6700\u540E",
+      "\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,
@@ -1256,7 +1529,8 @@ var DEFAULT_ROUTING_CONFIG = {
       reasoningMarkers: 0.18,
       technicalTerms: 0.1,
       creativeMarkers: 0.05,
-      simpleIndicators: 0.12,
+      simpleIndicators: 0.02,
+      // Reduced from 0.12 to make room for agenticTask
       multiStepPatterns: 0.12,
       questionComplexity: 0.05,
       imperativeVerbs: 0.03,
@@ -1264,7 +1538,9 @@ var DEFAULT_ROUTING_CONFIG = {
       outputFormat: 0.03,
       referenceComplexity: 0.02,
       negationComplexity: 0.01,
-      domainSpecificity: 0.02
+      domainSpecificity: 0.02,
+      agenticTask: 0.1
+      // Significant weight for agentic detection
     },
     // Tier boundaries on weighted score axis
     tierBoundaries: {
@@ -1280,25 +1556,49 @@ var DEFAULT_ROUTING_CONFIG = {
   tiers: {
     SIMPLE: {
       primary: "google/gemini-2.5-flash",
-      fallback: ["deepseek/deepseek-chat", "openai/gpt-4o-mini"]
+      fallback: ["nvidia/gpt-oss-120b", "deepseek/deepseek-chat", "openai/gpt-4o-mini"]
     },
     MEDIUM: {
-      primary: "deepseek/deepseek-chat",
-      fallback: ["google/gemini-2.5-flash", "openai/gpt-4o-mini"]
+      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: "anthropic/claude-opus-4",
-      fallback: ["anthropic/claude-sonnet-4", "openai/gpt-4o"]
+      primary: "google/gemini-2.5-pro",
+      fallback: ["anthropic/claude-sonnet-4", "xai/grok-4-0709", "openai/gpt-4o"]
     },
     REASONING: {
-      primary: "deepseek/deepseek-reasoner",
-      fallback: ["moonshot/kimi-k2.5", "google/gemini-2.5-pro"]
+      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: "xai/grok-4-fast-reasoning",
+      // Cheap reasoning for agentic tasks
+      fallback: ["moonshot/kimi-k2.5", "anthropic/claude-sonnet-4", "deepseek/deepseek-reasoner"]
     }
   },
   overrides: {
     maxTokensForceComplex: 1e5,
     structuredOutputMinTier: "MEDIUM",
-    ambiguousDefaultTier: "MEDIUM"
+    ambiguousDefaultTier: "MEDIUM",
+    agenticMode: false
   }
 };
 
@@ -1307,24 +1607,29 @@ 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`,
-      config.tiers,
+      `Input exceeds ${config.overrides.maxTokensForceComplex} tokens${useAgenticTiers ? " | agentic" : ""}`,
+      tierConfigs,
       modelPricing,
       estimatedTokens,
       maxOutputTokens
     );
   }
   const hasStructuredOutput = systemPrompt ? /json|structured|schema/i.test(systemPrompt) : false;
-  const ruleResult = classifyByRules(prompt, systemPrompt, estimatedTokens, config.scoring);
   let tier;
   let confidence;
   const method = "rules";
-  let reasoning = `score=${ruleResult.score} | ${ruleResult.signals.join(", ")}`;
+  let reasoning = `score=${ruleResult.score.toFixed(2)} | ${ruleResult.signals.join(", ")}`;
   if (ruleResult.tier !== null) {
     tier = ruleResult.tier;
     confidence = ruleResult.confidence;
@@ -1341,12 +1646,17 @@ function route(prompt, systemPrompt, maxOutputTokens, options) {
       tier = minTier;
     }
   }
+  if (isAutoAgentic) {
+    reasoning += " | auto-agentic";
+  } else if (isExplicitAgentic) {
+    reasoning += " | agentic";
+  }
   return selectModel(
     tier,
     confidence,
     method,
     reasoning,
-    config.tiers,
+    tierConfigs,
     modelPricing,
     estimatedTokens,
     maxOutputTokens
@@ -1374,6 +1684,176 @@ async function logUsage(entry) {
   }
 }
 
+// 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
+  };
+}
+function formatStatsAscii(stats) {
+  const lines = [];
+  lines.push("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+  lines.push("\u2551              ClawRouter Usage Statistics                   \u2551");
+  lines.push("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
+  lines.push(`\u2551  Period: ${stats.period.padEnd(49)}\u2551`);
+  lines.push(`\u2551  Total Requests: ${stats.totalRequests.toString().padEnd(41)}\u2551`);
+  lines.push(`\u2551  Total Cost: $${stats.totalCost.toFixed(4).padEnd(43)}\u2551`);
+  lines.push(
+    `\u2551  Baseline Cost (Opus): $${stats.totalBaselineCost.toFixed(4).padEnd(33)}\u2551`
+  );
+  lines.push(
+    `\u2551  \u{1F4B0} Total Saved: $${stats.totalSavings.toFixed(4)} (${stats.savingsPercentage.toFixed(1)}%)`.padEnd(61) + "\u2551"
+  );
+  lines.push(`\u2551  Avg Latency: ${stats.avgLatencyMs.toFixed(0)}ms`.padEnd(61) + "\u2551");
+  lines.push("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
+  lines.push("\u2551  Routing by Tier:                                          \u2551");
+  const tierOrder = ["SIMPLE", "MEDIUM", "COMPLEX", "REASONING"];
+  for (const tier of tierOrder) {
+    const data = stats.byTier[tier];
+    if (data) {
+      const bar = "\u2588".repeat(Math.min(20, Math.round(data.percentage / 5)));
+      const line = `\u2551    ${tier.padEnd(10)} ${bar.padEnd(20)} ${data.percentage.toFixed(1).padStart(5)}% (${data.count})`;
+      lines.push(line.padEnd(61) + "\u2551");
+    }
+  }
+  lines.push("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
+  lines.push("\u2551  Top Models:                                               \u2551");
+  const sortedModels = Object.entries(stats.byModel).sort((a, b) => b[1].count - a[1].count).slice(0, 5);
+  for (const [model, data] of sortedModels) {
+    const shortModel = model.length > 25 ? model.slice(0, 22) + "..." : model;
+    const line = `\u2551    ${shortModel.padEnd(25)} ${data.count.toString().padStart(5)} reqs  $${data.cost.toFixed(4)}`;
+    lines.push(line.padEnd(61) + "\u2551");
+  }
+  if (stats.dailyBreakdown.length > 0) {
+    lines.push("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
+    lines.push("\u2551  Daily Breakdown:                                          \u2551");
+    lines.push("\u2551    Date        Requests    Cost      Saved                 \u2551");
+    for (const day of stats.dailyBreakdown.slice(-7)) {
+      const saved = day.totalBaselineCost - day.totalCost;
+      const line = `\u2551    ${day.date}   ${day.totalRequests.toString().padStart(6)}    $${day.totalCost.toFixed(4).padStart(8)}  $${saved.toFixed(4)}`;
+      lines.push(line.padEnd(61) + "\u2551");
+    }
+  }
+  lines.push("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+  return lines.join("\n");
+}
+
 // src/dedup.ts
 import { createHash } from "crypto";
 var DEFAULT_TTL_MS2 = 3e4;
@@ -1667,18 +2147,152 @@ var BalanceMonitor = class {
 // src/version.ts
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
-import { dirname, join as join2 } from "path";
+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(join2(__dirname, "..", "package.json"));
+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;
@@ -1857,6 +2471,7 @@ async function startProxy(options) {
     modelPricing
   };
   const deduplicator = new RequestDeduplicator();
+  const sessionStore = new SessionStore(options.sessionConfig);
   const server = createServer(async (req, res) => {
     if (req.url === "/health" || req.url?.startsWith("/health?")) {
       const url = new URL(req.url, "http://localhost");
@@ -1879,6 +2494,37 @@ async function startProxy(options) {
       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" }));
@@ -1893,7 +2539,8 @@ async function startProxy(options) {
         options,
         routerOpts,
         deduplicator,
-        balanceMonitor
+        balanceMonitor,
+        sessionStore
       );
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
@@ -1944,6 +2591,7 @@ async function startProxy(options) {
         walletAddress: account.address,
         balanceMonitor,
         close: () => new Promise((res, rej) => {
+          sessionStore.close();
           server.close((err) => err ? rej(err) : res());
         })
       });
@@ -1996,7 +2644,7 @@ async function tryModelRequest(upstreamUrl, method, headers, body, modelId, maxT
     };
   }
 }
-async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, deduplicator, balanceMonitor) {
+async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, deduplicator, balanceMonitor, sessionStore) {
   const startTime = Date.now();
   const upstreamUrl = `${apiBase}${req.url}`;
   const bodyChunks = [];
@@ -2021,29 +2669,66 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
         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}", isAuto: ${isAutoModel}`
+        `[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 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 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;
+          const effectiveRouterOpts = hasTools ? {
+            ...routerOpts,
+            config: {
+              ...routerOpts.config,
+              overrides: { ...routerOpts.config.overrides, agenticMode: true }
             }
+          } : routerOpts;
+          if (hasTools) {
+            console.log(`[ClawRouter] Tools detected (${tools.length}), forcing agentic mode`);
+          }
+          routingDecision = route(prompt, systemPrompt, maxTokens, effectiveRouterOpts);
+          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);
         }
-        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;
-        routingDecision = route(prompt, systemPrompt, maxTokens, routerOpts);
-        parsed.model = routingDecision.model;
-        modelId = routingDecision.model;
-        bodyModified = true;
-        options.onRouted?.(routingDecision);
       }
       if (bodyModified) {
         body = Buffer.from(JSON.stringify(parsed));
@@ -2070,37 +2755,51 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
   }
   deduplicator.markInflight(dedupKey);
   let estimatedCostMicros;
-  if (modelId && !options.skipBalanceCheck) {
+  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) {
-        deduplicator.removeInflight(dedupKey);
-        const error = new EmptyWalletError(sufficiency.info.walletAddress);
-        options.onInsufficientFunds?.({
-          balanceUSD: sufficiency.info.balanceUSD,
-          requiredUSD: balanceMonitor.formatUSDC(bufferedCostMicros),
-          walletAddress: sufficiency.info.walletAddress
-        });
-        throw error;
-      }
-      if (!sufficiency.sufficient) {
-        deduplicator.removeInflight(dedupKey);
-        const error = new InsufficientFundsError({
-          currentBalanceUSD: sufficiency.info.balanceUSD,
-          requiredUSD: balanceMonitor.formatUSDC(bufferedCostMicros),
-          walletAddress: sufficiency.info.walletAddress
-        });
-        options.onInsufficientFunds?.({
-          balanceUSD: sufficiency.info.balanceUSD,
-          requiredUSD: balanceMonitor.formatUSDC(bufferedCostMicros),
-          walletAddress: sufficiency.info.walletAddress
-        });
-        throw error;
-      }
-      if (sufficiency.info.isLow) {
+      if (sufficiency.info.isEmpty || !sufficiency.sufficient) {
+        if (routingDecision) {
+          console.log(
+            `[ClawRouter] Wallet ${sufficiency.info.isEmpty ? "empty" : "insufficient"} ($${sufficiency.info.balanceUSD}), falling back to free model: ${FREE_MODEL}`
+          );
+          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 {
+          deduplicator.removeInflight(dedupKey);
+          if (sufficiency.info.isEmpty) {
+            const error = new EmptyWalletError(sufficiency.info.walletAddress);
+            options.onInsufficientFunds?.({
+              balanceUSD: sufficiency.info.balanceUSD,
+              requiredUSD: balanceMonitor.formatUSDC(bufferedCostMicros),
+              walletAddress: sufficiency.info.walletAddress
+            });
+            throw error;
+          } else {
+            const error = new InsufficientFundsError({
+              currentBalanceUSD: sufficiency.info.balanceUSD,
+              requiredUSD: balanceMonitor.formatUSDC(bufferedCostMicros),
+              walletAddress: sufficiency.info.walletAddress
+            });
+            options.onInsufficientFunds?.({
+              balanceUSD: sufficiency.info.balanceUSD,
+              requiredUSD: balanceMonitor.formatUSDC(bufferedCostMicros),
+              walletAddress: sufficiency.info.walletAddress
+            });
+            throw error;
+          }
+        }
+      } else if (sufficiency.info.isLow) {
         options.onLowBalance?.({
           balanceUSD: sufficiency.info.balanceUSD,
           walletAddress: sufficiency.info.walletAddress
@@ -2152,8 +2851,24 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
   try {
     let modelsToTry;
     if (routingDecision) {
-      modelsToTry = getFallbackChain(routingDecision.tier, routerOpts.config.tiers);
-      modelsToTry = modelsToTry.slice(0, MAX_FALLBACK_ATTEMPTS);
+      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);
     } else {
       modelsToTry = modelId ? [modelId] : [];
     }
@@ -2296,6 +3011,18 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
                 res.write(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 }, finish_reason: null }]
+                };
+                const toolCallData = `data: ${JSON.stringify(toolCallChunk)}
+
+`;
+                res.write(toolCallData);
+                responseChunks.push(Buffer.from(toolCallData));
+              }
               const finishChunk = {
                 ...baseChunk,
                 choices: [{ index, delta: {}, finish_reason: choice.finish_reason ?? "stop" }]
@@ -2327,7 +3054,7 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
     } else {
       const responseHeaders = {};
       upstream.headers.forEach((value, key) => {
-        if (key === "transfer-encoding" || key === "connection") return;
+        if (key === "transfer-encoding" || key === "connection" || key === "content-encoding") return;
         responseHeaders[key] = value;
       });
       res.writeHead(upstream.status, responseHeaders);
@@ -2373,7 +3100,10 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
     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(() => {
@@ -2382,15 +3112,15 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
 }
 
 // src/auth.ts
-import { writeFile, readFile, mkdir as mkdir2 } from "fs/promises";
-import { join as join3 } from "path";
-import { homedir as homedir2 } from "os";
+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 = join3(homedir2(), ".openclaw", "blockrun");
-var WALLET_FILE = join3(WALLET_DIR, "wallet.key");
+var WALLET_DIR = join4(homedir3(), ".openclaw", "blockrun");
+var WALLET_FILE = join4(WALLET_DIR, "wallet.key");
 async function loadSavedWallet() {
   try {
-    const key = (await readFile(WALLET_FILE, "utf-8")).trim();
+    const key = (await readFile2(WALLET_FILE, "utf-8")).trim();
     if (key.startsWith("0x") && key.length === 66) return key;
   } catch {
   }
@@ -2420,8 +3150,8 @@ async function resolveOrGenerateWalletKey() {
 
 // src/index.ts
 import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
 import { privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
 
 // src/retry.ts
@@ -2486,7 +3216,7 @@ function isCompletionMode() {
   return args.some((arg, i) => arg === "completion" && i >= 1 && i <= 3);
 }
 function injectModelsConfig(logger) {
-  const configPath = join4(homedir3(), ".openclaw", "openclaw.json");
+  const configPath = join5(homedir4(), ".openclaw", "openclaw.json");
   if (!existsSync(configPath)) {
     logger.info("OpenClaw config not found, skipping models injection");
     return;
@@ -2533,7 +3263,7 @@ function injectModelsConfig(logger) {
   }
 }
 function injectAuthProfile(logger) {
-  const agentsDir = join4(homedir3(), ".openclaw", "agents");
+  const agentsDir = join5(homedir4(), ".openclaw", "agents");
   if (!existsSync(agentsDir)) {
     try {
       mkdirSync(agentsDir, { recursive: true });
@@ -2550,8 +3280,8 @@ function injectAuthProfile(logger) {
       agents = ["main", ...agents];
     }
     for (const agentId of agents) {
-      const authDir = join4(agentsDir, agentId, "agent");
-      const authPath = join4(authDir, "auth-profiles.json");
+      const authDir = join5(agentsDir, agentId, "agent");
+      const authPath = join5(authDir, "auth-profiles.json");
       if (!existsSync(authDir)) {
         try {
           mkdirSync(authDir, { recursive: true });
@@ -2652,6 +3382,34 @@ async function startProxyInBackground(api) {
   activeProxyHandle = proxy;
   api.logger.info(`BlockRun provider active \u2014 ${proxy.baseUrl}/v1 (smart routing enabled)`);
 }
+async function createStatsCommand() {
+  return {
+    name: "stats",
+    description: "Show ClawRouter usage statistics and cost savings",
+    acceptsArgs: true,
+    requireAuth: false,
+    handler: async (ctx) => {
+      const arg = ctx.args?.trim().toLowerCase() || "7";
+      const days = parseInt(arg, 10) || 7;
+      try {
+        const stats = await getStats(Math.min(days, 30));
+        const ascii = formatStatsAscii(stats);
+        return {
+          text: [
+            "```",
+            ascii,
+            "```"
+          ].join("\n")
+        };
+      } catch (err) {
+        return {
+          text: `Failed to load stats: ${err instanceof Error ? err.message : String(err)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
 async function createWalletCommand() {
   return {
     name: "wallet",
@@ -2773,6 +3531,13 @@ var plugin = {
         `Failed to register /wallet command: ${err instanceof Error ? err.message : String(err)}`
       );
     });
+    createStatsCommand().then((statsCommand) => {
+      api.registerCommand(statsCommand);
+    }).catch((err) => {
+      api.logger.warn(
+        `Failed to register /stats command: ${err instanceof Error ? err.message : String(err)}`
+      );
+    });
     api.registerService({
       id: "clawrouter-proxy",
       start: () => {
@@ -2805,24 +3570,36 @@ export {
   BalanceMonitor,
   DEFAULT_RETRY_CONFIG,
   DEFAULT_ROUTING_CONFIG,
+  DEFAULT_SESSION_CONFIG,
   EmptyWalletError,
   InsufficientFundsError,
+  MODEL_ALIASES,
   OPENCLAW_MODELS,
   PaymentCache,
   RequestDeduplicator,
   RpcError,
+  SessionStore,
   blockrunProvider,
   buildProviderModels,
   createPaymentFetch,
   index_default as default,
   fetchWithRetry,
+  formatStatsAscii,
+  getAgenticModels,
+  getFallbackChain,
+  getFallbackChainFiltered,
+  getModelContextWindow,
   getProxyPort,
+  getSessionId,
+  getStats,
+  isAgenticModel,
   isBalanceError,
   isEmptyWalletError,
   isInsufficientFundsError,
   isRetryable,
   isRpcError,
   logUsage,
+  resolveModelAlias,
   route,
   startProxy
 };