@lakphy/local-router 0.5.2 → 0.5.5

package/dist/entry.js

@@ -4934,7 +4934,7 @@ var require_compile = __commonJS((exports) => {
     const schOrFunc = root2.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve4.call(this, root2, ref);
+    let _sch = resolve5.call(this, root2, ref);
     if (_sch === undefined) {
       const schema = (_a21 = root2.localRefs) === null || _a21 === undefined ? undefined : _a21[ref];
       const { schemaId } = this.opts;
@@ -4961,7 +4961,7 @@ var require_compile = __commonJS((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve4(root2, ref) {
+  function resolve5(root2, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -5491,7 +5491,7 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     return uri;
   }
-  function resolve4(baseURI, relativeURI, options) {
+  function resolve5(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const resolved = resolveComponent(parse7(baseURI, schemelessOptions), parse7(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
@@ -5719,7 +5719,7 @@ var require_fast_uri = __commonJS((exports, module) => {
   var fastUri = {
     SCHEMES,
     normalize,
-    resolve: resolve4,
+    resolve: resolve5,
     resolveComponent,
     equal,
     serialize,
@@ -9284,8 +9284,218 @@ var require_dist2 = __commonJS((exports, module) => {
 });
 
 // src/index.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname2, resolve as resolve6 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname3, resolve as resolve8 } from "path";
+
+// src/cli/autostart.ts
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir as homedir2, platform } from "os";
+import { dirname, join as join2 } from "path";
+
+// src/cli/runtime.ts
+import { homedir } from "os";
+import { join, resolve } from "path";
+function getRuntimeDirs() {
+  const override = process.env.LOCAL_ROUTER_RUNTIME_DIR;
+  const root = override?.trim() ? override.trim() : join(homedir(), ".local-router");
+  return {
+    root,
+    run: join(root, "run"),
+    logs: join(root, "logs")
+  };
+}
+
+// src/cli/autostart.ts
+var LABEL = "com.lakphy.local-router";
+function getDaemonLogPath() {
+  return getRuntimeDirs().logs + "/daemon.log";
+}
+function getLaunchAgentPath() {
+  return join2(homedir2(), "Library", "LaunchAgents", `${LABEL}.plist`);
+}
+function buildPlist(opts) {
+  const logPath = getDaemonLogPath();
+  const args = [opts.execPath, ...opts.args].map((a) => `    <string>${escapeXml(a)}</string>`).join(`
+`);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${escapeXml(opts.label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(logPath)}</string>
+</dict>
+</plist>
+`;
+}
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function createMacosManager() {
+  const plistPath = getLaunchAgentPath();
+  return {
+    platform: "macos",
+    async isInstalled() {
+      return existsSync(plistPath);
+    },
+    async install(opts) {
+      const dir = dirname(plistPath);
+      if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+      writeFileSync(plistPath, buildPlist(opts), "utf-8");
+      try {
+        execSync(`launchctl bootout gui/$(id -u) ${plistPath} 2>/dev/null`, { stdio: "ignore" });
+      } catch {}
+      execSync(`launchctl bootstrap gui/$(id -u) ${plistPath}`, { stdio: "ignore" });
+    },
+    async uninstall() {
+      if (!existsSync(plistPath))
+        return;
+      try {
+        execSync(`launchctl bootout gui/$(id -u) ${plistPath}`, { stdio: "ignore" });
+      } catch {}
+      rmSync(plistPath, { force: true });
+    },
+    getServicePath() {
+      return plistPath;
+    }
+  };
+}
+function getSystemdUnitPath() {
+  return join2(homedir2(), ".config", "systemd", "user", "local-router.service");
+}
+function buildUnit(opts) {
+  const logPath = getDaemonLogPath();
+  const execStart = [opts.execPath, ...opts.args].join(" ");
+  return `[Unit]
+Description=Local Router API Gateway
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${execStart}
+Restart=on-failure
+RestartSec=5
+StandardOutput=append:${logPath}
+StandardError=append:${logPath}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function createLinuxManager() {
+  const unitPath = getSystemdUnitPath();
+  return {
+    platform: "linux",
+    async isInstalled() {
+      if (!existsSync(unitPath))
+        return false;
+      try {
+        const out = execSync("systemctl --user is-enabled local-router 2>/dev/null", {
+          encoding: "utf-8"
+        }).trim();
+        return out === "enabled";
+      } catch {
+        return false;
+      }
+    },
+    async install(opts) {
+      const dir = dirname(unitPath);
+      if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+      writeFileSync(unitPath, buildUnit(opts), "utf-8");
+      execSync("systemctl --user daemon-reload", { stdio: "ignore" });
+      execSync("systemctl --user enable local-router", { stdio: "ignore" });
+    },
+    async uninstall() {
+      try {
+        execSync("systemctl --user disable local-router", { stdio: "ignore" });
+      } catch {}
+      rmSync(unitPath, { force: true });
+      try {
+        execSync("systemctl --user daemon-reload", { stdio: "ignore" });
+      } catch {}
+    },
+    getServicePath() {
+      return unitPath;
+    }
+  };
+}
+var WIN_REG_KEY = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
+var WIN_REG_VALUE = "LocalRouter";
+function createWindowsManager() {
+  return {
+    platform: "windows",
+    async isInstalled() {
+      try {
+        execSync(`reg query "${WIN_REG_KEY}" /v ${WIN_REG_VALUE}`, { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async install(opts) {
+      const cmd = [opts.execPath, ...opts.args].map((a) => `"${a}"`).join(" ");
+      execSync(`reg add "${WIN_REG_KEY}" /v ${WIN_REG_VALUE} /t REG_SZ /d "${cmd}" /f`, {
+        stdio: "ignore"
+      });
+    },
+    async uninstall() {
+      try {
+        execSync(`reg delete "${WIN_REG_KEY}" /v ${WIN_REG_VALUE} /f`, { stdio: "ignore" });
+      } catch {}
+    },
+    getServicePath() {
+      return `${WIN_REG_KEY}\\${WIN_REG_VALUE}`;
+    }
+  };
+}
+function createUnsupportedManager() {
+  return {
+    platform: "unsupported",
+    async isInstalled() {
+      return false;
+    },
+    async install() {
+      throw new Error("\u5F53\u524D\u5E73\u53F0\u4E0D\u652F\u6301\u81EA\u542F\u52A8");
+    },
+    async uninstall() {
+      throw new Error("\u5F53\u524D\u5E73\u53F0\u4E0D\u652F\u6301\u81EA\u542F\u52A8");
+    },
+    getServicePath() {
+      return "";
+    }
+  };
+}
+function createAutostartManager() {
+  const p = platform();
+  if (p === "darwin")
+    return createMacosManager();
+  if (p === "linux")
+    return createLinuxManager();
+  if (p === "win32")
+    return createWindowsManager();
+  return createUnsupportedManager();
+}
+function getAutostartExecArgs() {
+  const script = process.argv[1] ?? "dist/cli.js";
+  return {
+    execPath: process.execPath,
+    args: [script, "__run-server", "--mode", "daemon"]
+  };
+}
 
 // node_modules/.bun/@ai-sdk+provider@3.0.8/node_modules/@ai-sdk/provider/dist/index.mjs
 var marker = "vercel.ai.error";
@@ -29133,7 +29343,7 @@ function createProviderToolFactoryWithOutputSchema({
     supportsDeferredResults
   });
 }
-async function resolve(value) {
+async function resolve2(value) {
   if (typeof value === "function") {
     value = value();
   }
@@ -32078,11 +32288,11 @@ var AnthropicMessagesLanguageModel = class {
     betas,
     headers
   }) {
-    return combineHeaders(await resolve(this.config.headers), headers, betas.size > 0 ? { "anthropic-beta": Array.from(betas).join(",") } : {});
+    return combineHeaders(await resolve2(this.config.headers), headers, betas.size > 0 ? { "anthropic-beta": Array.from(betas).join(",") } : {});
   }
   async getBetasFromHeaders(requestHeaders) {
     var _a16, _b16;
-    const configHeaders = await resolve(this.config.headers);
+    const configHeaders = await resolve2(this.config.headers);
     const configBetaHeader = (_a16 = configHeaders["anthropic-beta"]) != null ? _a16 : "";
     const requestBetaHeader = (_b16 = requestHeaders == null ? undefined : requestHeaders["anthropic-beta"]) != null ? _b16 : "";
     return new Set([
@@ -41267,7 +41477,7 @@ var GatewayFetchMetadata = class {
     try {
       const { value } = await getFromApi({
         url: `${this.config.baseURL}/config`,
-        headers: await resolve(this.config.headers()),
+        headers: await resolve2(this.config.headers()),
         successfulResponseHandler: createJsonResponseHandler(gatewayAvailableModelsResponseSchema),
         failedResponseHandler: createJsonErrorResponseHandler({
           errorSchema: exports_external.any(),
@@ -41285,7 +41495,7 @@ var GatewayFetchMetadata = class {
       const baseUrl = new URL(this.config.baseURL);
       const { value } = await getFromApi({
         url: `${baseUrl.origin}/v1/credits`,
-        headers: await resolve(this.config.headers()),
+        headers: await resolve2(this.config.headers()),
         successfulResponseHandler: createJsonResponseHandler(gatewayCreditsResponseSchema),
         failedResponseHandler: createJsonErrorResponseHandler({
           errorSchema: exports_external.any(),
@@ -41350,7 +41560,7 @@ var GatewayLanguageModel = class {
   async doGenerate(options) {
     const { args, warnings } = await this.getArgs(options);
     const { abortSignal } = options;
-    const resolvedHeaders = await resolve(this.config.headers());
+    const resolvedHeaders = await resolve2(this.config.headers());
     try {
       const {
         responseHeaders,
@@ -41358,7 +41568,7 @@ var GatewayLanguageModel = class {
         rawValue: rawResponse
       } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, options.headers, this.getModelConfigHeaders(this.modelId, false), await resolve(this.config.o11yHeaders)),
+        headers: combineHeaders(resolvedHeaders, options.headers, this.getModelConfigHeaders(this.modelId, false), await resolve2(this.config.o11yHeaders)),
         body: args,
         successfulResponseHandler: createJsonResponseHandler(exports_external.any()),
         failedResponseHandler: createJsonErrorResponseHandler({
@@ -41381,11 +41591,11 @@ var GatewayLanguageModel = class {
   async doStream(options) {
     const { args, warnings } = await this.getArgs(options);
     const { abortSignal } = options;
-    const resolvedHeaders = await resolve(this.config.headers());
+    const resolvedHeaders = await resolve2(this.config.headers());
     try {
       const { value: response, responseHeaders } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, options.headers, this.getModelConfigHeaders(this.modelId, true), await resolve(this.config.o11yHeaders)),
+        headers: combineHeaders(resolvedHeaders, options.headers, this.getModelConfigHeaders(this.modelId, true), await resolve2(this.config.o11yHeaders)),
         body: args,
         successfulResponseHandler: createEventSourceResponseHandler(exports_external.any()),
         failedResponseHandler: createJsonErrorResponseHandler({
@@ -41471,7 +41681,7 @@ var GatewayEmbeddingModel = class {
     providerOptions
   }) {
     var _a92;
-    const resolvedHeaders = await resolve(this.config.headers());
+    const resolvedHeaders = await resolve2(this.config.headers());
     try {
       const {
         responseHeaders,
@@ -41479,7 +41689,7 @@ var GatewayEmbeddingModel = class {
         rawValue
       } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve(this.config.o11yHeaders)),
+        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve2(this.config.o11yHeaders)),
         body: {
           values,
           ...providerOptions ? { providerOptions } : {}
@@ -41541,7 +41751,7 @@ var GatewayImageModel = class {
     abortSignal
   }) {
     var _a92, _b92, _c, _d;
-    const resolvedHeaders = await resolve(this.config.headers());
+    const resolvedHeaders = await resolve2(this.config.headers());
     try {
       const {
         responseHeaders,
@@ -41549,7 +41759,7 @@ var GatewayImageModel = class {
         rawValue
       } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve(this.config.o11yHeaders)),
+        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve2(this.config.o11yHeaders)),
         body: {
           prompt,
           n,
@@ -41664,11 +41874,11 @@ var GatewayVideoModel = class {
     abortSignal
   }) {
     var _a92;
-    const resolvedHeaders = await resolve(this.config.headers());
+    const resolvedHeaders = await resolve2(this.config.headers());
     try {
       const { responseHeaders, value: responseBody } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve(this.config.o11yHeaders), { accept: "text/event-stream" }),
+        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve2(this.config.o11yHeaders), { accept: "text/event-stream" }),
         body: {
           prompt,
           n,
@@ -44539,7 +44749,7 @@ var object2 = ({
   const schema = asSchema(inputSchema);
   return {
     name: "object",
-    responseFormat: resolve(schema.jsonSchema).then((jsonSchema2) => ({
+    responseFormat: resolve2(schema.jsonSchema).then((jsonSchema2) => ({
       type: "json",
       schema: jsonSchema2,
       ...name21 != null && { name: name21 },
@@ -44601,7 +44811,7 @@ var array2 = ({
   const elementSchema = asSchema(inputElementSchema);
   return {
     name: "array",
-    responseFormat: resolve(elementSchema.jsonSchema).then((jsonSchema2) => {
+    responseFormat: resolve2(elementSchema.jsonSchema).then((jsonSchema2) => {
       const { $schema, ...itemSchema } = jsonSchema2;
       return {
         type: "json",
@@ -49860,7 +50070,7 @@ var Hono2 = class extends Hono {
 
 // node_modules/.bun/hono@4.12.5/node_modules/hono/dist/adapter/bun/serve-static.js
 import { stat } from "fs/promises";
-import { join } from "path";
+import { join as join3 } from "path";
 
 // node_modules/.bun/hono@4.12.5/node_modules/hono/dist/utils/compress.js
 var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/(?!event-stream(?:[;\s]|$))[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
@@ -49965,7 +50175,7 @@ var DEFAULT_DOCUMENT = "index.html";
 var serveStatic = (options) => {
   const root = options.root ?? "./";
   const optionPath = options.path;
-  const join = options.join ?? defaultJoin;
+  const join3 = options.join ?? defaultJoin;
   return async (c, next) => {
     if (c.finalized) {
       return next();
@@ -49984,9 +50194,9 @@ var serveStatic = (options) => {
         return next();
       }
     }
-    let path = join(root, !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename);
+    let path = join3(root, !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename);
     if (options.isDir && await options.isDir(path)) {
-      path = join(path, DEFAULT_DOCUMENT);
+      path = join3(path, DEFAULT_DOCUMENT);
     }
     const getContent = options.getContent;
     let content = await getContent(path, c);
@@ -50038,7 +50248,7 @@ var serveStatic2 = (options) => {
     return serveStatic({
       ...options,
       getContent,
-      join,
+      join: join3,
       isDir
     })(c, next);
   };
@@ -50130,9 +50340,9 @@ var upgradeWebSocket = defineWebSocketHelper((c, events) => {
 });
 
 // src/config.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { join as join2, resolve as resolve2 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4, resolve as resolve3 } from "path";
 
 // node_modules/.bun/json5@2.2.3/node_modules/json5/dist/index.mjs
 var Space_Separator = /[\u1680\u2000-\u200A\u202F\u205F\u3000]/;
@@ -51300,8 +51510,8 @@ var DEFAULT_CONFIG = `{
   // },
 }`;
 function loadConfig(configPath) {
-  const absolutePath = resolve2(configPath);
-  const content = readFileSync(absolutePath, "utf-8");
+  const absolutePath = resolve3(configPath);
+  const content = readFileSync2(absolutePath, "utf-8");
   const config2 = dist_default.parse(content);
   for (const [routeType, modelMap] of Object.entries(config2.routes)) {
     if (!modelMap["*"]) {
@@ -51316,21 +51526,21 @@ function loadConfig(configPath) {
   return config2;
 }
 function createDefaultConfig(configPath) {
-  const configDir = resolve2(configPath, "..");
-  if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true });
+  const configDir = resolve3(configPath, "..");
+  if (!existsSync2(configDir)) {
+    mkdirSync2(configDir, { recursive: true });
   }
-  writeFileSync(configPath, DEFAULT_CONFIG, "utf-8");
+  writeFileSync2(configPath, DEFAULT_CONFIG, "utf-8");
   console.log(`\u5DF2\u521B\u5EFA\u9ED8\u8BA4\u914D\u7F6E\u6587\u4EF6: ${configPath}`);
 }
 function resolveDefaultConfigPath() {
   const localConfig = "config.json5";
-  if (existsSync(localConfig)) {
+  if (existsSync2(localConfig)) {
     return localConfig;
   }
-  const globalConfigDir = join2(homedir(), ".local-router");
-  const globalConfig2 = join2(globalConfigDir, "config.json5");
-  if (!existsSync(globalConfig2)) {
+  const globalConfigDir = join4(homedir3(), ".local-router");
+  const globalConfig2 = join4(globalConfigDir, "config.json5");
+  if (!existsSync2(globalConfig2)) {
     createDefaultConfig(globalConfig2);
   }
   return globalConfig2;
@@ -51349,19 +51559,19 @@ function parseConfigPath() {
 }
 function resolveLogBaseDir(logConfig) {
   if (logConfig?.baseDir) {
-    return resolve2(logConfig.baseDir);
+    return resolve3(logConfig.baseDir);
   }
-  return join2(homedir(), ".local-router", "logs");
+  return join4(homedir3(), ".local-router", "logs");
 }
 
 // src/config-store.ts
-import { writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve3 } from "path";
+import { writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve4 } from "path";
 class ConfigStore {
   config;
   absolutePath;
   constructor(configPath) {
-    this.absolutePath = resolve3(configPath);
+    this.absolutePath = resolve4(configPath);
     this.config = loadConfig(this.absolutePath);
   }
   get() {
@@ -51376,7 +51586,7 @@ class ConfigStore {
   }
   save(newConfig) {
     const content = dist_default.stringify(newConfig, { space: 2, quote: '"' });
-    writeFileSync2(this.absolutePath, content, "utf-8");
+    writeFileSync3(this.absolutePath, content, "utf-8");
   }
   validate(config2) {
     for (const [routeType, modelMap] of Object.entries(config2.routes)) {
@@ -51395,7 +51605,7 @@ class ConfigStore {
 // src/config-validate.ts
 var import__2020 = __toESM(require_2020(), 1);
 var import_ajv_formats = __toESM(require_dist2(), 1);
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 
 // src/runtime-assets.ts
 import { fileURLToPath } from "url";
@@ -51426,7 +51636,7 @@ function validateConfigOrThrow(config2) {
   validateBusinessRules(config2);
   const ajv = new import__2020.default({ allErrors: true, strict: false });
   import_ajv_formats.default(ajv);
-  const schemaJson = JSON.parse(readFileSync2(getBundledSchemaPath(), "utf-8"));
+  const schemaJson = JSON.parse(readFileSync3(getBundledSchemaPath(), "utf-8"));
   const validateBySchema = ajv.compile(schemaJson);
   const valid = validateBySchema(config2);
   if (!valid) {
@@ -51487,8 +51697,8 @@ class CryptoSession {
 }
 
 // src/log-metrics.ts
-import { createReadStream, existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
+import { createReadStream, existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
 import { createInterface } from "readline";
 var WINDOW_MS = {
   "1h": 60 * 60 * 1000,
@@ -51605,8 +51815,8 @@ async function getLogMetrics(options) {
   if (!refresh && cached2 && cached2.expiresAt > nowMs) {
     return cached2.value;
   }
-  const eventsDir = join3(baseDir, "events");
-  if (!existsSync2(eventsDir)) {
+  const eventsDir = join5(baseDir, "events");
+  if (!existsSync3(eventsDir)) {
     const empty = createEmptyMetrics(window2, nowMs, {
       logEnabled: true,
       baseDir,
@@ -51652,8 +51862,8 @@ async function getLogMetrics(options) {
       partial2 = true;
       break;
     }
-    const filePath = join3(eventsDir, `${dateStr}.jsonl`);
-    if (!existsSync2(filePath))
+    const filePath = join5(eventsDir, `${dateStr}.jsonl`);
+    if (!existsSync3(filePath))
       continue;
     filesScanned += 1;
     try {
@@ -51789,8 +51999,8 @@ async function getLogMetrics(options) {
 }
 
 // src/log-query.ts
-import { createReadStream as createReadStream3, existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { join as join5, resolve as resolve4 } from "path";
+import { createReadStream as createReadStream3, existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { join as join7, resolve as resolve6 } from "path";
 import { createInterface as createInterface2 } from "readline";
 
 // src/log-index.ts
@@ -51798,13 +52008,13 @@ import { Database } from "bun:sqlite";
 import {
   closeSync,
   createReadStream as createReadStream2,
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync2,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync3,
   openSync,
   readSync,
-  statSync
+  statSync as statSync2
 } from "fs";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 
 // src/log-session-identity.ts
 var USER_SESSION_DELIMITER = "_account__session_";
@@ -51882,8 +52092,588 @@ function resolveLogSessionIdentity(requestBody) {
   };
 }
 
+// src/token-usage.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4, statSync } from "fs";
+import { resolve as resolve5 } 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(resolve5(baseDir, streamFile));
+    for (const candidate of candidates) {
+      const resolved = resolve5(candidate);
+      if (!resolved.endsWith(".sse.raw"))
+        continue;
+      if (!existsSync4(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_VERSION = 1;
+var SCHEMA_VERSION = 3;
 var MAX_INDEX_QUEUE = 20000;
 var INDEX_BATCH_SIZE = 250;
 var INDEX_FLUSH_DELAY_MS = 50;
@@ -52027,6 +52817,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,
@@ -52054,8 +52845,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 {
@@ -52078,7 +52907,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) {
@@ -52148,7 +52978,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 = {}) {
@@ -52231,8 +53076,8 @@ class LogIndex {
   constructor(baseDir, config2) {
     this.baseDir = baseDir;
     this.config = config2;
-    mkdirSync2(baseDir, { recursive: true });
-    const dbPath = join4(baseDir, "logs-index.sqlite");
+    mkdirSync3(baseDir, { recursive: true });
+    const dbPath = join6(baseDir, "logs-index.sqlite");
     this.db = new Database(dbPath, { create: true, strict: true });
     this.configure();
     this.migrate();
@@ -52241,12 +53086,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 = ?");
@@ -52292,13 +53153,13 @@ class LogIndex {
     let scannedFiles = 0;
     let scannedLines = 0;
     let parseErrors = 0;
-    const eventsDir = join4(this.baseDir, "events");
+    const eventsDir = join6(this.baseDir, "events");
     const dates = listDateStrings2(fromMs, toMs);
     for (const date5 of dates) {
-      const filePath = join4(eventsDir, `${date5}.jsonl`);
-      if (!existsSync3(filePath))
+      const filePath = join6(eventsDir, `${date5}.jsonl`);
+      if (!existsSync5(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);
@@ -52333,7 +53194,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}
@@ -52387,8 +53248,8 @@ class LogIndex {
     if (!parsedId)
       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 ?? join4(this.baseDir, "events", `${parsedId.date}.jsonl`);
-    if (!existsSync3(filePath))
+    const filePath = row?.source_file ?? join6(this.baseDir, "events", `${parsedId.date}.jsonl`);
+    if (!existsSync5(filePath))
       return null;
     const line2 = readLineAtOffset(filePath, row?.byte_offset ?? parsedId.offset);
     if (!line2?.trim())
@@ -52456,7 +53317,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
@@ -52474,12 +53364,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_VERSION) {
+      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_VERSION));
   }
+  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;
@@ -52507,6 +53452,7 @@ class LogIndex {
       return;
     const id = encodeOffsetLogEventId(item.date, item.offset);
     const row = eventToRow({
+      baseDir: this.baseDir,
       id,
       date: item.date,
       filePath: item.filePath,
@@ -52522,7 +53468,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 {}
@@ -52549,6 +53495,7 @@ class LogIndex {
           continue;
         }
         const row = eventToRow({
+          baseDir: this.baseDir,
           id: encodeOffsetLogEventId(date5, item.offset),
           date: date5,
           filePath,
@@ -52581,7 +53528,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);
@@ -52602,7 +53563,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
     };
   }
 }
@@ -52682,8 +53658,8 @@ function getIndexedLogEventDetail(logConfig, id) {
   const parsedId = decodeOffsetLogEventId(id);
   if (!parsedId)
     return null;
-  const filePath = join4(baseDir, "events", `${parsedId.date}.jsonl`);
-  if (!existsSync3(filePath))
+  const filePath = join6(baseDir, "events", `${parsedId.date}.jsonl`);
+  if (!existsSync5(filePath))
     return null;
   const line2 = readLineAtOffset(filePath, parsedId.offset);
   if (!line2?.trim())
@@ -52790,12 +53766,8 @@ function buildMessage2(event) {
   const status = event.upstream_status ?? 0;
   return `${event.method} ${event.path} -> ${status}`;
 }
-function containsKeyword(event, q) {
-  if (!q)
-    return true;
-  const identity = resolveLogSessionIdentity(event.request_body);
-  const keyword = q.toLowerCase();
-  const haystack = [
+function buildKeywordText(event, identity) {
+  return [
     event.request_id,
     event.path,
     event.provider,
@@ -52809,15 +53781,38 @@ function containsKeyword(event, q) {
     event.error_message ?? "",
     buildMessage2(event)
   ].join(" ").toLowerCase();
-  return haystack.includes(keyword);
+}
+function containsKeyword(event, q) {
+  if (!q)
+    return true;
+  const identity = resolveLogSessionIdentity(event.request_body);
+  const keyword = q.toLowerCase();
+  return buildKeywordText(event, identity).includes(keyword);
 }
 function createRunningStats() {
   return {
     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;
@@ -52828,6 +53823,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)
@@ -52850,7 +53862,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 {
@@ -52858,8 +53885,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) {
@@ -52910,7 +53955,7 @@ function normalizeQuery(input, maxLimit = MAX_QUERY_LIMIT) {
 }
 function eventToSummary(item) {
   const { event } = item;
-  const identity = resolveLogSessionIdentity(event.request_body);
+  const identity = item.identity ?? resolveLogSessionIdentity(event.request_body);
   return {
     id: item.id,
     ts: event.ts_start,
@@ -52931,21 +53976,43 @@ 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) {
+function extractLogEventFacts(event) {
   const ts = Date.parse(event.ts_start);
+  const level = getLevel2(event);
+  const statusClass = getStatusClass3(event);
+  const identity = resolveLogSessionIdentity(event.request_body);
+  return {
+    event,
+    ts: Number.isFinite(ts) ? ts : Number.NaN,
+    level,
+    statusClass,
+    model: event.model_out || event.model_in,
+    identity,
+    hasError: level === "error",
+    keywordText: buildKeywordText(event, identity),
+    tokenUsage: extractTokenUsageSummaryFromLogEvent(event)
+  };
+}
+function createLogEventSummaryFromFacts(facts, location) {
   return eventToSummary({
     id: location.id,
     date: location.date,
     line: location.line ?? 0,
-    ts: Number.isFinite(ts) ? ts : 0,
-    level: getLevel2(event),
-    statusClass: getStatusClass3(event),
-    event
+    ts: facts.ts,
+    level: facts.level,
+    statusClass: facts.statusClass,
+    event: facts.event,
+    identity: facts.identity,
+    tokenUsage: facts.tokenUsage
   });
 }
+function createLogEventSummaryFromEvent(event, location) {
+  return createLogEventSummaryFromFacts(extractLogEventFacts(event), location);
+}
 function logEventMatchesQuery(event, query) {
   if (!event.ts_start)
     return false;
@@ -53032,23 +54099,23 @@ function readStreamContent(baseDir, streamFile) {
   if (!streamFile)
     return { content: null, warning: null };
   try {
-    const resolvedBase = resolve4(baseDir);
-    const resolvedFromFile = resolve4(streamFile);
+    const resolvedBase = resolve6(baseDir);
+    const resolvedFromFile = resolve6(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: readFileSync3(resolvedFromFile, "utf-8"), warning: null };
+    if (existsSync6(resolvedFromFile)) {
+      return { content: readFileSync5(resolvedFromFile, "utf-8"), warning: null };
     }
-    const fallbackPath = resolve4(resolvedBase, streamFile);
+    const fallbackPath = resolve6(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 (!existsSync6(fallbackPath)) {
       return { content: null, warning: "stream_file \u4E0D\u5B58\u5728\uFF0C\u53EF\u80FD\u5DF2\u88AB\u6E05\u7406\u3002" };
     }
-    return { content: readFileSync3(fallbackPath, "utf-8"), warning: null };
+    return { content: readFileSync5(fallbackPath, "utf-8"), warning: null };
   } catch (err) {
     return {
       content: null,
@@ -53065,6 +54132,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,
@@ -53090,7 +54161,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,
@@ -53131,17 +54211,11 @@ async function buildLogEventDetail(id, parsed, location, context2) {
   };
 }
 async function scanEvents(baseDir, query) {
-  const eventsDir = join5(baseDir, "events");
-  if (!existsSync4(eventsDir)) {
+  const eventsDir = join7(baseDir, "events");
+  if (!existsSync6(eventsDir)) {
     return {
       items: [],
-      stats: {
-        total: 0,
-        errorCount: 0,
-        errorRate: 0,
-        avgLatencyMs: 0,
-        p95LatencyMs: 0
-      },
+      stats: createEmptyLogQueryStats(),
       meta: {
         scannedFiles: 0,
         scannedLines: 0,
@@ -53164,8 +54238,8 @@ async function scanEvents(baseDir, query) {
       truncated = true;
       break;
     }
-    const filePath = join5(eventsDir, `${date5}.jsonl`);
-    if (!existsSync4(filePath))
+    const filePath = join7(eventsDir, `${date5}.jsonl`);
+    if (!existsSync6(filePath))
       continue;
     scannedFiles += 1;
     const stream = createReadStream3(filePath, { encoding: "utf-8" });
@@ -53227,6 +54301,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,
@@ -53234,7 +54309,8 @@ async function scanEvents(baseDir, query) {
         ts,
         level,
         statusClass,
-        event
+        event,
+        tokenUsage
       };
       updateRunningStats(runningStats, located);
       insertBoundedEvent(items, located, query.sort, maxKeep);
@@ -53254,6 +54330,9 @@ async function scanEvents(baseDir, query) {
 function isLogQueryWindow(value) {
   return value === "1h" || value === "6h" || value === "24h";
 }
+function getLogQueryWindowMs(window2) {
+  return WINDOW_MS2[window2];
+}
 function resolveLogQueryRange(input) {
   const nowMs = input.nowMs ?? Date.now();
   const hasFrom = !!input.from;
@@ -53294,13 +54373,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,
@@ -53351,8 +54424,8 @@ async function getLogEventDetailById(context2, id) {
   }
   const { date: date5, line: line2 } = decodeEventId(id);
   const baseDir = resolveLogBaseDir(context2.logConfig);
-  const filePath = join5(baseDir, "events", `${date5}.jsonl`);
-  if (!existsSync4(filePath))
+  const filePath = join7(baseDir, "events", `${date5}.jsonl`);
+  if (!existsSync6(filePath))
     return null;
   const stream = createReadStream3(filePath, { encoding: "utf-8" });
   const rl = createInterface2({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
@@ -53383,6 +54456,7 @@ function escapeCsvValue(value) {
   return text2;
 }
 function toCsvRow(item) {
+  const usage = item.tokenUsage;
   return [
     item.id,
     item.ts,
@@ -53403,7 +54477,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) {
@@ -53428,7 +54531,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) {
@@ -53506,12 +54638,666 @@ function parseBooleanFlag(value) {
   throw new Error("hasError \u53C2\u6570\u4EC5\u652F\u6301 true/false/1/0");
 }
 
+// src/log-tail.ts
+var subscribers = new Set;
+function publishLogEvent(event) {
+  for (const subscriber of subscribers) {
+    try {
+      subscriber(event);
+    } catch {}
+  }
+}
+function subscribeLogEvents(subscriber) {
+  subscribers.add(subscriber);
+  return () => {
+    subscribers.delete(subscriber);
+  };
+}
+
+// src/network-access.ts
+var REMOTE_ADDRESS_ENV_KEY = "LOCAL_ROUTER_REMOTE_ADDRESS";
+function parseIpv4(address) {
+  const parts = address.split(".");
+  if (parts.length !== 4)
+    return null;
+  const octets = parts.map((part) => {
+    if (!/^\d{1,3}$/.test(part))
+      return Number.NaN;
+    const value = Number.parseInt(part, 10);
+    return value >= 0 && value <= 255 ? value : Number.NaN;
+  });
+  return octets.every(Number.isFinite) ? octets : null;
+}
+function normalizeIpAddress(raw2) {
+  let address = raw2.trim().toLowerCase();
+  if (address.startsWith("[")) {
+    const end = address.indexOf("]");
+    if (end !== -1)
+      address = address.slice(1, end);
+  }
+  const mappedIpv4 = address.match(/^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/);
+  if (mappedIpv4) {
+    return mappedIpv4[1];
+  }
+  return address;
+}
+function isLoopbackAddress(raw2) {
+  if (!raw2)
+    return false;
+  const address = normalizeIpAddress(raw2);
+  const ipv43 = parseIpv4(address);
+  if (ipv43)
+    return ipv43[0] === 127;
+  return address === "::1";
+}
+function isLanAddress(raw2) {
+  if (!raw2)
+    return false;
+  const address = normalizeIpAddress(raw2);
+  const ipv43 = parseIpv4(address);
+  if (ipv43) {
+    const [a, b] = ipv43;
+    return a === 10 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 169 && b === 254;
+  }
+  return address.startsWith("fc") || address.startsWith("fd") || /^fe[89ab]/.test(address);
+}
+function decideNetworkAccess(serverConfig, rawRemoteAddress) {
+  const remoteAddress = rawRemoteAddress ? normalizeIpAddress(rawRemoteAddress) : null;
+  if (!remoteAddress || isLoopbackAddress(remoteAddress)) {
+    return { allowed: true, remoteAddress };
+  }
+  const lanEnabled = serverConfig?.lanAccess?.enabled === true;
+  if (!lanEnabled) {
+    return { allowed: false, remoteAddress, reason: "lan-disabled" };
+  }
+  if (!isLanAddress(remoteAddress)) {
+    return { allowed: false, remoteAddress, reason: "non-lan-address" };
+  }
+  return { allowed: true, remoteAddress };
+}
+function getRemoteAddressFromContext(c2) {
+  const env = c2.env;
+  const value = env?.[REMOTE_ADDRESS_ENV_KEY];
+  return typeof value === "string" && value.trim() ? value : null;
+}
+function createNetworkAccessMiddleware(store) {
+  return async (c2, next) => {
+    const decision = decideNetworkAccess(store.get().server, getRemoteAddressFromContext(c2));
+    if (!decision.allowed) {
+      return c2.json({
+        error: decision.reason === "lan-disabled" ? "\u5C40\u57DF\u7F51\u670D\u52A1\u672A\u5F00\u542F\uFF0C\u5DF2\u62D2\u7EDD\u975E\u672C\u673A\u8BF7\u6C42" : "\u4EC5\u5141\u8BB8\u672C\u673A\u6216\u5C40\u57DF\u7F51\u6765\u6E90\u8BBF\u95EE",
+        remoteAddress: decision.remoteAddress
+      }, 403);
+    }
+    await next();
+  };
+}
+
+// src/log-realtime.ts
+var WS_PATHNAME = "/api/logs/events/ws";
+var MAX_CONNECTIONS = 64;
+var MAX_SUBSCRIPTIONS = 64;
+var MAX_CLIENT_MESSAGE_BYTES = 16 * 1024;
+var MAX_GLOBAL_EVENT_QUEUE_ITEMS = 1000;
+var MAX_GLOBAL_EVENT_QUEUE_BYTES = 16 * 1024 * 1024;
+var MAX_PENDING_BYTES_PER_CONNECTION = 1024 * 1024;
+var MAX_TOTAL_PENDING_BYTES = 32 * 1024 * 1024;
+var BACKPRESSURE_BUFFERED_BYTES = 512 * 1024;
+var HEARTBEAT_INTERVAL_MS = 15000;
+var FLUSH_BUDGET_MS = 10;
+var MAX_Q_LENGTH2 = 200;
+function jsonResponse(status, body) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json; charset=utf-8" }
+  });
+}
+function createId(prefix) {
+  return `${prefix}_${crypto.randomUUID()}`;
+}
+function estimatePublishedEventBytes(event) {
+  const bodyBytes = (event.event.request_bytes ?? 0) + (event.event.response_bytes ?? 0);
+  const streamBytes = event.event.stream_bytes ?? 0;
+  return 1024 + Math.min(64 * 1024, Math.max(0, bodyBytes + streamBytes));
+}
+function byteLength(text2) {
+  return Buffer.byteLength(text2);
+}
+function isSocketOpen(ws) {
+  return typeof ws.readyState !== "number" || ws.readyState === 1;
+}
+function bufferedAmount(ws) {
+  return typeof ws.bufferedAmount === "number" ? ws.bufferedAmount : 0;
+}
+function parseClientMessage(raw2) {
+  let text2;
+  if (typeof raw2 === "string") {
+    text2 = raw2;
+  } else {
+    text2 = new TextDecoder().decode(raw2);
+  }
+  if (byteLength(text2) > MAX_CLIENT_MESSAGE_BYTES) {
+    throw new Error("\u5BA2\u6237\u7AEF\u6D88\u606F\u8FC7\u5927");
+  }
+  const parsed = JSON.parse(text2);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("\u5BA2\u6237\u7AEF\u6D88\u606F\u5FC5\u987B\u662F JSON \u5BF9\u8C61");
+  }
+  const message = parsed;
+  if (message.type !== "subscribe" && message.type !== "unsubscribe" && message.type !== "ping") {
+    throw new Error("\u4E0D\u652F\u6301\u7684\u5B9E\u65F6\u65E5\u5FD7\u6D88\u606F\u7C7B\u578B");
+  }
+  return message;
+}
+function parseStringValue(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+function parseStringArrayValue(value) {
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => typeof item === "string" ? parseCommaSeparated(item) : []);
+  }
+  if (typeof value === "string")
+    return parseCommaSeparated(value);
+  return [];
+}
+function parseBooleanValue(value) {
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "string")
+    return parseBooleanFlag(value);
+  return null;
+}
+function createQueryHash(value) {
+  const text2 = JSON.stringify(value);
+  let hash2 = 2166136261;
+  for (let i = 0;i < text2.length; i += 1) {
+    hash2 ^= text2.charCodeAt(i);
+    hash2 = Math.imul(hash2, 16777619);
+  }
+  return `q_${(hash2 >>> 0).toString(36)}`;
+}
+function parseValidatedArray(value, validate, errorMessage) {
+  const raw2 = parseStringArrayValue(value);
+  const parsed = raw2.filter(validate);
+  if (parsed.length !== raw2.length) {
+    throw new Error(errorMessage);
+  }
+  return parsed;
+}
+function compileRealtimeQuery(input) {
+  const query = input ?? {};
+  const nowMs = Date.now();
+  const windowRaw = parseStringValue(query.window) ?? "24h";
+  if (!isLogQueryWindow(windowRaw)) {
+    throw new Error("window \u53C2\u6570\u4EC5\u652F\u6301 1h | 6h | 24h");
+  }
+  const from = parseStringValue(query.from);
+  const to = parseStringValue(query.to);
+  const range = from || to ? {
+    type: "fixed",
+    ...resolveLogQueryRange({ window: windowRaw, from, to, nowMs })
+  } : {
+    type: "window",
+    window: windowRaw,
+    windowMs: getLogQueryWindowMs(windowRaw)
+  };
+  if (range.type === "fixed" && range.toMs <= nowMs) {
+    throw new Error("\u56FA\u5B9A\u7ED3\u675F\u65F6\u95F4\u5DF2\u8FC7\u671F\uFF0C\u5B9E\u65F6\u63A8\u9001\u4EC5\u652F\u6301\u4ECD\u5728\u6EDA\u52A8\u7684\u67E5\u8BE2\u7A97\u53E3");
+  }
+  const sortRaw = parseStringValue(query.sort) ?? "time_desc";
+  if (!validateSort(sortRaw)) {
+    throw new Error("sort \u53C2\u6570\u4EC5\u652F\u6301 time_desc | time_asc");
+  }
+  const levels = parseValidatedArray(query.levels, validateLogLevel, "levels \u53C2\u6570\u4EC5\u652F\u6301 info,error");
+  const statusClasses = parseValidatedArray(query.statusClass, validateStatusClass, "statusClass \u53C2\u6570\u4EC5\u652F\u6301 2xx,4xx,5xx,network_error");
+  const q = (parseStringValue(query.q) ?? "").slice(0, MAX_Q_LENGTH2).toLowerCase();
+  const normalized = {
+    range,
+    sort: sortRaw,
+    levels,
+    providers: parseStringArrayValue(query.provider),
+    routeTypes: parseStringArrayValue(query.routeType),
+    models: parseStringArrayValue(query.model),
+    modelIns: parseStringArrayValue(query.modelIn),
+    modelOuts: parseStringArrayValue(query.modelOut),
+    users: parseStringArrayValue(query.user),
+    sessions: parseStringArrayValue(query.session),
+    statusClasses,
+    hasError: parseBooleanValue(query.hasError),
+    q
+  };
+  return {
+    queryHash: createQueryHash(normalized),
+    sort: sortRaw,
+    range,
+    levels: new Set(levels),
+    providers: new Set(normalized.providers),
+    routeTypes: new Set(normalized.routeTypes),
+    models: new Set(normalized.models),
+    modelIns: new Set(normalized.modelIns),
+    modelOuts: new Set(normalized.modelOuts),
+    users: new Set(normalized.users),
+    sessions: new Set(normalized.sessions),
+    statusClasses: new Set(statusClasses),
+    hasError: normalized.hasError,
+    q
+  };
+}
+function setHas(set2, value) {
+  return set2.size === 0 || set2.has(value);
+}
+function matchesCompiledQuery(query, facts, nowMs) {
+  if (!facts.event.ts_start || !Number.isFinite(facts.ts))
+    return false;
+  const fromMs = query.range.type === "window" ? nowMs - query.range.windowMs : query.range.fromMs;
+  const toMs = query.range.type === "window" ? nowMs : query.range.toMs;
+  if (facts.ts < fromMs || facts.ts > toMs)
+    return false;
+  if (!setHas(query.levels, facts.level))
+    return false;
+  if (!setHas(query.providers, facts.event.provider))
+    return false;
+  if (!setHas(query.routeTypes, facts.event.route_type))
+    return false;
+  if (!setHas(query.models, facts.model))
+    return false;
+  if (!setHas(query.modelIns, facts.event.model_in))
+    return false;
+  if (!setHas(query.modelOuts, facts.event.model_out))
+    return false;
+  if (query.users.size > 0) {
+    const matchedByRaw = facts.identity.userIdRaw ? query.users.has(facts.identity.userIdRaw) : false;
+    const matchedByUserKey = facts.identity.userKey ? query.users.has(facts.identity.userKey) : false;
+    if (!matchedByRaw && !matchedByUserKey)
+      return false;
+  }
+  if (query.sessions.size > 0) {
+    if (!facts.identity.sessionId || !query.sessions.has(facts.identity.sessionId))
+      return false;
+  }
+  if (!setHas(query.statusClasses, facts.statusClass))
+    return false;
+  if (query.hasError !== null && query.hasError !== facts.hasError)
+    return false;
+  return !query.q || facts.keywordText.includes(query.q);
+}
+function createLogRealtimeRuntime(options) {
+  const connections = new Map;
+  const subscriptions = new Map;
+  const eventQueue = [];
+  let tailUnsubscribe = null;
+  let flushTimer = null;
+  let heartbeatTimer = null;
+  let eventQueueBytes = 0;
+  let totalPendingBytes = 0;
+  let droppedUpstreamEvents = 0;
+  const sendText = (connection, text2) => {
+    if (!isSocketOpen(connection.ws))
+      return false;
+    const bytes = byteLength(text2);
+    const shouldQueue = connection.queue.length > 0 || bufferedAmount(connection.ws) > BACKPRESSURE_BUFFERED_BYTES;
+    if (!shouldQueue) {
+      try {
+        connection.ws.send(text2);
+        return true;
+      } catch {
+        removeConnection(connection.id, "send-failed");
+        return false;
+      }
+    }
+    if (connection.pendingBytes + bytes > MAX_PENDING_BYTES_PER_CONNECTION || totalPendingBytes + bytes > MAX_TOTAL_PENDING_BYTES) {
+      connection.droppedOutbound += 1;
+      if (connection.droppedOutbound >= 3) {
+        removeConnection(connection.id, "slow-client");
+      }
+      return false;
+    }
+    connection.queue.push({ text: text2, bytes });
+    connection.pendingBytes += bytes;
+    totalPendingBytes += bytes;
+    return true;
+  };
+  const sendMessage = (connection, message) => {
+    return sendText(connection, JSON.stringify(message));
+  };
+  const flushConnectionQueue = (connection) => {
+    if (!isSocketOpen(connection.ws))
+      return;
+    while (connection.queue.length > 0 && bufferedAmount(connection.ws) <= BACKPRESSURE_BUFFERED_BYTES) {
+      const item = connection.queue.shift();
+      if (!item)
+        break;
+      connection.pendingBytes -= item.bytes;
+      totalPendingBytes -= item.bytes;
+      try {
+        connection.ws.send(item.text);
+      } catch {
+        removeConnection(connection.id, "send-failed");
+        return;
+      }
+    }
+  };
+  const sendError = (connection, error48, requestId) => {
+    sendMessage(connection, { type: "error", requestId, error: error48 });
+  };
+  const ensureTailSubscription = () => {
+    if (tailUnsubscribe || subscriptions.size === 0)
+      return;
+    tailUnsubscribe = subscribeLogEvents((event) => {
+      if (subscriptions.size === 0)
+        return;
+      const bytes = estimatePublishedEventBytes(event);
+      while (eventQueue.length >= MAX_GLOBAL_EVENT_QUEUE_ITEMS || eventQueueBytes + bytes > MAX_GLOBAL_EVENT_QUEUE_BYTES) {
+        const dropped = eventQueue.shift();
+        if (!dropped)
+          break;
+        eventQueueBytes -= dropped.bytes;
+        droppedUpstreamEvents += 1;
+      }
+      eventQueue.push({ event, bytes });
+      eventQueueBytes += bytes;
+      scheduleFlush();
+    });
+  };
+  const maybeStopTailSubscription = () => {
+    if (subscriptions.size > 0)
+      return;
+    tailUnsubscribe?.();
+    tailUnsubscribe = null;
+    eventQueue.length = 0;
+    eventQueueBytes = 0;
+    droppedUpstreamEvents = 0;
+  };
+  const sendOverflow = (subscription, dropped, message) => {
+    const connection = connections.get(subscription.connectionId);
+    if (!connection)
+      return;
+    sendMessage(connection, {
+      type: "overflow",
+      subscriptionId: subscription.id,
+      dropped,
+      message
+    });
+  };
+  const removeSubscription = (subscriptionId, reason, notify2 = true) => {
+    const subscription = subscriptions.get(subscriptionId);
+    if (!subscription)
+      return;
+    subscriptions.delete(subscriptionId);
+    const connection = connections.get(subscription.connectionId);
+    if (connection) {
+      connection.subscriptions.delete(subscriptionId);
+      if (notify2) {
+        sendMessage(connection, {
+          type: "unsubscribed",
+          subscriptionId,
+          reason
+        });
+      }
+    }
+    maybeStopTailSubscription();
+  };
+  function removeConnection(connectionId, reason) {
+    const connection = connections.get(connectionId);
+    if (!connection)
+      return;
+    connections.delete(connectionId);
+    for (const subscriptionId of Array.from(connection.subscriptions)) {
+      removeSubscription(subscriptionId, reason, false);
+    }
+    for (const item of connection.queue) {
+      totalPendingBytes -= item.bytes;
+    }
+    connection.queue.length = 0;
+    connection.pendingBytes = 0;
+    try {
+      connection.ws.close(1001, reason);
+    } catch {}
+    if (connections.size === 0 && heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+    maybeStopTailSubscription();
+  }
+  const pruneExpiredSubscriptions = (nowMs) => {
+    for (const subscription of Array.from(subscriptions.values())) {
+      const range = subscription.query.range;
+      if (range.type === "fixed" && range.toMs <= nowMs) {
+        removeSubscription(subscription.id, "expired");
+      }
+    }
+  };
+  const flushEvents = () => {
+    flushTimer = null;
+    if (subscriptions.size === 0) {
+      eventQueue.length = 0;
+      eventQueueBytes = 0;
+      droppedUpstreamEvents = 0;
+      maybeStopTailSubscription();
+      return;
+    }
+    const startedAt = Date.now();
+    const nowMs = Date.now();
+    pruneExpiredSubscriptions(nowMs);
+    if (droppedUpstreamEvents > 0) {
+      const dropped = droppedUpstreamEvents;
+      droppedUpstreamEvents = 0;
+      for (const subscription of subscriptions.values()) {
+        sendOverflow(subscription, dropped, `\u5B9E\u65F6\u65E5\u5FD7\u961F\u5217\u5DF2\u4E22\u5F03 ${dropped} \u6761\u4E8B\u4EF6\uFF0C\u8BF7\u91CD\u65B0\u67E5\u8BE2\u4EE5\u8865\u9F50\u3002`);
+      }
+    }
+    while (eventQueue.length > 0 && Date.now() - startedAt < FLUSH_BUDGET_MS) {
+      const queued = eventQueue.shift();
+      if (!queued)
+        break;
+      eventQueueBytes -= queued.bytes;
+      const facts = extractLogEventFacts(queued.event.event);
+      let summary = null;
+      for (const subscription of subscriptions.values()) {
+        if (!matchesCompiledQuery(subscription.query, facts, Date.now()))
+          continue;
+        const connection = connections.get(subscription.connectionId);
+        if (!connection)
+          continue;
+        summary ??= createLogEventSummaryFromFacts(facts, {
+          id: queued.event.id,
+          date: queued.event.date,
+          line: null
+        });
+        const sent = sendMessage(connection, {
+          type: "log.event",
+          subscriptionId: subscription.id,
+          item: summary
+        });
+        if (!sent) {
+          sendOverflow(subscription, 1, "\u5B9E\u65F6\u65E5\u5FD7\u5BA2\u6237\u7AEF\u53D1\u9001\u961F\u5217\u5DF2\u6EE1\uFF0C\u8BF7\u91CD\u65B0\u67E5\u8BE2\u4EE5\u8865\u9F50\u3002");
+        }
+      }
+    }
+    for (const connection of connections.values()) {
+      flushConnectionQueue(connection);
+    }
+    if (eventQueue.length > 0)
+      scheduleFlush();
+  };
+  function scheduleFlush() {
+    if (flushTimer)
+      return;
+    flushTimer = setTimeout(flushEvents, 0);
+    flushTimer.unref?.();
+  }
+  const ensureHeartbeat = () => {
+    if (heartbeatTimer)
+      return;
+    heartbeatTimer = setInterval(() => {
+      const ts = new Date().toISOString();
+      pruneExpiredSubscriptions(Date.now());
+      for (const connection of connections.values()) {
+        sendMessage(connection, { type: "pong", ts });
+        flushConnectionQueue(connection);
+      }
+    }, HEARTBEAT_INTERVAL_MS);
+    heartbeatTimer.unref?.();
+  };
+  const subscribeConnection = (connection, requestId, query) => {
+    if (subscriptions.size >= MAX_SUBSCRIPTIONS && connection.subscriptions.size === 0) {
+      sendError(connection, "\u5B9E\u65F6\u65E5\u5FD7\u8BA2\u9605\u6570\u5DF2\u8FBE\u4E0A\u9650\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", requestId);
+      return;
+    }
+    let compiled;
+    try {
+      compiled = compileRealtimeQuery(query);
+    } catch (err) {
+      sendError(connection, err instanceof Error ? err.message : String(err), requestId);
+      return;
+    }
+    for (const subscriptionId2 of Array.from(connection.subscriptions)) {
+      removeSubscription(subscriptionId2, "replaced");
+    }
+    const subscriptionId = createId("sub");
+    const subscription = {
+      id: subscriptionId,
+      connectionId: connection.id,
+      query: compiled
+    };
+    subscriptions.set(subscriptionId, subscription);
+    connection.subscriptions.add(subscriptionId);
+    ensureTailSubscription();
+    sendMessage(connection, {
+      type: "subscribed",
+      requestId: requestId ?? null,
+      subscriptionId,
+      queryHash: compiled.queryHash,
+      now: new Date().toISOString()
+    });
+  };
+  const openConnection = (ws) => {
+    const data = ws.data;
+    const connection = {
+      id: data.connectionId,
+      remoteAddress: data.remoteAddress,
+      ws,
+      subscriptions: new Set,
+      queue: [],
+      pendingBytes: 0,
+      droppedOutbound: 0
+    };
+    connections.set(connection.id, connection);
+    ensureHeartbeat();
+    sendMessage(connection, {
+      type: "ready",
+      connectionId: connection.id,
+      now: new Date().toISOString()
+    });
+  };
+  const handleMessage = (ws, raw2) => {
+    const connection = connections.get(ws.data.connectionId);
+    if (!connection)
+      return;
+    let message;
+    try {
+      message = parseClientMessage(raw2);
+    } catch (err) {
+      sendError(connection, err instanceof Error ? err.message : String(err));
+      return;
+    }
+    if (message.type === "ping") {
+      sendMessage(connection, { type: "pong", ts: message.ts ?? new Date().toISOString() });
+      return;
+    }
+    if (message.type === "unsubscribe") {
+      if (message.subscriptionId) {
+        removeSubscription(message.subscriptionId, "client-unsubscribe");
+      } else {
+        for (const subscriptionId of Array.from(connection.subscriptions)) {
+          removeSubscription(subscriptionId, "client-unsubscribe");
+        }
+      }
+      return;
+    }
+    subscribeConnection(connection, message.requestId, message.query);
+  };
+  return {
+    pathname: WS_PATHNAME,
+    upgrade: (request, server, remoteAddress) => {
+      const url2 = new URL(request.url);
+      if (url2.pathname !== WS_PATHNAME)
+        return { handled: false };
+      const upgradeHeader = request.headers.get("upgrade")?.toLowerCase();
+      if (upgradeHeader !== "websocket") {
+        return {
+          handled: true,
+          response: jsonResponse(400, { error: "\u9700\u8981 WebSocket Upgrade" })
+        };
+      }
+      const decision = decideNetworkAccess(options.store.get().server, remoteAddress);
+      if (!decision.allowed) {
+        return {
+          handled: true,
+          response: jsonResponse(403, {
+            error: decision.reason === "lan-disabled" ? "\u5C40\u57DF\u7F51\u670D\u52A1\u672A\u5F00\u542F\uFF0C\u5DF2\u62D2\u7EDD\u975E\u672C\u673A\u8BF7\u6C42" : "\u4EC5\u5141\u8BB8\u672C\u673A\u6216\u5C40\u57DF\u7F51\u6765\u6E90\u8BBF\u95EE",
+            remoteAddress: decision.remoteAddress
+          })
+        };
+      }
+      if (connections.size >= MAX_CONNECTIONS) {
+        return {
+          handled: true,
+          response: jsonResponse(503, { error: "\u5B9E\u65F6\u65E5\u5FD7\u8FDE\u63A5\u6570\u5DF2\u8FBE\u4E0A\u9650\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5" })
+        };
+      }
+      const upgraded = server.upgrade(request, {
+        data: {
+          kind: "log-realtime",
+          connectionId: createId("conn"),
+          remoteAddress: decision.remoteAddress
+        }
+      });
+      return upgraded ? { handled: true, upgraded: true } : { handled: true, response: jsonResponse(400, { error: "WebSocket Upgrade \u5931\u8D25" }) };
+    },
+    websocket: {
+      open: openConnection,
+      message: handleMessage,
+      drain: (ws) => {
+        const connection = connections.get(ws.data.connectionId);
+        if (connection)
+          flushConnectionQueue(connection);
+      },
+      close: (ws) => {
+        removeConnection(ws.data.connectionId, "closed");
+      }
+    },
+    dispose: () => {
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+      }
+      tailUnsubscribe?.();
+      tailUnsubscribe = null;
+      for (const connectionId of Array.from(connections.keys())) {
+        removeConnection(connectionId, "server-dispose");
+      }
+      eventQueue.length = 0;
+      eventQueueBytes = 0;
+      totalPendingBytes = 0;
+      droppedUpstreamEvents = 0;
+    }
+  };
+}
+
 // src/log-sessions.ts
-import { createReadStream as createReadStream4, existsSync as existsSync5 } from "fs";
-import { join as join6 } from "path";
+import { createReadStream as createReadStream4, existsSync as existsSync7 } from "fs";
+import { join as join8 } from "path";
 import { createInterface as createInterface3 } from "readline";
 var MAX_LINES_SCANNED3 = 250000;
-var MAX_Q_LENGTH2 = 200;
+var MAX_Q_LENGTH3 = 200;
 function toDayStart4(ms) {
   const date5 = new Date(ms);
   return Date.UTC(date5.getUTCFullYear(), date5.getUTCMonth(), date5.getUTCDate());
@@ -53530,7 +55316,7 @@ function normalizeInput(input) {
     toMs: input.toMs,
     users: (input.users ?? []).map((item) => item.trim()).filter(Boolean),
     sessions: (input.sessions ?? []).map((item) => item.trim()).filter(Boolean),
-    q: qRaw.length > MAX_Q_LENGTH2 ? qRaw.slice(0, MAX_Q_LENGTH2) : qRaw
+    q: qRaw.length > MAX_Q_LENGTH3 ? qRaw.slice(0, MAX_Q_LENGTH3) : qRaw
   };
 }
 function incrementCount(map2, key2) {
@@ -53629,8 +55415,8 @@ async function queryLogSessions(context2, input) {
     return createEmptyResult(normalized.fromMs, normalized.toMs);
   }
   const baseDir = resolveLogBaseDir(context2.logConfig);
-  const eventsDir = join6(baseDir, "events");
-  if (!existsSync5(eventsDir)) {
+  const eventsDir = join8(baseDir, "events");
+  if (!existsSync7(eventsDir)) {
     return createEmptyResult(normalized.fromMs, normalized.toMs);
   }
   const usersMap = new Map;
@@ -53648,8 +55434,8 @@ async function queryLogSessions(context2, input) {
       truncated = true;
       break;
     }
-    const filePath = join6(eventsDir, `${date5}.jsonl`);
-    if (!existsSync5(filePath))
+    const filePath = join8(eventsDir, `${date5}.jsonl`);
+    if (!existsSync7(filePath))
       continue;
     scannedFiles += 1;
     const stream = createReadStream4(filePath, { encoding: "utf-8" });
@@ -53757,8 +55543,8 @@ async function queryLogSessions(context2, input) {
 }
 
 // src/log-storage.ts
-import { existsSync as existsSync6, promises as fsPromises } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync8, promises as fsPromises } from "fs";
+import { join as join9 } from "path";
 var cachedStorage = null;
 var calculationPromise = null;
 var lastCalculationTime = 0;
@@ -53766,7 +55552,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 (!existsSync8(dirPath)) {
     return { bytes: 0, fileCount: 0 };
   }
   let bytes = 0;
@@ -53775,7 +55561,7 @@ async function calculateDirSize(dirPath) {
     try {
       const entries = await fsPromises.readdir(currentPath, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join7(currentPath, entry.name);
+        const fullPath = join9(currentPath, entry.name);
         if (entry.isDirectory()) {
           await walk(fullPath);
         } else if (entry.isFile()) {
@@ -53806,8 +55592,8 @@ async function doCalculateStorage(logConfig) {
   }
   const baseDir = resolveLogBaseDir(logConfig);
   const [eventsResult, streamsResult] = await Promise.all([
-    calculateDirSize(join7(baseDir, "events")),
-    calculateDirSize(join7(baseDir, "streams"))
+    calculateDirSize(join9(baseDir, "events")),
+    calculateDirSize(join9(baseDir, "streams"))
   ]);
   const indexResult = await calculateIndexSize(baseDir);
   return {
@@ -53821,7 +55607,7 @@ async function doCalculateStorage(logConfig) {
   };
 }
 async function calculateIndexSize(baseDir) {
-  if (!existsSync6(baseDir)) {
+  if (!existsSync8(baseDir)) {
     return { bytes: 0, fileCount: 0 };
   }
   let bytes = 0;
@@ -53831,7 +55617,7 @@ async function calculateIndexSize(baseDir) {
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.startsWith("logs-index.sqlite"))
         continue;
-      const stats = await fsPromises.stat(join7(baseDir, entry.name));
+      const stats = await fsPromises.stat(join9(baseDir, entry.name));
       bytes += stats.size;
       fileCount += 1;
     }
@@ -53882,33 +55668,17 @@ function startLogStorageBackgroundTask(logConfig) {
   };
 }
 
-// src/log-tail.ts
-var subscribers = new Set;
-function publishLogEvent(event) {
-  for (const subscriber of subscribers) {
-    try {
-      subscriber(event);
-    } catch {}
-  }
-}
-function subscribeLogEvents(subscriber) {
-  subscribers.add(subscriber);
-  return () => {
-    subscribers.delete(subscriber);
-  };
-}
-
 // src/logger.ts
 import {
   appendFileSync,
   closeSync as closeSync2,
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync3,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync4,
   openSync as openSync2,
-  statSync as statSync2,
+  statSync as statSync3,
   writeSync
 } from "fs";
-import { join as join8 } from "path";
+import { join as join10 } from "path";
 class Logger {
   baseDir;
   eventsDir;
@@ -53923,8 +55693,8 @@ class Logger {
     this._bodyPolicy = config2.bodyPolicy ?? "off";
     this._streamsEnabled = config2.streams?.enabled !== false;
     this.maxStreamBytes = config2.streams?.maxBytesPerRequest ?? 10 * 1024 * 1024;
-    this.eventsDir = join8(baseDir, "events");
-    this.streamsDir = join8(baseDir, "streams");
+    this.eventsDir = join10(baseDir, "events");
+    this.streamsDir = join10(baseDir, "streams");
     if (this._enabled)
       this.ensureDirs();
   }
@@ -53936,25 +55706,26 @@ class Logger {
   }
   ensureDirs() {
     for (const dir of [this.baseDir, this.eventsDir, this.streamsDir]) {
-      if (!existsSync7(dir))
-        mkdirSync3(dir, { recursive: true });
+      if (!existsSync9(dir))
+        mkdirSync4(dir, { recursive: true });
     }
   }
   ensureStreamDateDir(dateStr) {
-    const dir = join8(this.streamsDir, dateStr);
-    if (!existsSync7(dir))
-      mkdirSync3(dir, { recursive: true });
+    const dir = join10(this.streamsDir, dateStr);
+    if (!existsSync9(dir))
+      mkdirSync4(dir, { recursive: true });
     return dir;
   }
   writeEvent(event) {
     if (!this._enabled)
       return;
     try {
+      const enrichedEvent = enrichLogEventTokenUsage(event, { baseDir: this.baseDir });
       this.ensureDirs();
-      const dateStr = event.ts_start.slice(0, 10);
-      const filePath = join8(this.eventsDir, `${dateStr}.jsonl`);
-      const offset = existsSync7(filePath) ? statSync2(filePath).size : 0;
-      const line2 = `${JSON.stringify(event)}
+      const dateStr = enrichedEvent.ts_start.slice(0, 10);
+      const filePath = join10(this.eventsDir, `${dateStr}.jsonl`);
+      const offset = existsSync9(filePath) ? statSync3(filePath).size : 0;
+      const line2 = `${JSON.stringify(enrichedEvent)}
 `;
       appendFileSync(filePath, line2);
       const id = encodeOffsetLogEventId(dateStr, offset);
@@ -53964,9 +55735,9 @@ 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);
     }
@@ -53982,7 +55753,7 @@ class Logger {
     let fd;
     try {
       const dir = this.ensureStreamDateDir(dateStr);
-      filePath = join8(dir, `${requestId}.sse.raw`);
+      filePath = join10(dir, `${requestId}.sse.raw`);
       fd = openSync2(filePath, "a");
     } catch (err) {
       console.error("[logger] \u6D41\u5F0F\u65E5\u5FD7\u6253\u5F00\u5931\u8D25:", err);
@@ -54072,85 +55843,6 @@ function normalizeUrl(rawUrl) {
   return rawUrl;
 }
 
-// src/network-access.ts
-var REMOTE_ADDRESS_ENV_KEY = "LOCAL_ROUTER_REMOTE_ADDRESS";
-function parseIpv4(address) {
-  const parts = address.split(".");
-  if (parts.length !== 4)
-    return null;
-  const octets = parts.map((part) => {
-    if (!/^\d{1,3}$/.test(part))
-      return Number.NaN;
-    const value = Number.parseInt(part, 10);
-    return value >= 0 && value <= 255 ? value : Number.NaN;
-  });
-  return octets.every(Number.isFinite) ? octets : null;
-}
-function normalizeIpAddress(raw2) {
-  let address = raw2.trim().toLowerCase();
-  if (address.startsWith("[")) {
-    const end = address.indexOf("]");
-    if (end !== -1)
-      address = address.slice(1, end);
-  }
-  const mappedIpv4 = address.match(/^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/);
-  if (mappedIpv4) {
-    return mappedIpv4[1];
-  }
-  return address;
-}
-function isLoopbackAddress(raw2) {
-  if (!raw2)
-    return false;
-  const address = normalizeIpAddress(raw2);
-  const ipv43 = parseIpv4(address);
-  if (ipv43)
-    return ipv43[0] === 127;
-  return address === "::1";
-}
-function isLanAddress(raw2) {
-  if (!raw2)
-    return false;
-  const address = normalizeIpAddress(raw2);
-  const ipv43 = parseIpv4(address);
-  if (ipv43) {
-    const [a, b] = ipv43;
-    return a === 10 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 169 && b === 254;
-  }
-  return address.startsWith("fc") || address.startsWith("fd") || /^fe[89ab]/.test(address);
-}
-function decideNetworkAccess(serverConfig, rawRemoteAddress) {
-  const remoteAddress = rawRemoteAddress ? normalizeIpAddress(rawRemoteAddress) : null;
-  if (!remoteAddress || isLoopbackAddress(remoteAddress)) {
-    return { allowed: true, remoteAddress };
-  }
-  const lanEnabled = serverConfig?.lanAccess?.enabled === true;
-  if (!lanEnabled) {
-    return { allowed: false, remoteAddress, reason: "lan-disabled" };
-  }
-  if (!isLanAddress(remoteAddress)) {
-    return { allowed: false, remoteAddress, reason: "non-lan-address" };
-  }
-  return { allowed: true, remoteAddress };
-}
-function getRemoteAddressFromContext(c2) {
-  const env = c2.env;
-  const value = env?.[REMOTE_ADDRESS_ENV_KEY];
-  return typeof value === "string" && value.trim() ? value : null;
-}
-function createNetworkAccessMiddleware(store) {
-  return async (c2, next) => {
-    const decision = decideNetworkAccess(store.get().server, getRemoteAddressFromContext(c2));
-    if (!decision.allowed) {
-      return c2.json({
-        error: decision.reason === "lan-disabled" ? "\u5C40\u57DF\u7F51\u670D\u52A1\u672A\u5F00\u542F\uFF0C\u5DF2\u62D2\u7EDD\u975E\u672C\u673A\u8BF7\u6C42" : "\u4EC5\u5141\u8BB8\u672C\u673A\u6216\u5C40\u57DF\u7F51\u6765\u6E90\u8BBF\u95EE",
-        remoteAddress: decision.remoteAddress
-      }, 403);
-    }
-    await next();
-  };
-}
-
 // src/openapi.ts
 var openAPISpec = {
   openapi: "3.0.0",
@@ -55257,7 +56949,7 @@ var openAPISpec = {
 // src/plugin-loader.ts
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join9, resolve as resolve5 } from "path";
+import { join as join11, resolve as resolve7 } from "path";
 function isLocalPath(pkg) {
   return pkg.startsWith("./") || pkg.startsWith("../") || pkg.startsWith("/") || /^[A-Za-z]:[\\/]/.test(pkg);
 }
@@ -55280,7 +56972,7 @@ var remoteTmpDir = null;
 var remoteTmpFiles = [];
 async function ensureRemoteTmpDir() {
   if (!remoteTmpDir) {
-    remoteTmpDir = await mkdtemp(join9(tmpdir(), "local-router-plugins-"));
+    remoteTmpDir = await mkdtemp(join11(tmpdir(), "local-router-plugins-"));
   }
   return remoteTmpDir;
 }
@@ -55293,7 +56985,7 @@ async function fetchRemotePlugin(url2) {
   const ext = inferExtension(url2, response.headers.get("content-type"));
   const dir = await ensureRemoteTmpDir();
   const fileName = `plugin_${Date.now()}_${Math.random().toString(36).slice(2, 8)}${ext}`;
-  const filePath = join9(dir, fileName);
+  const filePath = join11(dir, fileName);
   await writeFile(filePath, content, "utf-8");
   remoteTmpFiles.push(filePath);
   return filePath;
@@ -55313,7 +57005,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 = resolve7(configDir, pkg);
     modulePath = `${absolutePath}?t=${Date.now()}`;
   } else {
     modulePath = pkg;
@@ -55706,6 +57398,7 @@ async function proxyRequest(c2, options) {
       });
     }
     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 = () => {
@@ -55717,6 +57410,7 @@ async function proxyRequest(c2, options) {
         truncated: false,
         filePath: null
       };
+      const tokenUsage2 = tokenUsageCollector.getUsage();
       logger?.writeEvent(buildLogEvent(logMeta, targetUrl, proxy, Date.now(), {
         upstream_status: sseStatus,
         content_type_res: contentTypeRes,
@@ -55728,6 +57422,7 @@ async function proxyRequest(c2, options) {
           stream_file_bytes: captureResult.bytesWritten
         },
         ...captureResult.truncated && { stream_file_truncated: true },
+        ...tokenUsage2 && { token_usage: tokenUsage2 },
         ...requestBody !== undefined && { request_body: requestBody },
         ...pluginLogOverrides
       }));
@@ -55743,6 +57438,7 @@ async function proxyRequest(c2, options) {
             return;
           }
           upstreamBytes += value.byteLength;
+          tokenUsageCollector.addChunk(value);
           capture?.write(value);
           controller.enqueue(value);
         } catch (err) {
@@ -55793,12 +57489,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) {
@@ -56081,7 +57779,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(readFileSync4(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) {
@@ -56221,6 +57919,45 @@ function createAdminApiRoutes(store, pluginManager, registerCleanup) {
       return c2.json({ error: `\u8BFB\u53D6\u914D\u7F6E schema \u5931\u8D25: ${err instanceof Error ? err.message : err}` }, 500);
     }
   });
+  api2.get("/autostart", async (c2) => {
+    try {
+      const manager = createAutostartManager();
+      const systemInstalled = await manager.isInstalled();
+      const config2 = store.get();
+      return c2.json({
+        enabled: config2.server?.autostart ?? false,
+        systemInstalled,
+        platform: manager.platform,
+        servicePath: manager.getServicePath()
+      });
+    } catch (err) {
+      return c2.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  api2.put("/autostart", async (c2) => {
+    try {
+      const { enabled } = await c2.req.json();
+      if (typeof enabled !== "boolean") {
+        return c2.json({ error: "enabled \u5FC5\u987B\u662F\u5E03\u5C14\u503C" }, 400);
+      }
+      const manager = createAutostartManager();
+      if (manager.platform === "unsupported") {
+        return c2.json({ error: "\u5F53\u524D\u5E73\u53F0\u4E0D\u652F\u6301\u81EA\u542F\u52A8" }, 400);
+      }
+      if (enabled) {
+        const { execPath, args } = getAutostartExecArgs();
+        await manager.install({ execPath, args, label: "com.lakphy.local-router" });
+      } else {
+        await manager.uninstall();
+      }
+      const config2 = store.get();
+      const updated = { ...config2, server: { ...config2.server, autostart: enabled } };
+      store.save(updated);
+      return c2.json({ ok: true, enabled });
+    } catch (err) {
+      return c2.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
   api2.post("/chat/proxy", async (c2) => {
     let body;
     try {
@@ -56686,7 +58423,7 @@ async function createApp(store, options) {
   }
   const stopLogStorageTask = startLogStorageBackgroundTask(config2.log);
   options?.registerCleanup?.(stopLogStorageTask);
-  const configDir = dirname2(resolve6(store.getPath()));
+  const configDir = dirname3(resolve8(store.getPath()));
   const pluginManager = new PluginManager(configDir);
   const reloadResult = await pluginManager.reloadAll(config2.providers);
   if (!reloadResult.ok) {
@@ -56733,28 +58470,56 @@ async function createApp(store, options) {
   }
   return app;
 }
-async function createDefaultAppFromProcessArgs() {
-  const configPath = parseConfigPath();
+async function createAppRuntimeFromConfigPath(configPath, listen) {
   const store = new ConfigStore(configPath);
-  return createApp(store, {
-    listen: {
-      host: process.env.HOST ?? "0.0.0.0",
-      port: Number.parseInt(process.env.PORT ?? "4099", 10)
+  const cleanups = [];
+  const app = await createApp(store, {
+    listen,
+    registerCleanup: (cleanup) => {
+      cleanups.push(cleanup);
     }
   });
+  const logRealtime = createLogRealtimeRuntime({ store });
+  return {
+    app,
+    logRealtime,
+    dispose: () => {
+      logRealtime.dispose();
+      for (const cleanup of cleanups.reverse()) {
+        try {
+          cleanup();
+        } catch {}
+      }
+    }
+  };
+}
+async function createDefaultAppRuntimeFromProcessArgs() {
+  const configPath = parseConfigPath();
+  return createAppRuntimeFromConfigPath(configPath, {
+    host: process.env.HOST ?? "0.0.0.0",
+    port: Number.parseInt(process.env.PORT ?? "4099", 10)
+  });
 }
 
 // src/entry.ts
-var app = await createDefaultAppFromProcessArgs();
+var runtime = await createDefaultAppRuntimeFromProcessArgs();
 var entry_default = {
   hostname: process.env.HOST ?? "0.0.0.0",
   port: Number.parseInt(process.env.PORT ?? "4099", 10),
   fetch(request, server) {
     const remoteAddress = server.requestIP(request)?.address ?? null;
-    return app.fetch(request, {
+    const realtimeUpgrade = runtime.logRealtime.upgrade(request, server, remoteAddress);
+    if (realtimeUpgrade.handled) {
+      if (realtimeUpgrade.upgraded) {
+        return;
+      }
+      return realtimeUpgrade.response ?? new Response("WebSocket Upgrade failed", { status: 400 });
+    }
+    return runtime.app.fetch(request, {
       [REMOTE_ADDRESS_ENV_KEY]: remoteAddress
     });
-  }
+  },
+  websocket: runtime.logRealtime.websocket
 };
 export {
   entry_default as default