@lakphy/local-router 0.5.1 → 0.5.3

package/dist/cli.js

@@ -11166,8 +11166,8 @@ __export(exports_config_extra, {
   configDiff: () => configDiff,
   configBackupsList: () => configBackupsList
 });
-import { existsSync as existsSync9, readdirSync, readFileSync as readFileSync8, statSync as statSync4 } from "fs";
-import { dirname as dirname4, join as join13 } from "path";
+import { existsSync as existsSync10, readdirSync, readFileSync as readFileSync9, statSync as statSync5 } from "fs";
+import { dirname as dirname4, join as join12 } from "path";
 import { parseArgs as parseArgs2 } from "util";
 function maskApiKey(k) {
   if (k.length <= 8)
@@ -11245,15 +11245,15 @@ async function configDiff(args, flags) {
         strict: false
       });
       const path = resolveConfigPath(parsed.values.config);
-      if (!existsSync9(path)) {
+      if (!existsSync10(path)) {
         throw new CliError("CONFIG_NOT_FOUND", `\u914D\u7F6E\u4E0D\u5B58\u5728: ${path}`);
       }
-      const after = readFileSync8(path, "utf-8");
+      const after = readFileSync9(path, "utf-8");
       const against = parsed.values.against;
       let beforePath;
       if (!against) {
-        const backupDir = join13(dirname4(path), ".backups");
-        if (!existsSync9(backupDir)) {
+        const backupDir = join12(dirname4(path), ".backups");
+        if (!existsSync10(backupDir)) {
           throw new CliError("CONFIG_NOT_FOUND", "\u6CA1\u6709\u5907\u4EFD\u53EF\u5BF9\u6BD4", {
             hint: "\u6307\u5B9A --against <path|backup-id>"
           });
@@ -11262,21 +11262,21 @@ async function configDiff(args, flags) {
         if (files.length === 0) {
           throw new CliError("CONFIG_NOT_FOUND", "\u5907\u4EFD\u76EE\u5F55\u4E3A\u7A7A");
         }
-        beforePath = join13(backupDir, files[0]);
-      } else if (existsSync9(against)) {
+        beforePath = join12(backupDir, files[0]);
+      } else if (existsSync10(against)) {
         beforePath = against;
       } else {
-        const backupDir = join13(dirname4(path), ".backups");
-        const candidate = join13(backupDir, `config-${against}.json5`);
-        if (existsSync9(candidate))
+        const backupDir = join12(dirname4(path), ".backups");
+        const candidate = join12(backupDir, `config-${against}.json5`);
+        if (existsSync10(candidate))
           beforePath = candidate;
-        else if (existsSync9(join13(backupDir, against)))
-          beforePath = join13(backupDir, against);
+        else if (existsSync10(join12(backupDir, against)))
+          beforePath = join12(backupDir, against);
         else {
           throw new CliError("CONFIG_NOT_FOUND", `--against \u4E0D\u5B58\u5728: ${against}`);
         }
       }
-      const before = readFileSync8(beforePath, "utf-8");
+      const before = readFileSync9(beforePath, "utf-8");
       const diff = computeLineDiff(before, after);
       const { added, removed } = summarizeDiff(diff);
       emitResult(ctx, {
@@ -11320,10 +11320,10 @@ async function configImport(args, flags) {
       if (!file2 || file2 === "-") {
         raw2 = await readStdin();
       } else {
-        if (!existsSync9(file2)) {
+        if (!existsSync10(file2)) {
           throw new CliError("CONFIG_NOT_FOUND", `\u8F93\u5165\u6587\u4EF6\u4E0D\u5B58\u5728: ${file2}`);
         }
-        raw2 = readFileSync8(file2, "utf-8");
+        raw2 = readFileSync9(file2, "utf-8");
       }
       let parsedInput;
       try {
@@ -11332,7 +11332,7 @@ async function configImport(args, flags) {
         throw new CliError("CONFIG_INVALID", `\u8F93\u5165\u4E0D\u662F\u5408\u6CD5 JSON5: ${err instanceof Error ? err.message : err}`);
       }
       const path = resolveConfigPath(parsed.values.config);
-      const current = existsSync9(path) ? loadConfig(path) : null;
+      const current = existsSync10(path) ? loadConfig(path) : null;
       let next;
       if (parsed.values.replace || !current) {
         next = parsedInput;
@@ -11380,10 +11380,10 @@ async function configPatch(args, flags) {
       if (!file2 || file2 === "-") {
         raw2 = await readStdin();
       } else {
-        if (!existsSync9(file2)) {
+        if (!existsSync10(file2)) {
           throw new CliError("CONFIG_NOT_FOUND", `patch \u6587\u4EF6\u4E0D\u5B58\u5728: ${file2}`);
         }
-        raw2 = readFileSync8(file2, "utf-8");
+        raw2 = readFileSync9(file2, "utf-8");
       }
       let ops;
       try {
@@ -11426,12 +11426,12 @@ ${result.diff}`
   });
 }
 function listBackups(configPath) {
-  const dir = join13(dirname4(configPath), ".backups");
-  if (!existsSync9(dir))
+  const dir = join12(dirname4(configPath), ".backups");
+  if (!existsSync10(dir))
     return [];
   return readdirSync(dir).filter((f) => f.startsWith("config-") && f.endsWith(".json5")).map((f) => {
-    const full = join13(dir, f);
-    const st = statSync4(full);
+    const full = join12(dir, f);
+    const st = statSync5(full);
     return {
       id: f.replace(/^config-/, "").replace(/\.json5$/, ""),
       path: full,
@@ -11490,7 +11490,7 @@ async function configRollback(args, flags) {
           details: { available: backups.map((b) => b.id) }
         });
       }
-      const text2 = readFileSync8(target.path, "utf-8");
+      const text2 = readFileSync9(target.path, "utf-8");
       let parsedConfig;
       try {
         parsedConfig = dist_default.parse(text2);
@@ -11677,13 +11677,13 @@ import { parseArgs as parseArgs3 } from "util";
 
 // src/cli/process.ts
 init_config();
-import { closeSync as closeSync2, openSync as openSync2, readFileSync as readFileSync7, statSync as statSync3 } from "fs";
+import { closeSync as closeSync3, openSync as openSync3, readFileSync as readFileSync8, statSync as statSync4 } from "fs";
 import { setTimeout as sleep } from "timers/promises";
 import { parseArgs } from "util";
 
 // src/index.ts
-import { readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname3, resolve as resolve6 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname3, resolve as resolve7 } from "path";
 
 // node_modules/.bun/@ai-sdk+provider@3.0.8/node_modules/@ai-sdk/provider/dist/index.mjs
 var marker = "vercel.ai.error";
@@ -52928,8 +52928,8 @@ async function getLogMetrics(options) {
 
 // src/log-query.ts
 init_config();
-import { createReadStream as createReadStream3, existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { join as join6, resolve as resolve4 } from "path";
+import { createReadStream as createReadStream3, existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { join as join6, resolve as resolve5 } from "path";
 import { createInterface as createInterface2 } from "readline";
 
 // src/log-index.ts
@@ -52938,11 +52938,11 @@ import { Database } from "bun:sqlite";
 import {
   closeSync,
   createReadStream as createReadStream2,
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   mkdirSync as mkdirSync3,
   openSync,
   readSync,
-  statSync
+  statSync as statSync2
 } from "fs";
 import { join as join5 } from "path";
 
@@ -53022,8 +53022,588 @@ function resolveLogSessionIdentity(requestBody) {
   };
 }
 
+// src/token-usage.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4, statSync } from "fs";
+import { resolve as resolve4 } from "path";
+var MAX_STREAM_USAGE_BYTES = 25 * 1024 * 1024;
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  return value;
+}
+function numeric(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return null;
+}
+function numberAt(value, path) {
+  let current = value;
+  for (const key2 of path) {
+    const record2 = asRecord(current);
+    if (!record2 || !(key2 in record2))
+      return null;
+    current = record2[key2];
+  }
+  return numeric(current);
+}
+function firstNumber(value, paths) {
+  for (const path of paths) {
+    const found = numberAt(value, path);
+    if (found !== null)
+      return found;
+  }
+  return null;
+}
+function maxNullable(...values) {
+  const numbers = values.filter((value) => value !== null && value !== undefined);
+  if (numbers.length === 0)
+    return null;
+  return Math.max(...numbers);
+}
+function sumNullable(...values) {
+  let total = 0;
+  let hasValue = false;
+  for (const value of values) {
+    if (value === null || value === undefined)
+      continue;
+    total += value;
+    hasValue = true;
+  }
+  return hasValue ? total : null;
+}
+function roundPercent(numerator, denominator) {
+  if (!Number.isFinite(numerator) || !Number.isFinite(denominator) || denominator <= 0)
+    return null;
+  return Number((numerator / denominator * 100).toFixed(2));
+}
+function inferProviderStyle(usage, providerHint) {
+  const hint = providerHint?.toLowerCase() ?? "";
+  if (hint.includes("anthropic") || hint.includes("claude"))
+    return "anthropic";
+  if (hint.includes("gemini") || hint.includes("google"))
+    return "gemini";
+  if (hint.includes("deepseek"))
+    return "deepseek";
+  if (hint.includes("cohere"))
+    return "cohere";
+  if (hint.includes("mistral"))
+    return "mistral";
+  if (hint.includes("openrouter"))
+    return "openrouter";
+  if (hint.includes("openai") || hint.includes("gpt-"))
+    return "openai";
+  if ("cache_read_input_tokens" in usage || "cache_creation_input_tokens" in usage) {
+    return "anthropic";
+  }
+  if ("prompt_cache_hit_tokens" in usage || "prompt_cache_miss_tokens" in usage) {
+    return "deepseek";
+  }
+  if ("promptTokenCount" in usage || "usageMetadata" in usage || "cachedContentTokenCount" in usage) {
+    return "gemini";
+  }
+  if ("billed_units" in usage || "tokens" in usage) {
+    return "cohere";
+  }
+  if ("prompt_tokens" in usage || "completion_tokens" in usage) {
+    return "openai";
+  }
+  if ("input_tokens" in usage || "output_tokens" in usage) {
+    return "openai";
+  }
+  return "unknown";
+}
+function createEmptyMetrics2(input) {
+  return {
+    schemaVersion: 1,
+    source: input.source,
+    providerStyle: input.providerStyle,
+    inputTokens: null,
+    outputTokens: null,
+    totalTokens: null,
+    cachedInputTokens: null,
+    cacheHitInputTokens: null,
+    cacheHitRate: null,
+    cacheHitRateDenominatorTokens: null,
+    cacheHitRateFormula: null,
+    cacheReadInputTokens: null,
+    cacheCreationInputTokens: null,
+    cacheCreationInputTokens5m: null,
+    cacheCreationInputTokens1h: null,
+    cacheWriteInputTokens: null,
+    cacheMissInputTokens: null,
+    reasoningTokens: null,
+    audioInputTokens: null,
+    audioOutputTokens: null,
+    textInputTokens: null,
+    textOutputTokens: null,
+    acceptedPredictionTokens: null,
+    rejectedPredictionTokens: null,
+    toolUsePromptTokens: null,
+    billableInputTokens: null,
+    billableOutputTokens: null,
+    creditUsage: null,
+    cost: null,
+    rawUsage: input.rawUsage,
+    rawUsagePath: input.rawUsagePath,
+    warnings: []
+  };
+}
+function hasAnyTokenSignal(metrics) {
+  return [
+    metrics.inputTokens,
+    metrics.outputTokens,
+    metrics.totalTokens,
+    metrics.cachedInputTokens,
+    metrics.cacheHitInputTokens,
+    metrics.cacheReadInputTokens,
+    metrics.cacheCreationInputTokens,
+    metrics.cacheMissInputTokens,
+    metrics.reasoningTokens,
+    metrics.billableInputTokens,
+    metrics.billableOutputTokens,
+    metrics.creditUsage,
+    metrics.cost
+  ].some((value) => value !== null);
+}
+function normalizeUsageObject(input) {
+  const { usage, source: source2, rawUsagePath, providerHint } = input;
+  const providerStyle = inferProviderStyle(usage, providerHint);
+  const metrics = createEmptyMetrics2({
+    source: source2,
+    providerStyle,
+    rawUsage: usage,
+    rawUsagePath
+  });
+  const usageBody = asRecord(usage.usageMetadata) ?? usage;
+  metrics.inputTokens = firstNumber(usageBody, [
+    ["input_tokens"],
+    ["prompt_tokens"],
+    ["promptTokenCount"],
+    ["tokens", "input_tokens"],
+    ["billed_units", "input_tokens"]
+  ]);
+  metrics.outputTokens = firstNumber(usageBody, [
+    ["output_tokens"],
+    ["completion_tokens"],
+    ["candidatesTokenCount"],
+    ["tokens", "output_tokens"],
+    ["billed_units", "output_tokens"]
+  ]);
+  const explicitTotalTokens = firstNumber(usageBody, [
+    ["total_tokens"],
+    ["totalTokenCount"],
+    ["tokens", "total_tokens"]
+  ]);
+  metrics.totalTokens = explicitTotalTokens;
+  const cachedTokens = firstNumber(usageBody, [
+    ["input_tokens_details", "cached_tokens"],
+    ["prompt_tokens_details", "cached_tokens"],
+    ["cached_tokens"],
+    ["cachedContentTokenCount"]
+  ]);
+  const cacheReadTokens = firstNumber(usageBody, [
+    ["cache_read_input_tokens"],
+    ["cacheReadInputTokens"],
+    ["claude_cache_read_input_tokens"]
+  ]);
+  const promptCacheHitTokens = firstNumber(usageBody, [["prompt_cache_hit_tokens"]]);
+  const promptCacheMissTokens = firstNumber(usageBody, [["prompt_cache_miss_tokens"]]);
+  const cacheCreationTokens = firstNumber(usageBody, [
+    ["cache_creation_input_tokens"],
+    ["cacheCreationInputTokens"],
+    ["cache_creation", "input_tokens"],
+    ["claude_cache_creation_input_tokens"]
+  ]);
+  metrics.cacheCreationInputTokens5m = firstNumber(usageBody, [
+    ["cache_creation", "ephemeral_5m_input_tokens"],
+    ["cache_creation", "ephemeral5mInputTokens"],
+    ["cache_creation_ephemeral_5m_input_tokens"],
+    ["claude_cache_creation_5_m_tokens"]
+  ]);
+  metrics.cacheCreationInputTokens1h = firstNumber(usageBody, [
+    ["cache_creation", "ephemeral_1h_input_tokens"],
+    ["cache_creation", "ephemeral1hInputTokens"],
+    ["cache_creation_ephemeral_1h_input_tokens"],
+    ["claude_cache_creation_1_h_tokens"]
+  ]);
+  metrics.cacheCreationInputTokens = maxNullable(cacheCreationTokens, sumNullable(metrics.cacheCreationInputTokens5m, metrics.cacheCreationInputTokens1h));
+  metrics.cacheReadInputTokens = cacheReadTokens;
+  metrics.cacheHitInputTokens = maxNullable(cachedTokens, cacheReadTokens, promptCacheHitTokens);
+  metrics.cachedInputTokens = metrics.cacheHitInputTokens;
+  metrics.cacheMissInputTokens = promptCacheMissTokens;
+  metrics.cacheWriteInputTokens = firstNumber(usageBody, [
+    ["cache_write_input_tokens"],
+    ["cacheWriteInputTokens"]
+  ]);
+  if (metrics.cacheWriteInputTokens === null && providerStyle === "anthropic") {
+    metrics.cacheWriteInputTokens = metrics.cacheCreationInputTokens;
+  }
+  metrics.reasoningTokens = firstNumber(usageBody, [
+    ["output_tokens_details", "reasoning_tokens"],
+    ["completion_tokens_details", "reasoning_tokens"],
+    ["reasoning_tokens"],
+    ["thoughtsTokenCount"]
+  ]);
+  metrics.audioInputTokens = firstNumber(usageBody, [
+    ["input_tokens_details", "audio_tokens"],
+    ["prompt_tokens_details", "audio_tokens"],
+    ["audio_input_tokens"]
+  ]);
+  metrics.audioOutputTokens = firstNumber(usageBody, [
+    ["output_tokens_details", "audio_tokens"],
+    ["completion_tokens_details", "audio_tokens"],
+    ["audio_output_tokens"]
+  ]);
+  metrics.textInputTokens = firstNumber(usageBody, [
+    ["input_tokens_details", "text_tokens"],
+    ["prompt_tokens_details", "text_tokens"],
+    ["text_input_tokens"]
+  ]);
+  metrics.textOutputTokens = firstNumber(usageBody, [
+    ["output_tokens_details", "text_tokens"],
+    ["completion_tokens_details", "text_tokens"],
+    ["text_output_tokens"]
+  ]);
+  metrics.acceptedPredictionTokens = firstNumber(usageBody, [
+    ["output_tokens_details", "accepted_prediction_tokens"],
+    ["completion_tokens_details", "accepted_prediction_tokens"],
+    ["accepted_prediction_tokens"]
+  ]);
+  metrics.rejectedPredictionTokens = firstNumber(usageBody, [
+    ["output_tokens_details", "rejected_prediction_tokens"],
+    ["completion_tokens_details", "rejected_prediction_tokens"],
+    ["rejected_prediction_tokens"]
+  ]);
+  metrics.toolUsePromptTokens = firstNumber(usageBody, [
+    ["toolUsePromptTokenCount"],
+    ["tool_use_prompt_tokens"]
+  ]);
+  metrics.billableInputTokens = firstNumber(usageBody, [
+    ["billed_units", "input_tokens"],
+    ["billable_input_tokens"]
+  ]);
+  metrics.billableOutputTokens = firstNumber(usageBody, [
+    ["billed_units", "output_tokens"],
+    ["billable_output_tokens"]
+  ]);
+  metrics.creditUsage = firstNumber(usageBody, [["credit_usage"], ["creditUsage"]]);
+  metrics.cost = firstNumber(usageBody, [["cost"], ["total_cost"], ["totalCost"]]);
+  let cacheDenominator = null;
+  let cacheFormula = null;
+  if (providerStyle === "anthropic") {
+    cacheDenominator = sumNullable(metrics.inputTokens, metrics.cacheReadInputTokens, metrics.cacheCreationInputTokens);
+    cacheFormula = "cache_read_input_tokens / (input_tokens + cache_read_input_tokens + cache_creation_input_tokens)";
+  } else if (providerStyle === "deepseek") {
+    cacheDenominator = metrics.inputTokens ?? sumNullable(metrics.cacheHitInputTokens, metrics.cacheMissInputTokens);
+    cacheFormula = "prompt_cache_hit_tokens / prompt_tokens";
+  } else if (providerStyle === "gemini") {
+    cacheDenominator = metrics.inputTokens;
+    cacheFormula = "cachedContentTokenCount / promptTokenCount";
+  } else if (providerStyle === "openai" || providerStyle === "mistral" || providerStyle === "openrouter" || providerStyle === "unknown") {
+    cacheDenominator = metrics.inputTokens;
+    cacheFormula = "cached_tokens / input_tokens";
+  }
+  if (metrics.cacheHitInputTokens !== null && cacheDenominator !== null && cacheDenominator > 0) {
+    metrics.cacheHitRateDenominatorTokens = cacheDenominator;
+    metrics.cacheHitRateFormula = cacheFormula;
+    metrics.cacheHitRate = roundPercent(metrics.cacheHitInputTokens, cacheDenominator);
+    if (metrics.cacheMissInputTokens === null) {
+      metrics.cacheMissInputTokens = Math.max(0, cacheDenominator - metrics.cacheHitInputTokens);
+    }
+  }
+  if (metrics.totalTokens === null && metrics.outputTokens !== null) {
+    const effectiveInputTokens = metrics.cacheHitRateDenominatorTokens ?? metrics.inputTokens;
+    if (effectiveInputTokens !== null) {
+      metrics.totalTokens = effectiveInputTokens + metrics.outputTokens;
+      metrics.warnings.push(metrics.cacheHitRateDenominatorTokens !== null ? "totalTokens \u7531 cacheHitRateDenominatorTokens + outputTokens \u63A8\u5BFC" : "totalTokens \u7531 inputTokens + outputTokens \u63A8\u5BFC");
+    }
+  }
+  return hasAnyTokenSignal(metrics) ? metrics : null;
+}
+function collectUsageCandidates(value, prefix = "") {
+  const record2 = asRecord(value);
+  if (!record2)
+    return [];
+  const candidates = [];
+  const candidateKeys = [
+    "usage",
+    "usageMetadata",
+    "message.usage",
+    "response.usage",
+    "body.usage",
+    "data.usage",
+    "event.usage"
+  ];
+  for (const key2 of candidateKeys) {
+    const path = key2.split(".");
+    let current = record2;
+    for (const part of path) {
+      const currentRecord = asRecord(current);
+      current = currentRecord?.[part];
+    }
+    const usage = asRecord(current);
+    if (usage) {
+      candidates.push({ usage, path: prefix ? `${prefix}.${key2}` : key2 });
+    }
+  }
+  const direct = normalizeUsageObject({
+    usage: record2,
+    source: "response_body",
+    rawUsagePath: prefix || null
+  });
+  if (direct) {
+    candidates.push({ usage: record2, path: prefix || "$" });
+  }
+  return candidates;
+}
+function mergeNumber(current, incoming, strategy = "max") {
+  if (incoming === null)
+    return current;
+  if (current === null)
+    return incoming;
+  return strategy === "latest" ? incoming : Math.max(current, incoming);
+}
+function mergeTokenUsageMetrics(current, incoming) {
+  if (!current)
+    return incoming;
+  if (!incoming)
+    return current;
+  const merged = {
+    ...current,
+    source: incoming.source,
+    providerStyle: current.providerStyle === "unknown" ? incoming.providerStyle : current.providerStyle,
+    rawUsage: incoming.rawUsage ?? current.rawUsage,
+    rawUsagePath: incoming.rawUsagePath ?? current.rawUsagePath,
+    warnings: Array.from(new Set([...current.warnings, ...incoming.warnings]))
+  };
+  const numericKeys = [
+    "inputTokens",
+    "outputTokens",
+    "totalTokens",
+    "cachedInputTokens",
+    "cacheHitInputTokens",
+    "cacheHitRateDenominatorTokens",
+    "cacheReadInputTokens",
+    "cacheCreationInputTokens",
+    "cacheCreationInputTokens5m",
+    "cacheCreationInputTokens1h",
+    "cacheWriteInputTokens",
+    "cacheMissInputTokens",
+    "reasoningTokens",
+    "audioInputTokens",
+    "audioOutputTokens",
+    "textInputTokens",
+    "textOutputTokens",
+    "acceptedPredictionTokens",
+    "rejectedPredictionTokens",
+    "toolUsePromptTokens",
+    "billableInputTokens",
+    "billableOutputTokens",
+    "creditUsage",
+    "cost"
+  ];
+  for (const key2 of numericKeys) {
+    const value = mergeNumber(current[key2], incoming[key2], key2 === "cost" || key2 === "creditUsage" ? "latest" : "max");
+    merged[key2] = value;
+  }
+  if (incoming.cacheHitRate !== null && (current.cacheHitRate === null || (incoming.cacheHitRateDenominatorTokens ?? 0) >= (current.cacheHitRateDenominatorTokens ?? 0))) {
+    merged.cacheHitRate = incoming.cacheHitRate;
+    merged.cacheHitRateFormula = incoming.cacheHitRateFormula;
+  }
+  if (merged.cacheHitInputTokens !== null && merged.cacheHitRateDenominatorTokens !== null) {
+    merged.cacheHitRate = roundPercent(merged.cacheHitInputTokens, merged.cacheHitRateDenominatorTokens);
+  }
+  if (merged.totalTokens === null && merged.outputTokens !== null) {
+    const effectiveInputTokens = merged.cacheHitRateDenominatorTokens ?? merged.inputTokens;
+    if (effectiveInputTokens !== null) {
+      merged.totalTokens = effectiveInputTokens + merged.outputTokens;
+      merged.warnings.push(merged.cacheHitRateDenominatorTokens !== null ? "totalTokens \u7531 cacheHitRateDenominatorTokens + outputTokens \u63A8\u5BFC" : "totalTokens \u7531 inputTokens + outputTokens \u63A8\u5BFC");
+      merged.warnings = Array.from(new Set(merged.warnings));
+    }
+  }
+  return merged;
+}
+function toTokenUsageSummary(metrics) {
+  const { rawUsage: _rawUsage, ...summary } = metrics;
+  return summary;
+}
+function extractTokenUsageFromJson(value, options) {
+  let merged = null;
+  const candidates = collectUsageCandidates(value, options.rawUsagePathPrefix ?? "");
+  for (const candidate of candidates) {
+    const metrics = normalizeUsageObject({
+      usage: candidate.usage,
+      source: options.source,
+      rawUsagePath: candidate.path,
+      providerHint: options.providerHint
+    });
+    merged = mergeTokenUsageMetrics(merged, metrics);
+  }
+  return merged;
+}
+function extractTokenUsageFromResponseText(text2, source2 = "response_body", providerHint) {
+  if (!text2?.trim())
+    return null;
+  try {
+    return extractTokenUsageFromJson(JSON.parse(text2), { source: source2, providerHint });
+  } catch {
+    return null;
+  }
+}
+function processSseMessage(dataLines, source2, providerHint) {
+  if (dataLines.length === 0)
+    return null;
+  const data = dataLines.join(`
+`).trim();
+  if (!data || data === "[DONE]")
+    return null;
+  try {
+    return extractTokenUsageFromJson(JSON.parse(data), {
+      source: source2,
+      providerHint,
+      rawUsagePathPrefix: source2 === "stream_file" ? "stream" : "stream"
+    });
+  } catch {
+    return null;
+  }
+}
+function extractTokenUsageFromSseText(text2, source2 = "stream_file", providerHint) {
+  if (!text2?.trim())
+    return null;
+  let merged = null;
+  let dataLines = [];
+  const flush = () => {
+    merged = mergeTokenUsageMetrics(merged, processSseMessage(dataLines, source2, providerHint));
+    dataLines = [];
+  };
+  for (const rawLine of text2.split(/\r?\n/)) {
+    if (rawLine === "") {
+      flush();
+      continue;
+    }
+    if (rawLine.startsWith("data:")) {
+      dataLines.push(rawLine.slice(5).trimStart());
+    }
+  }
+  flush();
+  return merged;
+}
+function createTokenUsageStreamCollector(providerHint) {
+  const decoder = new TextDecoder;
+  let buffer2 = "";
+  let dataLines = [];
+  let latest = null;
+  const flushMessage = () => {
+    latest = mergeTokenUsageMetrics(latest, processSseMessage(dataLines, "stream_chunk", providerHint));
+    dataLines = [];
+  };
+  const processLine = (rawLine) => {
+    const line2 = rawLine.replace(/\r$/, "");
+    if (line2 === "") {
+      flushMessage();
+      return;
+    }
+    if (line2.startsWith("data:")) {
+      dataLines.push(line2.slice(5).trimStart());
+    }
+  };
+  return {
+    addChunk(chunk) {
+      buffer2 += decoder.decode(chunk, { stream: true });
+      let newlineIndex = buffer2.indexOf(`
+`);
+      while (newlineIndex >= 0) {
+        processLine(buffer2.slice(0, newlineIndex));
+        buffer2 = buffer2.slice(newlineIndex + 1);
+        newlineIndex = buffer2.indexOf(`
+`);
+      }
+    },
+    getUsage() {
+      buffer2 += decoder.decode();
+      if (buffer2) {
+        processLine(buffer2);
+        buffer2 = "";
+      }
+      flushMessage();
+      return latest;
+    }
+  };
+}
+function safeReadStreamFile(streamFile, baseDir) {
+  if (!streamFile)
+    return { content: null, warning: null };
+  try {
+    const candidates = [streamFile];
+    if (baseDir)
+      candidates.push(resolve4(baseDir, streamFile));
+    for (const candidate of candidates) {
+      const resolved = resolve4(candidate);
+      if (!resolved.endsWith(".sse.raw"))
+        continue;
+      if (!existsSync3(resolved))
+        continue;
+      const stats = statSync(resolved);
+      if (stats.size > MAX_STREAM_USAGE_BYTES) {
+        return {
+          content: null,
+          warning: `stream_file \u8D85\u8FC7 ${MAX_STREAM_USAGE_BYTES} \u5B57\u8282\uFF0C\u5DF2\u8DF3\u8FC7 token usage \u56DE\u586B`
+        };
+      }
+      return { content: readFileSync4(resolved, "utf-8"), warning: null };
+    }
+  } catch (err) {
+    return {
+      content: null,
+      warning: `stream_file token usage \u8BFB\u53D6\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  return { content: null, warning: null };
+}
+function extractTokenUsageFromLogEvent(event, options = {}) {
+  if (event.token_usage) {
+    return {
+      rawUsage: null,
+      ...event.token_usage,
+      source: event.token_usage.source ?? "explicit"
+    };
+  }
+  const providerHint = [event.provider, event.route_type, event.model_in, event.model_out].filter(Boolean).join(" ");
+  const responseBodyUsage = extractTokenUsageFromResponseText(event.response_body, "response_body", providerHint);
+  if (responseBodyUsage)
+    return responseBodyUsage;
+  const responseAfterPluginsUsage = extractTokenUsageFromResponseText(event.response_body_after_plugins, "response_body_after_plugins", providerHint);
+  if (responseAfterPluginsUsage)
+    return responseAfterPluginsUsage;
+  const responseBeforePluginsUsage = extractTokenUsageFromResponseText(event.response_body_before_plugins, "response_body_before_plugins", providerHint);
+  if (responseBeforePluginsUsage)
+    return responseBeforePluginsUsage;
+  const streamContent = options.streamContent ?? safeReadStreamFile(event.stream_file, options.baseDir).content;
+  return extractTokenUsageFromSseText(streamContent ?? undefined, "stream_file", providerHint);
+}
+function extractTokenUsageSummaryFromLogEvent(event, options = {}) {
+  const metrics = extractTokenUsageFromLogEvent(event, options);
+  return metrics ? toTokenUsageSummary(metrics) : null;
+}
+function enrichLogEventTokenUsage(event, options = {}) {
+  if (event.token_usage)
+    return event;
+  const tokenUsage = extractTokenUsageFromLogEvent(event, options);
+  if (!tokenUsage)
+    return event;
+  return {
+    ...event,
+    token_usage: tokenUsage
+  };
+}
+
 // src/log-index.ts
-var SCHEMA_VERSION2 = 1;
+var SCHEMA_VERSION2 = 3;
 var MAX_INDEX_QUEUE = 20000;
 var INDEX_BATCH_SIZE = 250;
 var INDEX_FLUSH_DELAY_MS = 50;
@@ -53167,6 +53747,7 @@ function eventToRow(input) {
   const statusClass = getStatusClass2(event);
   const latencyMs = Math.max(0, event.latency_ms ?? 0);
   const model = event.model_out || event.model_in;
+  const tokenUsage = extractTokenUsageSummaryFromLogEvent(event, { baseDir: input.baseDir });
   return {
     id: input.id,
     ts_ms: tsMs,
@@ -53194,8 +53775,46 @@ function eventToRow(input) {
     line_number: input.lineNumber,
     byte_offset: input.offset,
     byte_length: input.byteLength,
-    search_text: buildSearchText(event)
-  };
+    search_text: buildSearchText(event),
+    token_input: tokenUsage?.inputTokens ?? null,
+    token_output: tokenUsage?.outputTokens ?? null,
+    token_total: tokenUsage?.totalTokens ?? null,
+    token_cached_input: tokenUsage?.cachedInputTokens ?? null,
+    token_cache_hit_input: tokenUsage?.cacheHitInputTokens ?? null,
+    token_cache_hit_rate: tokenUsage?.cacheHitRate ?? null,
+    token_cache_hit_rate_denominator: tokenUsage?.cacheHitRateDenominatorTokens ?? null,
+    token_cache_read_input: tokenUsage?.cacheReadInputTokens ?? null,
+    token_cache_creation_input: tokenUsage?.cacheCreationInputTokens ?? null,
+    token_cache_creation_input_5m: tokenUsage?.cacheCreationInputTokens5m ?? null,
+    token_cache_creation_input_1h: tokenUsage?.cacheCreationInputTokens1h ?? null,
+    token_cache_write_input: tokenUsage?.cacheWriteInputTokens ?? null,
+    token_cache_miss_input: tokenUsage?.cacheMissInputTokens ?? null,
+    token_reasoning: tokenUsage?.reasoningTokens ?? null,
+    token_audio_input: tokenUsage?.audioInputTokens ?? null,
+    token_audio_output: tokenUsage?.audioOutputTokens ?? null,
+    token_text_input: tokenUsage?.textInputTokens ?? null,
+    token_text_output: tokenUsage?.textOutputTokens ?? null,
+    token_accepted_prediction: tokenUsage?.acceptedPredictionTokens ?? null,
+    token_rejected_prediction: tokenUsage?.rejectedPredictionTokens ?? null,
+    token_tool_use_prompt: tokenUsage?.toolUsePromptTokens ?? null,
+    token_billable_input: tokenUsage?.billableInputTokens ?? null,
+    token_billable_output: tokenUsage?.billableOutputTokens ?? null,
+    token_credit_usage: tokenUsage?.creditUsage ?? null,
+    token_cost: tokenUsage?.cost ?? null,
+    token_source: tokenUsage?.source ?? null,
+    token_provider_style: tokenUsage?.providerStyle ?? null,
+    token_raw_usage_path: tokenUsage?.rawUsagePath ?? null,
+    token_usage_json: tokenUsage ? JSON.stringify(tokenUsage) : null
+  };
+}
+function parseTokenUsageSummary(value) {
+  if (!value)
+    return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
 }
 function rowToSummary(row) {
   return {
@@ -53218,7 +53837,8 @@ function rowToSummary(row) {
     hasMetadata: row.has_metadata === 1,
     userIdRaw: row.user_id_raw,
     userKey: row.user_key,
-    sessionId: row.session_id
+    sessionId: row.session_id,
+    tokenUsage: parseTokenUsageSummary(row.token_usage_json)
   };
 }
 async function* readJsonlLinesWithOffsets(filePath) {
@@ -53288,7 +53908,22 @@ function createEmptyStats() {
     errorCount: 0,
     errorRate: 0,
     avgLatencyMs: 0,
-    p95LatencyMs: 0
+    p95LatencyMs: 0,
+    tokenUsageCount: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    cachedInputTokens: 0,
+    cacheHitInputTokens: 0,
+    cacheHitRate: 0,
+    cacheHitRateDenominatorTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    cacheWriteInputTokens: 0,
+    cacheMissInputTokens: 0,
+    reasoningTokens: 0,
+    billableInputTokens: 0,
+    billableOutputTokens: 0
   };
 }
 function createEmptyQueryResult(query, meta3 = {}) {
@@ -53381,12 +54016,28 @@ class LogIndex {
         id, ts_ms, ts_start, level, provider, route_type, model, model_in, model_out,
         path, request_id, latency_ms, upstream_status, status_class, has_error,
         message, error_type, has_metadata, user_id_raw, user_key, session_id,
-        source_date, source_file, line_number, byte_offset, byte_length, search_text
+        source_date, source_file, line_number, byte_offset, byte_length, search_text,
+        token_input, token_output, token_total, token_cached_input, token_cache_hit_input,
+        token_cache_hit_rate, token_cache_hit_rate_denominator, token_cache_read_input,
+        token_cache_creation_input, token_cache_creation_input_5m, token_cache_creation_input_1h,
+        token_cache_write_input, token_cache_miss_input, token_reasoning, token_audio_input,
+        token_audio_output, token_text_input, token_text_output, token_accepted_prediction,
+        token_rejected_prediction, token_tool_use_prompt, token_billable_input,
+        token_billable_output, token_credit_usage, token_cost, token_source,
+        token_provider_style, token_raw_usage_path, token_usage_json
       ) VALUES (
         $id, $ts_ms, $ts_start, $level, $provider, $route_type, $model, $model_in, $model_out,
         $path, $request_id, $latency_ms, $upstream_status, $status_class, $has_error,
         $message, $error_type, $has_metadata, $user_id_raw, $user_key, $session_id,
-        $source_date, $source_file, $line_number, $byte_offset, $byte_length, $search_text
+        $source_date, $source_file, $line_number, $byte_offset, $byte_length, $search_text,
+        $token_input, $token_output, $token_total, $token_cached_input, $token_cache_hit_input,
+        $token_cache_hit_rate, $token_cache_hit_rate_denominator, $token_cache_read_input,
+        $token_cache_creation_input, $token_cache_creation_input_5m, $token_cache_creation_input_1h,
+        $token_cache_write_input, $token_cache_miss_input, $token_reasoning, $token_audio_input,
+        $token_audio_output, $token_text_input, $token_text_output, $token_accepted_prediction,
+        $token_rejected_prediction, $token_tool_use_prompt, $token_billable_input,
+        $token_billable_output, $token_credit_usage, $token_cost, $token_source,
+        $token_provider_style, $token_raw_usage_path, $token_usage_json
       )
     `);
     this.deleteFtsStmt = this.db.prepare("DELETE FROM log_events_fts WHERE event_id = ?");
@@ -53436,9 +54087,9 @@ class LogIndex {
     const dates = listDateStrings2(fromMs, toMs);
     for (const date5 of dates) {
       const filePath = join5(eventsDir, `${date5}.jsonl`);
-      if (!existsSync3(filePath))
+      if (!existsSync4(filePath))
         continue;
-      const stats = statSync(filePath);
+      const stats = statSync2(filePath);
       const fileRow = this.db.query("SELECT size_bytes, mtime_ms FROM log_index_files WHERE file_path = ?").get(filePath);
       const sizeBytes = stats.size;
       const mtimeMs = Math.trunc(stats.mtimeMs);
@@ -53473,7 +54124,7 @@ class LogIndex {
             e.id, e.ts_start, e.level, e.provider, e.route_type, e.model, e.model_in,
             e.model_out, e.path, e.request_id, e.latency_ms, e.upstream_status,
             e.status_class, e.has_error, e.message, e.error_type, e.has_metadata,
-            e.user_id_raw, e.user_key, e.session_id, e.ts_ms
+            e.user_id_raw, e.user_key, e.session_id, e.ts_ms, e.token_usage_json
           FROM log_events e
           ${whereSql}
           ${cursorClause}
@@ -53528,7 +54179,7 @@ class LogIndex {
       return null;
     const row = this.db.query("SELECT source_date, source_file, line_number, byte_offset FROM log_events WHERE id = ?").get(id);
     const filePath = row?.source_file ?? join5(this.baseDir, "events", `${parsedId.date}.jsonl`);
-    if (!existsSync3(filePath))
+    if (!existsSync4(filePath))
       return null;
     const line2 = readLineAtOffset(filePath, row?.byte_offset ?? parsedId.offset);
     if (!line2?.trim())
@@ -53596,7 +54247,36 @@ class LogIndex {
         line_number INTEGER,
         byte_offset INTEGER NOT NULL,
         byte_length INTEGER NOT NULL,
-        search_text TEXT NOT NULL
+        search_text TEXT NOT NULL,
+        token_input INTEGER,
+        token_output INTEGER,
+        token_total INTEGER,
+        token_cached_input INTEGER,
+        token_cache_hit_input INTEGER,
+        token_cache_hit_rate REAL,
+        token_cache_hit_rate_denominator INTEGER,
+        token_cache_read_input INTEGER,
+        token_cache_creation_input INTEGER,
+        token_cache_creation_input_5m INTEGER,
+        token_cache_creation_input_1h INTEGER,
+        token_cache_write_input INTEGER,
+        token_cache_miss_input INTEGER,
+        token_reasoning INTEGER,
+        token_audio_input INTEGER,
+        token_audio_output INTEGER,
+        token_text_input INTEGER,
+        token_text_output INTEGER,
+        token_accepted_prediction INTEGER,
+        token_rejected_prediction INTEGER,
+        token_tool_use_prompt INTEGER,
+        token_billable_input INTEGER,
+        token_billable_output INTEGER,
+        token_credit_usage REAL,
+        token_cost REAL,
+        token_source TEXT,
+        token_provider_style TEXT,
+        token_raw_usage_path TEXT,
+        token_usage_json TEXT
       );
 
       CREATE VIRTUAL TABLE IF NOT EXISTS log_events_fts
@@ -53614,12 +54294,67 @@ class LogIndex {
       CREATE INDEX IF NOT EXISTS idx_log_events_session_time ON log_events(session_id, ts_ms DESC);
       CREATE INDEX IF NOT EXISTS idx_log_events_file ON log_events(source_file);
     `);
+    this.ensureTokenColumns();
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_log_events_token_total_time ON log_events(token_total, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_token_input_time ON log_events(token_input, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_token_cache_hit_rate_time ON log_events(token_cache_hit_rate, ts_ms DESC);
+    `);
+    const versionRow = this.db.query("SELECT value FROM log_index_meta WHERE key = 'schema_version'").get();
+    const previousVersion = Number.parseInt(versionRow?.value ?? "0", 10) || 0;
+    if (previousVersion > 0 && previousVersion < SCHEMA_VERSION2) {
+      this.db.exec(`
+        DELETE FROM log_events_fts;
+        DELETE FROM log_events;
+        DELETE FROM log_index_files;
+      `);
+    }
     this.db.prepare(`
         INSERT INTO log_index_meta(key, value)
         VALUES ('schema_version', ?)
         ON CONFLICT(key) DO UPDATE SET value = excluded.value
       `).run(String(SCHEMA_VERSION2));
   }
+  ensureTokenColumns() {
+    const rows = this.db.query("PRAGMA table_info(log_events)").all();
+    const existing = new Set(rows.map((row) => row.name));
+    const columns = [
+      { name: "token_input", type: "INTEGER" },
+      { name: "token_output", type: "INTEGER" },
+      { name: "token_total", type: "INTEGER" },
+      { name: "token_cached_input", type: "INTEGER" },
+      { name: "token_cache_hit_input", type: "INTEGER" },
+      { name: "token_cache_hit_rate", type: "REAL" },
+      { name: "token_cache_hit_rate_denominator", type: "INTEGER" },
+      { name: "token_cache_read_input", type: "INTEGER" },
+      { name: "token_cache_creation_input", type: "INTEGER" },
+      { name: "token_cache_creation_input_5m", type: "INTEGER" },
+      { name: "token_cache_creation_input_1h", type: "INTEGER" },
+      { name: "token_cache_write_input", type: "INTEGER" },
+      { name: "token_cache_miss_input", type: "INTEGER" },
+      { name: "token_reasoning", type: "INTEGER" },
+      { name: "token_audio_input", type: "INTEGER" },
+      { name: "token_audio_output", type: "INTEGER" },
+      { name: "token_text_input", type: "INTEGER" },
+      { name: "token_text_output", type: "INTEGER" },
+      { name: "token_accepted_prediction", type: "INTEGER" },
+      { name: "token_rejected_prediction", type: "INTEGER" },
+      { name: "token_tool_use_prompt", type: "INTEGER" },
+      { name: "token_billable_input", type: "INTEGER" },
+      { name: "token_billable_output", type: "INTEGER" },
+      { name: "token_credit_usage", type: "REAL" },
+      { name: "token_cost", type: "REAL" },
+      { name: "token_source", type: "TEXT" },
+      { name: "token_provider_style", type: "TEXT" },
+      { name: "token_raw_usage_path", type: "TEXT" },
+      { name: "token_usage_json", type: "TEXT" }
+    ];
+    for (const column2 of columns) {
+      if (existing.has(column2.name))
+        continue;
+      this.db.exec(`ALTER TABLE log_events ADD COLUMN ${column2.name} ${column2.type}`);
+    }
+  }
   flushQueue() {
     if (this.queue.length === 0 || this.disposed)
       return;
@@ -53647,6 +54382,7 @@ class LogIndex {
       return;
     const id = encodeOffsetLogEventId(item.date, item.offset);
     const row = eventToRow({
+      baseDir: this.baseDir,
       id,
       date: item.date,
       filePath: item.filePath,
@@ -53662,7 +54398,7 @@ class LogIndex {
     this.insertFtsStmt.run(id, row.search_text);
     if (!this.dirtyFiles.has(item.filePath)) {
       try {
-        const stats = statSync(item.filePath);
+        const stats = statSync2(item.filePath);
         const indexedThrough = item.offset + item.byteLength;
         this.upsertFileStmt.run(item.filePath, item.date, Math.min(indexedThrough, stats.size), Math.trunc(stats.mtimeMs), Date.now());
       } catch {}
@@ -53689,6 +54425,7 @@ class LogIndex {
           continue;
         }
         const row = eventToRow({
+          baseDir: this.baseDir,
           id: encodeOffsetLogEventId(date5, item.offset),
           date: date5,
           filePath,
@@ -53721,7 +54458,21 @@ class LogIndex {
         SELECT
           COUNT(*) AS total,
           COALESCE(SUM(has_error), 0) AS errorCount,
-          COALESCE(AVG(latency_ms), 0) AS avgLatencyMs
+          COALESCE(AVG(latency_ms), 0) AS avgLatencyMs,
+          COALESCE(SUM(CASE WHEN token_usage_json IS NOT NULL THEN 1 ELSE 0 END), 0) AS tokenUsageCount,
+          COALESCE(SUM(token_input), 0) AS inputTokens,
+          COALESCE(SUM(token_output), 0) AS outputTokens,
+          COALESCE(SUM(token_total), 0) AS totalTokens,
+          COALESCE(SUM(token_cached_input), 0) AS cachedInputTokens,
+          COALESCE(SUM(token_cache_hit_input), 0) AS cacheHitInputTokens,
+          COALESCE(SUM(token_cache_hit_rate_denominator), 0) AS cacheHitRateDenominatorTokens,
+          COALESCE(SUM(token_cache_read_input), 0) AS cacheReadInputTokens,
+          COALESCE(SUM(token_cache_creation_input), 0) AS cacheCreationInputTokens,
+          COALESCE(SUM(token_cache_write_input), 0) AS cacheWriteInputTokens,
+          COALESCE(SUM(token_cache_miss_input), 0) AS cacheMissInputTokens,
+          COALESCE(SUM(token_reasoning), 0) AS reasoningTokens,
+          COALESCE(SUM(token_billable_input), 0) AS billableInputTokens,
+          COALESCE(SUM(token_billable_output), 0) AS billableOutputTokens
         FROM log_events e
         ${whereSql}
       `).get(...params);
@@ -53742,7 +54493,22 @@ class LogIndex {
       errorCount,
       errorRate: toPercent2(errorCount, total),
       avgLatencyMs: Math.round(Number(aggregate.avgLatencyMs) || 0),
-      p95LatencyMs: Math.round(p95Row?.latency_ms ?? 0)
+      p95LatencyMs: Math.round(p95Row?.latency_ms ?? 0),
+      tokenUsageCount: Number(aggregate.tokenUsageCount) || 0,
+      inputTokens: Number(aggregate.inputTokens) || 0,
+      outputTokens: Number(aggregate.outputTokens) || 0,
+      totalTokens: Number(aggregate.totalTokens) || 0,
+      cachedInputTokens: Number(aggregate.cachedInputTokens) || 0,
+      cacheHitInputTokens: Number(aggregate.cacheHitInputTokens) || 0,
+      cacheHitRate: toPercent2(Number(aggregate.cacheHitInputTokens) || 0, Number(aggregate.cacheHitRateDenominatorTokens) || 0),
+      cacheHitRateDenominatorTokens: Number(aggregate.cacheHitRateDenominatorTokens) || 0,
+      cacheReadInputTokens: Number(aggregate.cacheReadInputTokens) || 0,
+      cacheCreationInputTokens: Number(aggregate.cacheCreationInputTokens) || 0,
+      cacheWriteInputTokens: Number(aggregate.cacheWriteInputTokens) || 0,
+      cacheMissInputTokens: Number(aggregate.cacheMissInputTokens) || 0,
+      reasoningTokens: Number(aggregate.reasoningTokens) || 0,
+      billableInputTokens: Number(aggregate.billableInputTokens) || 0,
+      billableOutputTokens: Number(aggregate.billableOutputTokens) || 0
     };
   }
 }
@@ -53823,7 +54589,7 @@ function getIndexedLogEventDetail(logConfig, id) {
   if (!parsedId)
     return null;
   const filePath = join5(baseDir, "events", `${parsedId.date}.jsonl`);
-  if (!existsSync3(filePath))
+  if (!existsSync4(filePath))
     return null;
   const line2 = readLineAtOffset(filePath, parsedId.offset);
   if (!line2?.trim())
@@ -53956,8 +54722,25 @@ function createRunningStats() {
     total: 0,
     errorCount: 0,
     latencySum: 0,
-    latencyCounts: new Map
-  };
+    latencyCounts: new Map,
+    tokenUsageCount: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    cachedInputTokens: 0,
+    cacheHitInputTokens: 0,
+    cacheHitRateDenominatorTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    cacheWriteInputTokens: 0,
+    cacheMissInputTokens: 0,
+    reasoningTokens: 0,
+    billableInputTokens: 0,
+    billableOutputTokens: 0
+  };
+}
+function addNullable(total, value) {
+  return total + (value ?? 0);
 }
 function updateRunningStats(stats, item) {
   stats.total += 1;
@@ -53968,6 +54751,23 @@ function updateRunningStats(stats, item) {
   stats.latencySum += latency;
   const roundedLatency = Math.round(latency);
   stats.latencyCounts.set(roundedLatency, (stats.latencyCounts.get(roundedLatency) ?? 0) + 1);
+  const usage = item.tokenUsage;
+  if (!usage)
+    return;
+  stats.tokenUsageCount += 1;
+  stats.inputTokens = addNullable(stats.inputTokens, usage.inputTokens);
+  stats.outputTokens = addNullable(stats.outputTokens, usage.outputTokens);
+  stats.totalTokens = addNullable(stats.totalTokens, usage.totalTokens);
+  stats.cachedInputTokens = addNullable(stats.cachedInputTokens, usage.cachedInputTokens);
+  stats.cacheHitInputTokens = addNullable(stats.cacheHitInputTokens, usage.cacheHitInputTokens);
+  stats.cacheHitRateDenominatorTokens = addNullable(stats.cacheHitRateDenominatorTokens, usage.cacheHitRateDenominatorTokens);
+  stats.cacheReadInputTokens = addNullable(stats.cacheReadInputTokens, usage.cacheReadInputTokens);
+  stats.cacheCreationInputTokens = addNullable(stats.cacheCreationInputTokens, usage.cacheCreationInputTokens);
+  stats.cacheWriteInputTokens = addNullable(stats.cacheWriteInputTokens, usage.cacheWriteInputTokens);
+  stats.cacheMissInputTokens = addNullable(stats.cacheMissInputTokens, usage.cacheMissInputTokens);
+  stats.reasoningTokens = addNullable(stats.reasoningTokens, usage.reasoningTokens);
+  stats.billableInputTokens = addNullable(stats.billableInputTokens, usage.billableInputTokens);
+  stats.billableOutputTokens = addNullable(stats.billableOutputTokens, usage.billableOutputTokens);
 }
 function percentileFromCounts(latencyCounts, total, ratio) {
   if (total <= 0 || latencyCounts.size === 0)
@@ -53990,7 +54790,22 @@ function finalizeStats(stats) {
       errorCount: 0,
       errorRate: 0,
       avgLatencyMs: 0,
-      p95LatencyMs: 0
+      p95LatencyMs: 0,
+      tokenUsageCount: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      cachedInputTokens: 0,
+      cacheHitInputTokens: 0,
+      cacheHitRate: 0,
+      cacheHitRateDenominatorTokens: 0,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      cacheWriteInputTokens: 0,
+      cacheMissInputTokens: 0,
+      reasoningTokens: 0,
+      billableInputTokens: 0,
+      billableOutputTokens: 0
     };
   }
   return {
@@ -53998,8 +54813,26 @@ function finalizeStats(stats) {
     errorCount: stats.errorCount,
     errorRate: toPercent3(stats.errorCount, stats.total),
     avgLatencyMs: Math.round(stats.latencySum / stats.total),
-    p95LatencyMs: percentileFromCounts(stats.latencyCounts, stats.total, 0.95)
-  };
+    p95LatencyMs: percentileFromCounts(stats.latencyCounts, stats.total, 0.95),
+    tokenUsageCount: stats.tokenUsageCount,
+    inputTokens: stats.inputTokens,
+    outputTokens: stats.outputTokens,
+    totalTokens: stats.totalTokens,
+    cachedInputTokens: stats.cachedInputTokens,
+    cacheHitInputTokens: stats.cacheHitInputTokens,
+    cacheHitRate: toPercent3(stats.cacheHitInputTokens, stats.cacheHitRateDenominatorTokens),
+    cacheHitRateDenominatorTokens: stats.cacheHitRateDenominatorTokens,
+    cacheReadInputTokens: stats.cacheReadInputTokens,
+    cacheCreationInputTokens: stats.cacheCreationInputTokens,
+    cacheWriteInputTokens: stats.cacheWriteInputTokens,
+    cacheMissInputTokens: stats.cacheMissInputTokens,
+    reasoningTokens: stats.reasoningTokens,
+    billableInputTokens: stats.billableInputTokens,
+    billableOutputTokens: stats.billableOutputTokens
+  };
+}
+function createEmptyLogQueryStats() {
+  return finalizeStats(createRunningStats());
 }
 function compareLocatedEvents(a, b, sort) {
   if (a.ts !== b.ts) {
@@ -54071,7 +54904,8 @@ function eventToSummary(item) {
     hasMetadata: identity.hasMetadata,
     userIdRaw: identity.userIdRaw,
     userKey: identity.userKey,
-    sessionId: identity.sessionId
+    sessionId: identity.sessionId,
+    tokenUsage: item.tokenUsage
   };
 }
 function createLogEventSummaryFromEvent(event, location) {
@@ -54083,7 +54917,8 @@ function createLogEventSummaryFromEvent(event, location) {
     ts: Number.isFinite(ts) ? ts : 0,
     level: getLevel2(event),
     statusClass: getStatusClass3(event),
-    event
+    event,
+    tokenUsage: extractTokenUsageSummaryFromLogEvent(event)
   });
 }
 function logEventMatchesQuery(event, query) {
@@ -54172,23 +55007,23 @@ function readStreamContent(baseDir, streamFile) {
   if (!streamFile)
     return { content: null, warning: null };
   try {
-    const resolvedBase = resolve4(baseDir);
-    const resolvedFromFile = resolve4(streamFile);
+    const resolvedBase = resolve5(baseDir);
+    const resolvedFromFile = resolve5(streamFile);
     const looksLikeStreamFile = resolvedFromFile.endsWith(".sse.raw");
     if (!looksLikeStreamFile) {
       return { content: null, warning: "stream_file \u4E0D\u662F .sse.raw \u6587\u4EF6\uFF0C\u5DF2\u8DF3\u8FC7\u8BFB\u53D6\u3002" };
     }
-    if (existsSync4(resolvedFromFile)) {
-      return { content: readFileSync4(resolvedFromFile, "utf-8"), warning: null };
+    if (existsSync5(resolvedFromFile)) {
+      return { content: readFileSync5(resolvedFromFile, "utf-8"), warning: null };
     }
-    const fallbackPath = resolve4(resolvedBase, streamFile);
+    const fallbackPath = resolve5(resolvedBase, streamFile);
     if (!fallbackPath.startsWith(`${resolvedBase}/`) && fallbackPath !== resolvedBase) {
       return { content: null, warning: "stream_file \u8DEF\u5F84\u975E\u6CD5\uFF0C\u5DF2\u62D2\u7EDD\u8BFB\u53D6\u3002" };
     }
-    if (!existsSync4(fallbackPath)) {
+    if (!existsSync5(fallbackPath)) {
       return { content: null, warning: "stream_file \u4E0D\u5B58\u5728\uFF0C\u53EF\u80FD\u5DF2\u88AB\u6E05\u7406\u3002" };
     }
-    return { content: readFileSync4(fallbackPath, "utf-8"), warning: null };
+    return { content: readFileSync5(fallbackPath, "utf-8"), warning: null };
   } catch (err) {
     return {
       content: null,
@@ -54205,6 +55040,10 @@ async function buildLogEventDetail(id, parsed, location, context2) {
   const responseBodyAvailable = event.response_body !== undefined;
   const streamCaptured = Boolean(event.stream_file);
   const { content: streamContent, warning: streamWarning } = readStreamContent(resolveLogBaseDir(context2.logConfig), event.stream_file);
+  const tokenUsage = extractTokenUsageSummaryFromLogEvent(event, {
+    baseDir: resolveLogBaseDir(context2.logConfig),
+    streamContent: streamContent ?? undefined
+  }) ?? null;
   const hasPluginData = event.plugins_request || event.plugins_response || event.request_body_after_plugins !== undefined || event.request_url_after_plugins !== undefined || event.response_body_before_plugins !== undefined || event.response_body_after_plugins !== undefined;
   const pluginsSection = hasPluginData ? {
     request: event.plugins_request,
@@ -54230,7 +55069,16 @@ async function buildLogEventDetail(id, parsed, location, context2) {
       hasError: level === "error",
       model: event.model_out || event.model_in,
       modelIn: event.model_in,
-      modelOut: event.model_out
+      modelOut: event.model_out,
+      tokenUsage
+    },
+    usage: {
+      tokenUsage,
+      requestBytes: event.request_bytes ?? 0,
+      responseBytes: event.response_bytes ?? null,
+      streamBytes: event.stream_bytes ?? null,
+      streamFileBytes: event.stream_file_bytes ?? null,
+      streamFileTruncated: event.stream_file_truncated === true
     },
     request: {
       method: event.method,
@@ -54272,16 +55120,10 @@ async function buildLogEventDetail(id, parsed, location, context2) {
 }
 async function scanEvents(baseDir, query) {
   const eventsDir = join6(baseDir, "events");
-  if (!existsSync4(eventsDir)) {
+  if (!existsSync5(eventsDir)) {
     return {
       items: [],
-      stats: {
-        total: 0,
-        errorCount: 0,
-        errorRate: 0,
-        avgLatencyMs: 0,
-        p95LatencyMs: 0
-      },
+      stats: createEmptyLogQueryStats(),
       meta: {
         scannedFiles: 0,
         scannedLines: 0,
@@ -54305,7 +55147,7 @@ async function scanEvents(baseDir, query) {
       break;
     }
     const filePath = join6(eventsDir, `${date5}.jsonl`);
-    if (!existsSync4(filePath))
+    if (!existsSync5(filePath))
       continue;
     scannedFiles += 1;
     const stream = createReadStream3(filePath, { encoding: "utf-8" });
@@ -54367,6 +55209,7 @@ async function scanEvents(baseDir, query) {
         continue;
       if (!containsKeyword(event, query.q))
         continue;
+      const tokenUsage = extractTokenUsageSummaryFromLogEvent(event, { baseDir });
       const located = {
         id: encodeEventId(date5, lineNumber),
         date: date5,
@@ -54374,7 +55217,8 @@ async function scanEvents(baseDir, query) {
         ts,
         level,
         statusClass,
-        event
+        event,
+        tokenUsage
       };
       updateRunningStats(runningStats, located);
       insertBoundedEvent(items, located, query.sort, maxKeep);
@@ -54434,13 +55278,7 @@ async function queryLogEventsInternal(context2, input, maxLimit) {
       items: [],
       nextCursor: null,
       hasMore: false,
-      stats: {
-        total: 0,
-        errorCount: 0,
-        errorRate: 0,
-        avgLatencyMs: 0,
-        p95LatencyMs: 0
-      },
+      stats: createEmptyLogQueryStats(),
       meta: {
         scannedFiles: 0,
         scannedLines: 0,
@@ -54492,7 +55330,7 @@ async function getLogEventDetailById(context2, id) {
   const { date: date5, line: line2 } = decodeEventId(id);
   const baseDir = resolveLogBaseDir(context2.logConfig);
   const filePath = join6(baseDir, "events", `${date5}.jsonl`);
-  if (!existsSync4(filePath))
+  if (!existsSync5(filePath))
     return null;
   const stream = createReadStream3(filePath, { encoding: "utf-8" });
   const rl = createInterface2({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
@@ -54523,6 +55361,7 @@ function escapeCsvValue(value) {
   return text2;
 }
 function toCsvRow(item) {
+  const usage = item.tokenUsage;
   return [
     item.id,
     item.ts,
@@ -54543,7 +55382,36 @@ function toCsvRow(item) {
     item.userKey ?? "",
     item.sessionId ?? "",
     item.message,
-    item.errorType ?? ""
+    item.errorType ?? "",
+    usage?.inputTokens ?? "",
+    usage?.outputTokens ?? "",
+    usage?.totalTokens ?? "",
+    usage?.cachedInputTokens ?? "",
+    usage?.cacheHitInputTokens ?? "",
+    usage?.cacheHitRate ?? "",
+    usage?.cacheHitRateDenominatorTokens ?? "",
+    usage?.cacheReadInputTokens ?? "",
+    usage?.cacheCreationInputTokens ?? "",
+    usage?.cacheCreationInputTokens5m ?? "",
+    usage?.cacheCreationInputTokens1h ?? "",
+    usage?.cacheWriteInputTokens ?? "",
+    usage?.cacheMissInputTokens ?? "",
+    usage?.reasoningTokens ?? "",
+    usage?.audioInputTokens ?? "",
+    usage?.audioOutputTokens ?? "",
+    usage?.textInputTokens ?? "",
+    usage?.textOutputTokens ?? "",
+    usage?.acceptedPredictionTokens ?? "",
+    usage?.rejectedPredictionTokens ?? "",
+    usage?.toolUsePromptTokens ?? "",
+    usage?.billableInputTokens ?? "",
+    usage?.billableOutputTokens ?? "",
+    usage?.creditUsage ?? "",
+    usage?.cost ?? "",
+    usage?.providerStyle ?? "",
+    usage?.source ?? "",
+    usage?.rawUsagePath ?? "",
+    usage?.cacheHitRateFormula ?? ""
   ].map(escapeCsvValue).join(",");
 }
 function createCsvExportStream(items) {
@@ -54568,7 +55436,36 @@ function createCsvExportStream(items) {
     "userKey",
     "sessionId",
     "message",
-    "errorType"
+    "errorType",
+    "usage.inputTokens",
+    "usage.outputTokens",
+    "usage.totalTokens",
+    "usage.cachedInputTokens",
+    "usage.cacheHitInputTokens",
+    "usage.cacheHitRate",
+    "usage.cacheHitRateDenominatorTokens",
+    "usage.cacheReadInputTokens",
+    "usage.cacheCreationInputTokens",
+    "usage.cacheCreationInputTokens5m",
+    "usage.cacheCreationInputTokens1h",
+    "usage.cacheWriteInputTokens",
+    "usage.cacheMissInputTokens",
+    "usage.reasoningTokens",
+    "usage.audioInputTokens",
+    "usage.audioOutputTokens",
+    "usage.textInputTokens",
+    "usage.textOutputTokens",
+    "usage.acceptedPredictionTokens",
+    "usage.rejectedPredictionTokens",
+    "usage.toolUsePromptTokens",
+    "usage.billableInputTokens",
+    "usage.billableOutputTokens",
+    "usage.creditUsage",
+    "usage.cost",
+    "usage.providerStyle",
+    "usage.source",
+    "usage.rawUsagePath",
+    "usage.cacheHitRateFormula"
   ];
   return new ReadableStream({
     start(controller) {
@@ -54648,7 +55545,7 @@ function parseBooleanFlag(value) {
 
 // src/log-sessions.ts
 init_config();
-import { createReadStream as createReadStream4, existsSync as existsSync5 } from "fs";
+import { createReadStream as createReadStream4, existsSync as existsSync6 } from "fs";
 import { join as join7 } from "path";
 import { createInterface as createInterface3 } from "readline";
 var MAX_LINES_SCANNED3 = 250000;
@@ -54771,7 +55668,7 @@ async function queryLogSessions(context2, input) {
   }
   const baseDir = resolveLogBaseDir(context2.logConfig);
   const eventsDir = join7(baseDir, "events");
-  if (!existsSync5(eventsDir)) {
+  if (!existsSync6(eventsDir)) {
     return createEmptyResult(normalized.fromMs, normalized.toMs);
   }
   const usersMap = new Map;
@@ -54790,7 +55687,7 @@ async function queryLogSessions(context2, input) {
       break;
     }
     const filePath = join7(eventsDir, `${date5}.jsonl`);
-    if (!existsSync5(filePath))
+    if (!existsSync6(filePath))
       continue;
     scannedFiles += 1;
     const stream = createReadStream4(filePath, { encoding: "utf-8" });
@@ -54899,7 +55796,7 @@ async function queryLogSessions(context2, input) {
 
 // src/log-storage.ts
 init_config();
-import { existsSync as existsSync6, promises as fsPromises } from "fs";
+import { existsSync as existsSync7, promises as fsPromises } from "fs";
 import { join as join8 } from "path";
 var cachedStorage = null;
 var calculationPromise = null;
@@ -54908,7 +55805,7 @@ var CACHE_TTL_MS2 = 60 * 60 * 1000;
 var CALCULATION_INTERVAL_MS = 60 * 60 * 1000;
 var MIN_CALCULATION_INTERVAL_MS = 5 * 60 * 1000;
 async function calculateDirSize(dirPath) {
-  if (!existsSync6(dirPath)) {
+  if (!existsSync7(dirPath)) {
     return { bytes: 0, fileCount: 0 };
   }
   let bytes = 0;
@@ -54963,7 +55860,7 @@ async function doCalculateStorage(logConfig) {
   };
 }
 async function calculateIndexSize(baseDir) {
-  if (!existsSync6(baseDir)) {
+  if (!existsSync7(baseDir)) {
     return { bytes: 0, fileCount: 0 };
   }
   let bytes = 0;
@@ -55041,7 +55938,15 @@ function subscribeLogEvents(subscriber) {
 }
 
 // src/logger.ts
-import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync4, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
+import {
+  appendFileSync,
+  closeSync as closeSync2,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync4,
+  openSync as openSync2,
+  statSync as statSync3,
+  writeSync
+} from "fs";
 import { join as join9 } from "path";
 class Logger {
   baseDir;
@@ -55070,13 +55975,13 @@ class Logger {
   }
   ensureDirs() {
     for (const dir of [this.baseDir, this.eventsDir, this.streamsDir]) {
-      if (!existsSync7(dir))
+      if (!existsSync8(dir))
         mkdirSync4(dir, { recursive: true });
     }
   }
   ensureStreamDateDir(dateStr) {
     const dir = join9(this.streamsDir, dateStr);
-    if (!existsSync7(dir))
+    if (!existsSync8(dir))
       mkdirSync4(dir, { recursive: true });
     return dir;
   }
@@ -55084,11 +55989,12 @@ class Logger {
     if (!this._enabled)
       return;
     try {
+      const enrichedEvent = enrichLogEventTokenUsage(event, { baseDir: this.baseDir });
       this.ensureDirs();
-      const dateStr = event.ts_start.slice(0, 10);
+      const dateStr = enrichedEvent.ts_start.slice(0, 10);
       const filePath = join9(this.eventsDir, `${dateStr}.jsonl`);
-      const offset = existsSync7(filePath) ? statSync2(filePath).size : 0;
-      const line2 = `${JSON.stringify(event)}
+      const offset = existsSync8(filePath) ? statSync3(filePath).size : 0;
+      const line2 = `${JSON.stringify(enrichedEvent)}
 `;
       appendFileSync(filePath, line2);
       const id = encodeOffsetLogEventId(dateStr, offset);
@@ -55098,29 +56004,80 @@ class Logger {
         date: dateStr,
         offset,
         byteLength: Buffer.byteLength(line2),
-        event
+        event: enrichedEvent
       });
-      publishLogEvent({ id, date: dateStr, filePath, offset, event });
+      publishLogEvent({ id, date: dateStr, filePath, offset, event: enrichedEvent });
     } catch (err) {
       console.error("[logger] \u4E8B\u4EF6\u65E5\u5FD7\u5199\u5165\u5931\u8D25:", err);
     }
   }
-  writeStreamFile(requestId, dateStr, content) {
-    if (!this._enabled || !this._streamsEnabled)
-      return null;
+  openStreamCapture(requestId, dateStr) {
+    if (!this._enabled || !this._streamsEnabled) {
+      return makeNoopStreamCaptureHandle();
+    }
+    const maxStreamBytes = this.maxStreamBytes;
+    const truncationMarker = Buffer.from(`
+[TRUNCATED]`);
+    let filePath;
+    let fd;
     try {
       const dir = this.ensureStreamDateDir(dateStr);
-      const filePath = join9(dir, `${requestId}.sse.raw`);
-      const toWrite = content.length > this.maxStreamBytes ? `${content.slice(0, this.maxStreamBytes)}
-[TRUNCATED]` : content;
-      writeFileSync4(filePath, toWrite);
-      return filePath;
+      filePath = join9(dir, `${requestId}.sse.raw`);
+      fd = openSync2(filePath, "a");
     } catch (err) {
-      console.error("[logger] \u6D41\u5F0F\u65E5\u5FD7\u5199\u5165\u5931\u8D25:", err);
-      return null;
+      console.error("[logger] \u6D41\u5F0F\u65E5\u5FD7\u6253\u5F00\u5931\u8D25:", err);
+      return makeNoopStreamCaptureHandle();
     }
+    let bytes = 0;
+    let truncated = false;
+    let finalized = false;
+    return {
+      filePath,
+      write(chunk) {
+        if (finalized || truncated || fd == null)
+          return;
+        try {
+          if (bytes + chunk.byteLength > maxStreamBytes) {
+            const remaining = Math.max(0, maxStreamBytes - bytes);
+            if (remaining > 0) {
+              writeSync(fd, chunk.subarray(0, remaining));
+              bytes += remaining;
+            }
+            writeSync(fd, truncationMarker);
+            truncated = true;
+            return;
+          }
+          writeSync(fd, chunk);
+          bytes += chunk.byteLength;
+        } catch (err) {
+          console.error("[logger] \u6D41\u5F0F\u65E5\u5FD7\u5199\u5165\u5931\u8D25:", err);
+          truncated = true;
+        }
+      },
+      finalize() {
+        if (finalized)
+          return { bytesWritten: bytes, truncated, filePath };
+        finalized = true;
+        if (fd != null) {
+          try {
+            closeSync2(fd);
+          } catch {}
+          fd = null;
+        }
+        return { bytesWritten: bytes, truncated, filePath };
+      }
+    };
   }
 }
+function makeNoopStreamCaptureHandle() {
+  return {
+    filePath: null,
+    write() {},
+    finalize() {
+      return { bytesWritten: 0, truncated: false, filePath: null };
+    }
+  };
+}
 var instance = null;
 function initLogger(baseDir, config2) {
   instance = new Logger(baseDir, config2);
@@ -56340,7 +57297,7 @@ var openAPISpec = {
 // src/plugin-loader.ts
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join10, resolve as resolve5 } from "path";
+import { join as join10, resolve as resolve6 } from "path";
 function isLocalPath(pkg) {
   return pkg.startsWith("./") || pkg.startsWith("../") || pkg.startsWith("/") || /^[A-Za-z]:[\\/]/.test(pkg);
 }
@@ -56396,7 +57353,7 @@ async function importPlugin(pkg, configDir) {
     const localPath = await fetchRemotePlugin(pkg);
     modulePath = `${localPath}?t=${Date.now()}`;
   } else if (isLocalPath(pkg)) {
-    const absolutePath = resolve5(configDir, pkg);
+    const absolutePath = resolve6(configDir, pkg);
     modulePath = `${absolutePath}?t=${Date.now()}`;
   } else {
     modulePath = pkg;
@@ -56512,11 +57469,6 @@ class PluginManager {
   }
 }
 
-// src/proxy.ts
-import { appendFile, readFile, unlink } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join11 } from "path";
-
 // src/plugin-engine.ts
 async function executeRequestPlugins(plugins, ctx, url2, headers, body) {
   let currentUrl = url2;
@@ -56706,28 +57658,6 @@ function buildLogEvent(logMeta, targetUrl, proxyUrl, tsEnd, overrides) {
     ...overrides
   };
 }
-function createTempStreamCapturePath(requestId) {
-  return join11(tmpdir2(), `local-router-stream-${requestId}-${Date.now()}.sse.raw`);
-}
-async function appendTempStreamCapture(filePath, chunk) {
-  await appendFile(filePath, chunk);
-}
-async function flushTempCaptureToLogger(tempPath, requestId, dateStr, logger) {
-  if (!logger)
-    return null;
-  try {
-    const text2 = await readFile(tempPath, "utf-8").catch((err) => {
-      if (err.code === "ENOENT")
-        return "";
-      throw err;
-    });
-    return logger.writeStreamFile(requestId, dateStr, text2);
-  } finally {
-    await unlink(tempPath).catch(() => {
-      return;
-    });
-  }
-}
 async function proxyRequest(c2, options) {
   const { logMeta, plugins, pluginConfigs } = options;
   const logger = getLogger();
@@ -56735,19 +57665,20 @@ async function proxyRequest(c2, options) {
   const hasPlugins = plugins && plugins.length > 0;
   let targetUrl = options.targetUrl;
   let headers = buildUpstreamHeaders(c2.req.raw.headers, options.apiKey, options.authType);
-  let bodyStr = options.body;
+  let currentBody = options.body;
+  const pluginCtx = Object.freeze({
+    requestId: logMeta.requestId,
+    provider: logMeta.provider,
+    modelIn: logMeta.modelIn,
+    modelOut: logMeta.modelOut,
+    routeType: logMeta.routeType,
+    isStream: logMeta.isStream
+  });
+  const wantsBodyLog = shouldLog && logger?.bodyPolicy !== "off";
+  const requestBodySnapshot = wantsBodyLog ? JSON.parse(JSON.stringify(options.body)) : undefined;
   const pluginLogOverrides = {};
   if (hasPlugins) {
-    const bodyObj = JSON.parse(bodyStr);
-    const ctx = {
-      requestId: logMeta.requestId,
-      provider: logMeta.provider,
-      modelIn: logMeta.modelIn,
-      modelOut: logMeta.modelOut,
-      routeType: logMeta.routeType,
-      isStream: logMeta.isStream
-    };
-    const result = await executeRequestPlugins(plugins, ctx, targetUrl, headers, bodyObj);
+    const result = await executeRequestPlugins(plugins, pluginCtx, targetUrl, headers, currentBody);
     if (pluginConfigs) {
       pluginLogOverrides.plugins_request = pluginConfigs;
     }
@@ -56756,20 +57687,20 @@ async function proxyRequest(c2, options) {
       pluginLogOverrides.request_url_after_plugins = targetUrl;
     }
     headers = result.headers;
-    const newBodyStr = JSON.stringify(result.body);
-    if (newBodyStr !== bodyStr) {
-      bodyStr = newBodyStr;
+    if (result.body !== currentBody) {
+      currentBody = result.body;
       pluginLogOverrides.request_body_after_plugins = result.body;
     }
   }
-  const requestBody = shouldLog && logger?.bodyPolicy !== "off" ? JSON.parse(options.body) : undefined;
+  const wireBody = JSON.stringify(currentBody);
+  const requestBody = requestBodySnapshot;
   const proxy = options.proxy?.trim() ? options.proxy.trim() : undefined;
   let upstreamRes;
   try {
     upstreamRes = await fetch(targetUrl, {
       method: c2.req.method,
       headers,
-      body: bodyStr,
+      body: wireBody,
       ...proxy ? { proxy } : {},
       decompress: true
     });
@@ -56799,15 +57730,7 @@ async function proxyRequest(c2, options) {
     let sseHeaders = responseHeaders;
     let sseTransform = null;
     if (hasPlugins) {
-      const ctx = {
-        requestId: logMeta.requestId,
-        provider: logMeta.provider,
-        modelIn: logMeta.modelIn,
-        modelOut: logMeta.modelOut,
-        routeType: logMeta.routeType,
-        isStream: logMeta.isStream
-      };
-      const sseResult = await createSSEPluginTransform(plugins, ctx, upstreamRes.status, responseHeaders);
+      const sseResult = await createSSEPluginTransform(plugins, pluginCtx, upstreamRes.status, responseHeaders);
       sseStatus = sseResult.status;
       sseHeaders = sseResult.headers;
       sseTransform = sseResult.transform;
@@ -56816,47 +57739,75 @@ async function proxyRequest(c2, options) {
       }
     }
     if (!shouldLog) {
-      const outputBody2 = sseTransform ? upstreamRes.body.pipeThrough(sseTransform) : upstreamRes.body;
-      return new Response(outputBody2, {
+      const outputBody = sseTransform ? upstreamRes.body.pipeThrough(sseTransform) : upstreamRes.body;
+      return new Response(outputBody, {
         status: sseStatus,
         headers: sseHeaders
       });
     }
-    const [clientStream, logStream] = upstreamRes.body.tee();
-    (async () => {
-      const tempPath = createTempStreamCapturePath(logMeta.requestId);
-      let streamBytes = 0;
-      let streamFile = null;
-      try {
-        const reader = logStream.getReader();
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done)
-            break;
-          streamBytes += value.byteLength;
-          await appendTempStreamCapture(tempPath, value);
+    const capture = logger?.openStreamCapture(logMeta.requestId, dateStr) ?? null;
+    const tokenUsageCollector = createTokenUsageStreamCollector(`${logMeta.provider} ${logMeta.routeType} ${logMeta.modelIn} ${logMeta.modelOut}`);
+    let upstreamBytes = 0;
+    let writeEventCalled = false;
+    const finalizeAndWriteEvent = () => {
+      if (writeEventCalled)
+        return;
+      writeEventCalled = true;
+      const captureResult = capture?.finalize() ?? {
+        bytesWritten: 0,
+        truncated: false,
+        filePath: null
+      };
+      const tokenUsage2 = tokenUsageCollector.getUsage();
+      logger?.writeEvent(buildLogEvent(logMeta, targetUrl, proxy, Date.now(), {
+        upstream_status: sseStatus,
+        content_type_res: contentTypeRes,
+        response_headers: sseHeaders,
+        stream_bytes: upstreamBytes,
+        provider_request_id: providerRequestId,
+        ...captureResult.filePath != null && { stream_file: captureResult.filePath },
+        ...captureResult.bytesWritten > 0 && {
+          stream_file_bytes: captureResult.bytesWritten
+        },
+        ...captureResult.truncated && { stream_file_truncated: true },
+        ...tokenUsage2 && { token_usage: tokenUsage2 },
+        ...requestBody !== undefined && { request_body: requestBody },
+        ...pluginLogOverrides
+      }));
+    };
+    const upstreamReader = upstreamRes.body.getReader();
+    const tappedStream = new ReadableStream({
+      async pull(controller) {
+        try {
+          const { done, value } = await upstreamReader.read();
+          if (done) {
+            controller.close();
+            finalizeAndWriteEvent();
+            return;
+          }
+          upstreamBytes += value.byteLength;
+          tokenUsageCollector.addChunk(value);
+          capture?.write(value);
+          controller.enqueue(value);
+        } catch (err) {
+          finalizeAndWriteEvent();
+          controller.error(err);
+        }
+      },
+      cancel(reason) {
+        try {
+          upstreamReader.cancel(reason).catch(() => {
+            return;
+          });
+        } finally {
+          finalizeAndWriteEvent();
         }
-        streamFile = await flushTempCaptureToLogger(tempPath, logMeta.requestId, dateStr, logger);
-      } catch (err) {
-        await unlink(tempPath).catch(() => {
-          return;
-        });
-        console.error("[logger] \u6D41\u5F0F\u65E5\u5FD7\u5904\u7406\u5931\u8D25:", err);
-      } finally {
-        logger?.writeEvent(buildLogEvent(logMeta, targetUrl, proxy, Date.now(), {
-          upstream_status: sseStatus,
-          content_type_res: contentTypeRes,
-          response_headers: sseHeaders,
-          stream_bytes: streamBytes,
-          provider_request_id: providerRequestId,
-          ...streamFile != null && { stream_file: streamFile },
-          ...requestBody !== undefined && { request_body: requestBody },
-          ...pluginLogOverrides
-        }));
       }
-    })();
-    const outputBody = sseTransform ? clientStream.pipeThrough(sseTransform) : clientStream;
-    return new Response(outputBody, {
+    });
+    let stream = tappedStream;
+    if (sseTransform)
+      stream = stream.pipeThrough(sseTransform);
+    return new Response(stream, {
       status: sseStatus,
       headers: sseHeaders
     });
@@ -56865,15 +57816,7 @@ async function proxyRequest(c2, options) {
   let responseStatus = upstreamRes.status;
   let finalResponseHeaders = responseHeaders;
   if (hasPlugins) {
-    const ctx = {
-      requestId: logMeta.requestId,
-      provider: logMeta.provider,
-      modelIn: logMeta.modelIn,
-      modelOut: logMeta.modelOut,
-      routeType: logMeta.routeType,
-      isStream: logMeta.isStream
-    };
-    const result = await executeJsonResponsePlugins(plugins, ctx, upstreamRes.status, responseHeaders, responseText);
+    const result = await executeJsonResponsePlugins(plugins, pluginCtx, upstreamRes.status, responseHeaders, responseText);
     if (pluginConfigs) {
       pluginLogOverrides.plugins_response = pluginConfigs;
     }
@@ -56894,12 +57837,14 @@ async function proxyRequest(c2, options) {
     });
   }
   const responseBytes = Buffer.byteLength(responseText, "utf-8");
+  const tokenUsage = extractTokenUsageFromResponseText(responseText, "response_body", `${logMeta.provider} ${logMeta.routeType} ${logMeta.modelIn} ${logMeta.modelOut}`);
   const eventOverrides = {
     upstream_status: upstreamRes.status,
     content_type_res: contentTypeRes,
     response_headers: finalResponseHeaders,
     response_bytes: responseBytes,
     provider_request_id: providerRequestId,
+    ...tokenUsage && { token_usage: tokenUsage },
     ...pluginLogOverrides
   };
   if (requestBody !== undefined) {
@@ -56950,8 +57895,10 @@ function createModelRoutingHandler(options) {
       return c2.json({ error: `provider "${target.provider}" \u672A\u5728\u914D\u7F6E\u4E2D\u5B9A\u4E49` }, 500);
     }
     payload.model = target.model;
-    const body = JSON.stringify(payload);
     const targetUrl = buildTargetUrl(provider.base);
+    const contentLengthHeader = c2.req.header("content-length");
+    const parsedContentLength = contentLengthHeader ? Number(contentLengthHeader) : NaN;
+    const requestBytes = Number.isInteger(parsedContentLength) && parsedContentLength >= 0 ? parsedContentLength : Buffer.byteLength(JSON.stringify(payload), "utf-8");
     const logMeta = {
       requestId: crypto.randomUUID(),
       tsStart: Date.now(),
@@ -56965,7 +57912,7 @@ function createModelRoutingHandler(options) {
       path: c2.req.path,
       contentTypeReq: c2.req.header("content-type") ?? null,
       userAgent: c2.req.header("user-agent") ?? null,
-      requestBytes: Buffer.byteLength(body, "utf-8"),
+      requestBytes,
       requestHeaders: collectHeaders(c2.req.raw.headers)
     };
     const plugins = pluginManager?.getPlugins(target.provider) ?? [];
@@ -56975,7 +57922,7 @@ function createModelRoutingHandler(options) {
       apiKey: provider.apiKey,
       proxy: provider.proxy,
       authType,
-      body,
+      body: payload,
       logMeta,
       plugins: plugins.length > 0 ? plugins : undefined,
       pluginConfigs: pluginConfigs.length > 0 ? pluginConfigs.map((lp) => ({
@@ -57183,7 +58130,7 @@ function createAdminApiRoutes(store, pluginManager, registerCleanup) {
   const CRYPTO_SESSION_TTL_MS = 2 * 60 * 1000;
   const CRYPTO_SESSION_MAX = 512;
   const schemaPath = getBundledSchemaPath();
-  const schemaJson = JSON.parse(readFileSync5(schemaPath, "utf-8"));
+  const schemaJson = JSON.parse(readFileSync6(schemaPath, "utf-8"));
   const pruneExpiredCryptoSessions = (now2 = Date.now()) => {
     for (const [id, record2] of Array.from(cryptoSessions.entries())) {
       if (now2 - record2.createdAt > CRYPTO_SESSION_TTL_MS) {
@@ -57788,7 +58735,7 @@ async function createApp(store, options) {
   }
   const stopLogStorageTask = startLogStorageBackgroundTask(config2.log);
   options?.registerCleanup?.(stopLogStorageTask);
-  const configDir = dirname3(resolve6(store.getPath()));
+  const configDir = dirname3(resolve7(store.getPath()));
   const pluginManager = new PluginManager(configDir);
   const reloadResult = await pluginManager.reloadAll(config2.providers);
   if (!reloadResult.ok) {
@@ -57904,24 +58851,24 @@ async function startServer(options) {
 }
 
 // src/cli/runtime.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync7, rmSync, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join12, resolve as resolve7 } from "path";
+import { join as join11, resolve as resolve8 } from "path";
 function getRuntimeDirs() {
   const override = process.env.LOCAL_ROUTER_RUNTIME_DIR;
-  const root2 = override?.trim() ? override.trim() : join12(homedir2(), ".local-router");
+  const root2 = override?.trim() ? override.trim() : join11(homedir2(), ".local-router");
   return {
     root: root2,
-    run: join12(root2, "run"),
-    logs: join12(root2, "logs")
+    run: join11(root2, "run"),
+    logs: join11(root2, "logs")
   };
 }
 function getRuntimeFiles() {
   const dirs = getRuntimeDirs();
   return {
-    pid: join12(dirs.run, "local-router.pid"),
-    state: join12(dirs.run, "status.json"),
-    daemonLog: join12(dirs.logs, "daemon.log")
+    pid: join11(dirs.run, "local-router.pid"),
+    state: join11(dirs.run, "status.json"),
+    daemonLog: join11(dirs.logs, "daemon.log")
   };
 }
 function ensureRuntimeDirs() {
@@ -57933,17 +58880,17 @@ function ensureRuntimeDirs() {
 function writeRuntimeState(state) {
   ensureRuntimeDirs();
   const files = getRuntimeFiles();
-  writeFileSync5(files.pid, `${state.pid}
+  writeFileSync4(files.pid, `${state.pid}
 `, "utf-8");
-  writeFileSync5(files.state, JSON.stringify(state, null, 2), "utf-8");
+  writeFileSync4(files.state, JSON.stringify(state, null, 2), "utf-8");
 }
 function readRuntimeState() {
   const files = getRuntimeFiles();
-  if (!existsSync8(files.state)) {
+  if (!existsSync9(files.state)) {
     return null;
   }
   try {
-    return JSON.parse(readFileSync6(files.state, "utf-8"));
+    return JSON.parse(readFileSync7(files.state, "utf-8"));
   } catch {
     return null;
   }
@@ -57954,7 +58901,7 @@ function clearRuntimeFiles() {
   rmSync(files.state, { force: true });
 }
 function resolveConfigArgPath(pathValue) {
-  return resolve7(pathValue);
+  return resolve8(pathValue);
 }
 
 // src/cli/process.ts
@@ -58094,8 +59041,8 @@ async function startDaemon(flags) {
   }
   ensureRuntimeDirs();
   const files = getRuntimeFiles();
-  const stdoutFd = openSync2(files.daemonLog, "a");
-  const stderrFd = openSync2(files.daemonLog, "a");
+  const stdoutFd = openSync3(files.daemonLog, "a");
+  const stderrFd = openSync3(files.daemonLog, "a");
   const childArgs = [process.argv[1] ?? "src/cli.ts", "__run-server", "--mode", "daemon"];
   if (flags.config) {
     childArgs.push("--config", resolveConfigArgPath(flags.config));
@@ -58116,8 +59063,8 @@ async function startDaemon(flags) {
     stderr: stderrFd,
     detached: true
   });
-  closeSync2(stdoutFd);
-  closeSync2(stderrFd);
+  closeSync3(stdoutFd);
+  closeSync3(stderrFd);
   child.unref();
   for (let i = 0;i < 24; i += 1) {
     await sleep(250);
@@ -58132,7 +59079,7 @@ async function startDaemon(flags) {
   }
   let tail = "";
   try {
-    const content = readFileSync7(files.daemonLog, "utf-8");
+    const content = readFileSync8(files.daemonLog, "utf-8");
     tail = content.split(`
 `).slice(-20).join(`
 `);
@@ -58165,11 +59112,11 @@ async function stopProcess(graceMs = 8000) {
 }
 function readLogDelta(filePath, offset) {
   try {
-    const stats = statSync3(filePath);
+    const stats = statSync4(filePath);
     if (stats.size <= offset) {
       return { content: "", nextOffset: offset };
     }
-    const full = readFileSync7(filePath, "utf-8");
+    const full = readFileSync8(filePath, "utf-8");
     const content = full.slice(offset);
     return { content, nextOffset: full.length };
   } catch {
@@ -59182,13 +60129,13 @@ init_config();
 init_config_validate();
 init_errors();
 init_output();
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { parseArgs as parseArgs4 } from "util";
 init_registry();
 function tryRead(configArg) {
   try {
     const path = resolveConfigPath(configArg);
-    if (!existsSync10(path)) {
+    if (!existsSync11(path)) {
       return { path, config: null, error: `\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728: ${path}` };
     }
     const config2 = loadConfig(path);
@@ -59623,7 +60570,7 @@ defineCommand({
 });
 
 // src/cli/handlers/introspection.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { parseArgs as parseArgs5 } from "util";
 
@@ -59899,7 +60846,7 @@ defineCommand({
               hint: "\u8BF7\u786E\u8BA4 npm \u5305\u5B8C\u6574\u6027\uFF0C\u6216\u5F00\u53D1\u6A21\u5F0F\u4E0B\u4ECE\u6E90\u7801\u8FD0\u884C"
             });
           }
-          const text2 = readFileSync9(fileURLToPath2(schemaUrl), "utf-8");
+          const text2 = readFileSync10(fileURLToPath2(schemaUrl), "utf-8");
           const data2 = JSON.parse(text2);
           emitResult(ctx, {
             command: "schema.config",
@@ -60119,7 +61066,7 @@ defineCommand({
 
 // src/cli/handlers/lifecycle.ts
 init_config();
-import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
 import { setTimeout as sleep3 } from "timers/promises";
 import { parseArgs as parseArgs6 } from "util";
 init_errors();
@@ -60424,10 +61371,10 @@ defineCommand({
   })
 });
 function readLastLines(filePath, lines) {
-  if (!existsSync11(filePath)) {
+  if (!existsSync12(filePath)) {
     return { content: "", offset: 0 };
   }
-  const full = readFileSync10(filePath, "utf-8");
+  const full = readFileSync11(filePath, "utf-8");
   const rendered = full.split(`
 `).slice(-lines).join(`
 `);
@@ -60458,7 +61405,7 @@ defineCommand({
       const linesRaw = parsed.values.lines ?? "100";
       const lines = Number.parseInt(linesRaw, 10);
       const initial = readLastLines(files.daemonLog, Number.isFinite(lines) ? lines : 100);
-      if (!existsSync11(files.daemonLog)) {
+      if (!existsSync12(files.daemonLog)) {
         emitResult(ctx, {
           command: "logs.daemon",
           data: { exists: false, path: files.daemonLog, lines: [] },