opencode-tokenwatch 0.2.0 → 0.3.0

package/dist/i18n.js

@@ -40,8 +40,6 @@ const zh = {
     toolCall: "Tool调用",
     toolResult: "Tool结果",
     outputTokens: "输出",
-    settings: "Settings",
-    showCache: "显示缓存统计",
     showPerformance: "显示性能指标",
     showPricing: "显示模型定价",
     showTokenDistribution: "显示Token分布",
@@ -114,8 +112,6 @@ const en = {
     toolCall: "Tool Call",
     toolResult: "Tool Result",
     outputTokens: "Output",
-    settings: "Settings",
-    showCache: "Show Cache",
     showPerformance: "Show Performance",
     showPricing: "Show Pricing",
     showTokenDistribution: "Show Token Distribution",

package/dist/perf-tracker.d.ts

@@ -41,11 +41,16 @@ interface MessageRemoveEvent {
 declare class PerfTracker {
     private firstPartTimes;
     private statsMap;
+    /** 原始样本串，用于分位数计算，不持久化 */
+    private ttftSamples;
+    private latencySamples;
     handlePartUpdated(event: PartEvent): void;
     handleMessageUpdated(event: MessageUpdateEvent): void;
     private appendLog;
     handleMessageRemoved(event: MessageRemoveEvent): void;
     private updateStats;
+    /** 计算有序数组的指定百分位数（线性插值法） */
+    private percentile;
     getSessionStats(): SessionPerfStats;
     readLogs(last?: number): LogEntry[];
     reset(): void;

package/dist/perf-tracker.js

@@ -1,16 +1,22 @@
-import { appendFileSync } from "node:fs";
-import { readFileSync } from "node:fs";
+import { appendFileSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 const LOG_PATH = join(homedir(), ".opencode", "tokenwatch.jsonl");
 class PerfTracker {
     firstPartTimes = new Map();
     statsMap = new Map();
+    /** 原始样本串，用于分位数计算，不持久化 */
+    ttftSamples = new Map();
+    latencySamples = new Map();
     handlePartUpdated(event) {
         if (!event.time?.start || !event.message_id)
             return;
-        this.firstPartTimes.set(event.message_id, event.time.start);
+        // Bug fix: 取最早 part 时间而非最后一个，避免 TTFT 被高估
+        const cur = this.firstPartTimes.get(event.message_id) ?? Number.POSITIVE_INFINITY;
+        if (event.time.start < cur) {
+            this.firstPartTimes.set(event.message_id, event.time.start);
+        }
     }
     handleMessageUpdated(event) {
         const info = event.properties?.info;
@@ -43,9 +49,9 @@ class PerfTracker {
         const tps = (genMs !== null && genMs > 0 && outputTokens > 0)
             ? (outputTokens / genMs) * 1000
             : null;
-        const tpsFallback = (tps === null && latencyMs > 0 && outputTokens > 0)
-            ? (outputTokens / latencyMs) * 1000
-            : null;
+        // Bug fix: 移除 TPS fallback。
+        // 原 fallback 用 latencyMs（completed-created，含排队+TTFT）计算 TPS，
+        // 会使结果严重低估（约 40%+）。null 表示"无可靠数据"比虚假数字更好。
         this.firstPartTimes.delete(messageID);
         const entry = {
             ts: new Date().toISOString(),
@@ -54,7 +60,7 @@ class PerfTracker {
             modelID,
             sessionID,
             ttft_ms: ttftMs,
-            tps: tps ?? tpsFallback,
+            tps: tps, // 只在有可靠 genMs 时才有值
             latency_ms: latencyMs,
             inputTokens,
             outputTokens,
@@ -68,6 +74,14 @@ class PerfTracker {
     }
     appendLog(entry) {
         try {
+            // Risk fix: JSONL 日志轮转保护，防止长期使用后文件无限增长
+            // 超过 5MB 时截断，保留最新 2000 行
+            const MAX_SIZE = 5 * 1024 * 1024; // 5 MB
+            const KEEP_LINES = 2000;
+            if (existsSync(LOG_PATH) && statSync(LOG_PATH).size > MAX_SIZE) {
+                const lines = readFileSync(LOG_PATH, "utf-8").trim().split("\n");
+                writeFileSync(LOG_PATH, lines.slice(-KEEP_LINES).join("\n") + "\n");
+            }
             appendFileSync(LOG_PATH, JSON.stringify(entry) + "\n");
         }
         catch {
@@ -87,6 +101,9 @@ class PerfTracker {
                 model,
                 providerID: entry.providerID,
                 requestCount: 0,
+                ttftCount: 0, // Bug fix: 独立维护有效样本计数
+                tpsCount: 0,
+                latencyCount: 0,
                 totalInput: 0,
                 totalOutput: 0,
                 totalCacheRead: 0,
@@ -95,12 +112,19 @@ class PerfTracker {
                 avgTTFT: null,
                 maxTTFT: null,
                 minTTFT: null,
+                p50TTFT: null,
+                p95TTFT: null,
+                p99TTFT: null,
                 avgTPS: null,
                 maxTPS: null,
                 minTPS: null,
                 avgLatency: null,
                 maxLatency: null,
                 minLatency: null,
+                p50Latency: null,
+                p95Latency: null,
+                p99Latency: null,
+                cacheHitRate: null,
             };
             this.statsMap.set(model, stats);
         }
@@ -111,41 +135,87 @@ class PerfTracker {
         stats.totalCacheWrite += entry.cacheWriteTokens;
         stats.totalCost += entry.cost;
         if (entry.ttft_ms !== null) {
-            const c = stats.requestCount;
+            // Bug fix: 分母使用 ttftCount（有效样本数），而非 requestCount（总请求数）
+            stats.ttftCount++;
+            const c = stats.ttftCount;
             const prev = stats.avgTTFT;
             stats.avgTTFT = prev !== null ? prev + (entry.ttft_ms - prev) / c : entry.ttft_ms;
             stats.maxTTFT = stats.maxTTFT !== null ? Math.max(stats.maxTTFT, entry.ttft_ms) : entry.ttft_ms;
             stats.minTTFT = stats.minTTFT !== null ? Math.min(stats.minTTFT, entry.ttft_ms) : entry.ttft_ms;
+            // 收集原始样本用于分位数计算
+            const ttftArr = this.ttftSamples.get(model) ?? [];
+            ttftArr.push(entry.ttft_ms);
+            this.ttftSamples.set(model, ttftArr);
         }
         if (entry.tps !== null) {
-            const c = stats.requestCount;
+            // Bug fix: 分母使用 tpsCount（有效样本数）
+            stats.tpsCount++;
+            const c = stats.tpsCount;
             const prev = stats.avgTPS;
             stats.avgTPS = prev !== null ? prev + (entry.tps - prev) / c : entry.tps;
             stats.maxTPS = stats.maxTPS !== null ? Math.max(stats.maxTPS, entry.tps) : entry.tps;
             stats.minTPS = stats.minTPS !== null ? Math.min(stats.minTPS, entry.tps) : entry.tps;
         }
         if (entry.latency_ms !== null) {
-            const c = stats.requestCount;
+            // latency 每条消息都有，但保持一致使用专用计数
+            stats.latencyCount++;
+            const c = stats.latencyCount;
             const prev = stats.avgLatency;
             stats.avgLatency = prev !== null ? prev + (entry.latency_ms - prev) / c : entry.latency_ms;
             stats.maxLatency = stats.maxLatency !== null ? Math.max(stats.maxLatency, entry.latency_ms) : entry.latency_ms;
             stats.minLatency = stats.minLatency !== null ? Math.min(stats.minLatency, entry.latency_ms) : entry.latency_ms;
+            // 收集原始样本用于分位数计算
+            const latArr = this.latencySamples.get(model) ?? [];
+            latArr.push(entry.latency_ms);
+            this.latencySamples.set(model, latArr);
         }
     }
+    /** 计算有序数组的指定百分位数（线性插值法） */
+    percentile(sortedArr, p) {
+        if (sortedArr.length === 0)
+            return null;
+        if (sortedArr.length === 1)
+            return sortedArr[0];
+        const idx = (p / 100) * (sortedArr.length - 1);
+        const lo = Math.floor(idx);
+        const hi = Math.ceil(idx);
+        if (lo === hi)
+            return sortedArr[lo];
+        return sortedArr[lo] + (sortedArr[hi] - sortedArr[lo]) * (idx - lo);
+    }
     getSessionStats() {
         let totalInput = 0, totalOutput = 0, totalCacheRead = 0, totalCacheWrite = 0;
         let totalRequests = 0, totalCost = 0;
-        for (const s of this.statsMap.values()) {
+        let weightedHitSum = 0, totalReqForHit = 0;
+        for (const [model, s] of this.statsMap) {
             totalInput += s.totalInput;
             totalOutput += s.totalOutput;
             totalCacheRead += s.totalCacheRead;
             totalCacheWrite += s.totalCacheWrite;
             totalRequests += s.requestCount;
             totalCost += s.totalCost;
+            // 计算每个模型的分位数（需先排序）
+            const ttftArr = [...(this.ttftSamples.get(model) ?? [])].sort((a, b) => a - b);
+            s.p50TTFT = this.percentile(ttftArr, 50);
+            s.p95TTFT = this.percentile(ttftArr, 95);
+            s.p99TTFT = this.percentile(ttftArr, 99);
+            const latArr = [...(this.latencySamples.get(model) ?? [])].sort((a, b) => a - b);
+            s.p50Latency = this.percentile(latArr, 50);
+            s.p95Latency = this.percentile(latArr, 95);
+            s.p99Latency = this.percentile(latArr, 99);
+            // 模型级缓存命中率
+            const denom = s.totalInput + s.totalCacheRead;
+            s.cacheHitRate = denom > 0 ? (s.totalCacheRead / denom) * 100 : null;
+            // 累加加权命中率（按请求数加权）
+            if (s.cacheHitRate !== null) {
+                weightedHitSum += s.cacheHitRate * s.requestCount;
+                totalReqForHit += s.requestCount;
+            }
         }
+        const weightedCacheHitRate = totalReqForHit > 0 ? weightedHitSum / totalReqForHit : null;
         return {
             models: Object.fromEntries(this.statsMap),
-            totals: { totalInput, totalOutput, totalCacheRead, totalCacheWrite, totalRequests, totalCost },
+            totals: { totalInput, totalOutput, totalCacheRead, totalCacheWrite, totalRequests, totalCost, weightedCacheHitRate },
         };
     }
     readLogs(last = 50) {
@@ -174,6 +244,8 @@ class PerfTracker {
     reset() {
         this.firstPartTimes.clear();
         this.statsMap.clear();
+        this.ttftSamples.clear();
+        this.latencySamples.clear();
     }
 }
 export function createPerfTracker() {

package/dist/queries.d.ts

@@ -1,4 +1,4 @@
-import type { DailyBreakdownItem, ModelBreakdownItem, ProviderBreakdownItem, SessionBreakdownItem, SessionTokenData, UsageFilters, UsageReport } from "./formatter.js";
+import type { DailyBreakdownItem, ErrorStats, ModelBreakdownItem, ProviderBreakdownItem, SessionBreakdownItem, SessionTokenData, UsageFilters, UsageReport } from "./formatter.js";
 export declare function getPresetRange(preset: "all" | "7d" | "30d" | "month"): Pick<UsageFilters, "startDate" | "endDate">;
 export declare function getCurrentSessionStats(sessionId?: string): Promise<SessionTokenData>;
 export declare function getSummary(filters?: UsageFilters): Promise<SessionTokenData>;
@@ -8,5 +8,7 @@ export declare function getDailyBreakdown(filters?: UsageFilters): Promise<Daily
 export declare function getSessionBreakdown(filters?: UsageFilters): Promise<SessionBreakdownItem[]>;
 export declare function getAvailableModels(): Promise<string[]>;
 export declare function getAvailableProviders(): Promise<string[]>;
+/** 失败请求计数 SQL。1次运行获取成功数＋失败数＋按模型细分 */
+export declare function getErrorStats(filters?: UsageFilters): Promise<ErrorStats>;
 export declare function getUsageReport(filters?: UsageFilters): Promise<UsageReport>;
 export declare function exportReportAsCsv(report: UsageReport, section: "models" | "providers" | "daily" | "sessions"): string;

package/dist/queries.js

@@ -20,6 +20,10 @@ async function queryDb(sql) {
 function escapeSql(value) {
     return value.replace(/'/g, "''");
 }
+/** 校验日期格式必须为 YYYY-MM-DD，防止格式异常字符串进入 SQL */
+function isValidDate(s) {
+    return /^\d{4}-\d{2}-\d{2}$/.test(s);
+}
 function messageWhere(filters) {
     const where = [
         "json_extract(m.data, '$.role') = 'assistant'",
@@ -31,10 +35,13 @@ function messageWhere(filters) {
         where.push(`coalesce(json_extract(m.data, '$.providerID'), '') = '${escapeSql(filters.provider)}'`);
     if (filters.model)
         where.push(`coalesce(json_extract(m.data, '$.modelID'), '') = '${escapeSql(filters.model)}'`);
-    if (filters.startDate)
-        where.push(`date(m.time_created / 1000, 'unixepoch', 'localtime') >= '${escapeSql(filters.startDate)}'`);
-    if (filters.endDate)
-        where.push(`date(m.time_created / 1000, 'unixepoch', 'localtime') <= '${escapeSql(filters.endDate)}'`);
+    // Risk fix: 日期参数先验证格式（YYYY-MM-DD），格式不符则忽略该过滤条件
+    if (filters.startDate && isValidDate(filters.startDate)) {
+        where.push(`date(m.time_created / 1000, 'unixepoch', 'localtime') >= '${filters.startDate}'`);
+    }
+    if (filters.endDate && isValidDate(filters.endDate)) {
+        where.push(`date(m.time_created / 1000, 'unixepoch', 'localtime') <= '${filters.endDate}'`);
+    }
     return where.join(" AND ");
 }
 function parseList(value) {
@@ -83,41 +90,41 @@ export async function getCurrentSessionStats(sessionId) {
     return getSummary(filters);
 }
 export async function getSummary(filters = {}) {
-    const sql = `
-SELECT
-  group_concat(distinct coalesce(json_extract(m.data, '$.modelID'), 'unknown')) as models_used,
-  group_concat(distinct coalesce(json_extract(m.data, '$.providerID'), 'unknown')) as providers_used,
-  count(*) as request_count,
-  sum(coalesce(json_extract(m.data, '$.tokens.total'), 0)) as total_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.input'), 0)) as input_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.output'), 0)) as output_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.reasoning'), 0)) as reasoning_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.cache.read'), 0)) as cache_read,
-  sum(coalesce(json_extract(m.data, '$.tokens.cache.write'), 0)) as cache_write,
-  sum(coalesce(json_extract(m.data, '$.cost'), 0)) as total_cost
-FROM message m
-WHERE ${messageWhere(filters)}
+    const sql = `
+SELECT
+  group_concat(distinct coalesce(json_extract(m.data, '$.modelID'), 'unknown')) as models_used,
+  group_concat(distinct coalesce(json_extract(m.data, '$.providerID'), 'unknown')) as providers_used,
+  count(*) as request_count,
+  sum(coalesce(json_extract(m.data, '$.tokens.total'), 0)) as total_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.input'), 0)) as input_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.output'), 0)) as output_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.reasoning'), 0)) as reasoning_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.cache.read'), 0)) as cache_read,
+  sum(coalesce(json_extract(m.data, '$.tokens.cache.write'), 0)) as cache_write,
+  sum(coalesce(json_extract(m.data, '$.cost'), 0)) as total_cost
+FROM message m
+WHERE ${messageWhere(filters)}
   `.trim();
     const rows = await queryDb(sql);
     return toSessionTokenData(rows[0]);
 }
 export async function getModelBreakdown(filters = {}) {
-    const sql = `
-SELECT
-  coalesce(json_extract(m.data, '$.providerID'), 'unknown') as provider,
-  coalesce(json_extract(m.data, '$.modelID'), 'unknown') as model,
-  count(*) as requests,
-  count(distinct m.session_id) as sessions,
-  sum(coalesce(json_extract(m.data, '$.tokens.total'), 0)) as total_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.input'), 0)) as input_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.output'), 0)) as output_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.reasoning'), 0)) as reasoning_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.cache.read'), 0)) as cache_read,
-  sum(coalesce(json_extract(m.data, '$.cost'), 0)) as total_cost
-FROM message m
-WHERE ${messageWhere(filters)}
-GROUP BY provider, model
-ORDER BY total_tokens DESC
+    const sql = `
+SELECT
+  coalesce(json_extract(m.data, '$.providerID'), 'unknown') as provider,
+  coalesce(json_extract(m.data, '$.modelID'), 'unknown') as model,
+  count(*) as requests,
+  count(distinct m.session_id) as sessions,
+  sum(coalesce(json_extract(m.data, '$.tokens.total'), 0)) as total_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.input'), 0)) as input_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.output'), 0)) as output_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.reasoning'), 0)) as reasoning_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.cache.read'), 0)) as cache_read,
+  sum(coalesce(json_extract(m.data, '$.cost'), 0)) as total_cost
+FROM message m
+WHERE ${messageWhere(filters)}
+GROUP BY provider, model
+ORDER BY total_tokens DESC
   `.trim();
     const rows = await queryDb(sql);
     return rows.map((row) => ({
@@ -134,21 +141,21 @@ ORDER BY total_tokens DESC
     }));
 }
 export async function getProviderBreakdown(filters = {}) {
-    const sql = `
-SELECT
-  coalesce(json_extract(m.data, '$.providerID'), 'unknown') as provider,
-  count(*) as requests,
-  count(distinct m.session_id) as sessions,
-  sum(coalesce(json_extract(m.data, '$.tokens.total'), 0)) as total_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.input'), 0)) as input_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.output'), 0)) as output_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.reasoning'), 0)) as reasoning_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.cache.read'), 0)) as cache_read,
-  sum(coalesce(json_extract(m.data, '$.cost'), 0)) as total_cost
-FROM message m
-WHERE ${messageWhere(filters)}
-GROUP BY provider
-ORDER BY total_tokens DESC
+    const sql = `
+SELECT
+  coalesce(json_extract(m.data, '$.providerID'), 'unknown') as provider,
+  count(*) as requests,
+  count(distinct m.session_id) as sessions,
+  sum(coalesce(json_extract(m.data, '$.tokens.total'), 0)) as total_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.input'), 0)) as input_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.output'), 0)) as output_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.reasoning'), 0)) as reasoning_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.cache.read'), 0)) as cache_read,
+  sum(coalesce(json_extract(m.data, '$.cost'), 0)) as total_cost
+FROM message m
+WHERE ${messageWhere(filters)}
+GROUP BY provider
+ORDER BY total_tokens DESC
   `.trim();
     const rows = await queryDb(sql);
     return rows.map((row) => ({
@@ -165,22 +172,22 @@ ORDER BY total_tokens DESC
 }
 export async function getDailyBreakdown(filters = {}) {
     const limit = filters.limit ?? 30;
-    const sql = `
-SELECT
-  date(m.time_created / 1000, 'unixepoch', 'localtime') as day,
-  count(*) as requests,
-  count(distinct m.session_id) as sessions,
-  sum(coalesce(json_extract(m.data, '$.tokens.total'), 0)) as total_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.input'), 0)) as input_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.output'), 0)) as output_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.reasoning'), 0)) as reasoning_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.cache.read'), 0)) as cache_read,
-  sum(coalesce(json_extract(m.data, '$.cost'), 0)) as total_cost
-FROM message m
-WHERE ${messageWhere(filters)}
-GROUP BY day
-ORDER BY day DESC
-LIMIT ${Math.max(1, limit)}
+    const sql = `
+SELECT
+  date(m.time_created / 1000, 'unixepoch', 'localtime') as day,
+  count(*) as requests,
+  count(distinct m.session_id) as sessions,
+  sum(coalesce(json_extract(m.data, '$.tokens.total'), 0)) as total_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.input'), 0)) as input_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.output'), 0)) as output_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.reasoning'), 0)) as reasoning_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.cache.read'), 0)) as cache_read,
+  sum(coalesce(json_extract(m.data, '$.cost'), 0)) as total_cost
+FROM message m
+WHERE ${messageWhere(filters)}
+GROUP BY day
+ORDER BY day DESC
+LIMIT ${Math.max(1, limit)}
   `.trim();
     const rows = await queryDb(sql);
     return rows.map((row) => ({
@@ -197,26 +204,26 @@ LIMIT ${Math.max(1, limit)}
 }
 export async function getSessionBreakdown(filters = {}) {
     const limit = filters.limit ?? 15;
-    const sql = `
-SELECT
-  s.id as session_id,
-  s.title as title,
-  coalesce(json_extract(m.data, '$.providerID'), json_extract(s.model, '$.providerID'), 'unknown') as provider,
-  coalesce(json_extract(m.data, '$.modelID'), json_extract(s.model, '$.id'), 'unknown') as model,
-  count(*) as requests,
-  sum(coalesce(json_extract(m.data, '$.tokens.total'), 0)) as total_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.input'), 0)) as input_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.output'), 0)) as output_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.reasoning'), 0)) as reasoning_tokens,
-  sum(coalesce(json_extract(m.data, '$.tokens.cache.read'), 0)) as cache_read,
-  sum(coalesce(json_extract(m.data, '$.cost'), 0)) as total_cost,
-  date(max(m.time_created) / 1000, 'unixepoch', 'localtime') as day
-FROM message m
-JOIN session s ON s.id = m.session_id
-WHERE ${messageWhere(filters)}
-GROUP BY s.id, s.title, provider, model
-ORDER BY max(m.time_created) DESC
-LIMIT ${Math.max(1, limit)}
+    const sql = `
+SELECT
+  s.id as session_id,
+  s.title as title,
+  coalesce(json_extract(m.data, '$.providerID'), json_extract(s.model, '$.providerID'), 'unknown') as provider,
+  coalesce(json_extract(m.data, '$.modelID'), json_extract(s.model, '$.id'), 'unknown') as model,
+  count(*) as requests,
+  sum(coalesce(json_extract(m.data, '$.tokens.total'), 0)) as total_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.input'), 0)) as input_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.output'), 0)) as output_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.reasoning'), 0)) as reasoning_tokens,
+  sum(coalesce(json_extract(m.data, '$.tokens.cache.read'), 0)) as cache_read,
+  sum(coalesce(json_extract(m.data, '$.cost'), 0)) as total_cost,
+  date(max(m.time_created) / 1000, 'unixepoch', 'localtime') as day
+FROM message m
+JOIN session s ON s.id = m.session_id
+WHERE ${messageWhere(filters)}
+GROUP BY s.id, s.title, provider, model
+ORDER BY max(m.time_created) DESC
+LIMIT ${Math.max(1, limit)}
   `.trim();
     const rows = await queryDb(sql);
     return rows.map((row) => ({
@@ -235,34 +242,86 @@ LIMIT ${Math.max(1, limit)}
     }));
 }
 export async function getAvailableModels() {
-    const sql = `
-SELECT distinct coalesce(json_extract(m.data, '$.modelID'), 'unknown') as value
-FROM message m
-WHERE ${messageWhere({})}
-ORDER BY value ASC
+    const sql = `
+SELECT distinct coalesce(json_extract(m.data, '$.modelID'), 'unknown') as value
+FROM message m
+WHERE ${messageWhere({})}
+ORDER BY value ASC
   `.trim();
     const rows = await queryDb(sql);
     return rows.map((row) => row.value ?? "unknown");
 }
 export async function getAvailableProviders() {
-    const sql = `
-SELECT distinct coalesce(json_extract(m.data, '$.providerID'), 'unknown') as value
-FROM message m
-WHERE ${messageWhere({})}
-ORDER BY value ASC
+    const sql = `
+SELECT distinct coalesce(json_extract(m.data, '$.providerID'), 'unknown') as value
+FROM message m
+WHERE ${messageWhere({})}
+ORDER BY value ASC
   `.trim();
     const rows = await queryDb(sql);
     return rows.map((row) => row.value ?? "unknown");
 }
+/** 失败请求计数 SQL。1次运行获取成功数＋失败数＋按模型细分 */
+export async function getErrorStats(filters = {}) {
+    // 构建日期／Session/Provider/Model 过滤条件（不包含 tokens.total > 0 过滤）
+    const baseConds = [
+        "json_extract(m.data, '$.role') = 'assistant'",
+    ];
+    if (filters.sessionId)
+        baseConds.push(`m.session_id = '${escapeSql(filters.sessionId)}'`);
+    if (filters.provider)
+        baseConds.push(`coalesce(json_extract(m.data, '$.providerID'), '') = '${escapeSql(filters.provider)}'`);
+    if (filters.model)
+        baseConds.push(`coalesce(json_extract(m.data, '$.modelID'), '') = '${escapeSql(filters.model)}'`);
+    if (filters.startDate && isValidDate(filters.startDate)) {
+        baseConds.push(`date(m.time_created / 1000, 'unixepoch', 'localtime') >= '${filters.startDate}'`);
+    }
+    if (filters.endDate && isValidDate(filters.endDate)) {
+        baseConds.push(`date(m.time_created / 1000, 'unixepoch', 'localtime') <= '${filters.endDate}'`);
+    }
+    const baseWhere = baseConds.join(" AND ");
+    // 按模型细化：同时统计成功和失败请求
+    const sql = `
+SELECT
+  coalesce(json_extract(m.data, '$.providerID'), 'unknown') as provider,
+  coalesce(json_extract(m.data, '$.modelID'), 'unknown') as model,
+  count(*) as total,
+  sum(CASE WHEN coalesce(json_extract(m.data, '$.tokens.total'), 0) = 0 THEN 1 ELSE 0 END) as failed
+FROM message m
+WHERE ${baseWhere}
+GROUP BY provider, model
+ORDER BY failed DESC
+  `.trim();
+    try {
+        const rows = await queryDb(sql);
+        let successCount = 0, failedCount = 0;
+        const byModel = rows.map(r => {
+            const total = r.total ?? 0;
+            const failed = r.failed ?? 0;
+            const success = total - failed;
+            successCount += success;
+            failedCount += failed;
+            return { provider: r.provider ?? 'unknown', model: r.model ?? 'unknown', failed, total };
+        });
+        const errorRate = (successCount + failedCount) > 0
+            ? failedCount / (successCount + failedCount)
+            : 0;
+        return { successCount, failedCount, errorRate, byModel };
+    }
+    catch {
+        return { successCount: 0, failedCount: 0, errorRate: 0, byModel: [] };
+    }
+}
 export async function getUsageReport(filters = {}) {
-    const [summary, models, providers, daily, sessions] = await Promise.all([
+    const [summary, models, providers, daily, sessions, errors] = await Promise.all([
         getSummary(filters),
         getModelBreakdown(filters),
         getProviderBreakdown(filters),
         getDailyBreakdown(filters),
         getSessionBreakdown(filters),
+        getErrorStats(filters),
     ]);
-    return { filters, summary, models, providers, daily, sessions };
+    return { filters, summary, models, providers, daily, sessions, errors };
 }
 function csvEscape(value) {
     const text = String(value);