openclaw-diag-cli 0.1.0

package/diag/07_performance.py

@@ -0,0 +1,687 @@
+#!/usr/bin/env python3
+"""模块 7：模型与性能数据（慢调用 Top 20、E2E 延迟、Cache 命中率）。"""
+
+from __future__ import annotations
+
+import glob
+import json
+import os
+import sys
+import tempfile
+from collections import defaultdict
+from datetime import datetime, timezone, timedelta
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from ocdiag import cli, output
+
+
+NORMAL_STOPS = {"stop", "end_turn", "toolUse", "tool_calls", ""}
+
+
+def parse_obj_ts(ts_str):
+    if not ts_str:
+        return None
+    try:
+        return datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+    except Exception:
+        return None
+
+
+def parse_msg_ts(ms):
+    if ms is None:
+        return None
+    try:
+        return datetime.fromtimestamp(int(ms) / 1000, tz=timezone.utc)
+    except Exception:
+        return None
+
+
+def pct(sorted_vals, p):
+    if not sorted_vals:
+        return 0.0
+    n = len(sorted_vals)
+    idx = min(n - 1, int(n * p))
+    return sorted_vals[idx]
+
+
+def fmt_tokens(n):
+    if n >= 1_000_000:
+        return f"{n/1_000_000:.1f}M"
+    if n >= 1_000:
+        return f"{n/1_000:.1f}K"
+    return str(n)
+
+
+def fmt_args(tool_name, tc_args, max_len=100):
+    if isinstance(tc_args, str):
+        try:
+            tc_args = json.loads(tc_args)
+        except Exception:
+            return (tc_args or "")[:max_len]
+    if not isinstance(tc_args, dict) or not tc_args:
+        return ""
+
+    def trunc(s, n):
+        s = "" if s is None else str(s)
+        return s[:n] + ("..." if len(s) > n else "")
+
+    name = (tool_name or "").lower()
+    if name == "exec":
+        return trunc(tc_args.get("command", ""), max_len)
+    if name == "web_fetch":
+        return trunc(tc_args.get("url", ""), max_len)
+    if name == "web_search":
+        return trunc(tc_args.get("query", ""), max_len)
+    if name == "sessions_spawn":
+        aid = tc_args.get("agentId", "")
+        task = trunc(tc_args.get("task", ""), 60)
+        return trunc(f"agentId={aid}, task={task}", max_len)
+    if name in ("read", "write", "edit"):
+        return trunc(tc_args.get("path", ""), max_len)
+    if name == "cron":
+        action = tc_args.get("action", "")
+        jid = tc_args.get("jobId", "")
+        s = f"action={action}, jobId={jid}" if jid else f"action={action}"
+        return trunc(s, max_len)
+    if name in ("image", "image_generate"):
+        return trunc(tc_args.get("prompt", ""), 60)
+    parts = []
+    for k, v in list(tc_args.items())[:3]:
+        sv = str(v)
+        if len(sv) > 50:
+            sv = sv[:50] + "..."
+        parts.append(f"{k}={sv}")
+    return trunc(", ".join(parts), max_len)
+
+
+def categorize_api_error(msg, stop):
+    text = str(msg.get("error", ""))
+    content = msg.get("content", "")
+    if isinstance(content, list):
+        for c in content:
+            if isinstance(c, dict):
+                t = c.get("text") or c.get("content") or ""
+                if t:
+                    text += " " + str(t)
+            elif isinstance(c, str):
+                text += " " + c
+    elif isinstance(content, str):
+        text += " " + content
+    text = text[:1000]
+    low = text.lower()
+    if "429" in text or "rate limit" in low or "throttl" in low:
+        return "rate_limit(429)"
+    if "503" in text or "service unavailable" in low:
+        return "service_unavailable(503)"
+    if "401" in text or "403" in text or "unauthorized" in low or "forbidden" in low:
+        return "auth_error(401/403)"
+    if "500" in text or "internal server" in low:
+        return "server_error(500)"
+    if "timeout" in low or "timed out" in low:
+        return "timeout"
+    if "connection" in low and ("refused" in low or "reset" in low or "aborted" in low):
+        return "connection_error"
+    if stop == "aborted" or "aborted" in low:
+        return "aborted"
+    return f"other(stop={stop or 'n/a'})"
+
+
+def collect_session_files(sessions_base, limit=20):
+    files = []
+    pattern1 = os.path.join(sessions_base, "*", "*", "*.jsonl")
+    pattern2 = os.path.join(sessions_base, "*", "*", "*.jsonl.reset.*")
+    for pat in (pattern1, pattern2):
+        for p in glob.glob(pat):
+            if p.endswith(".trajectory.jsonl"):
+                continue
+            try:
+                m = os.path.getmtime(p)
+            except OSError:
+                continue
+            files.append((m, p))
+    files.sort(reverse=True)
+    return [p for _, p in files[:limit]]
+
+
+def tail_lines(path, n=500):
+    try:
+        with open(path, "r", errors="replace") as f:
+            return f.readlines()[-n:]
+    except OSError:
+        return []
+
+
+def analyze_sessions(session_files):
+    model_stats = defaultdict(lambda: {
+        "calls": 0, "input": 0, "output": 0,
+        "cache_read": 0, "cache_write": 0, "cost": 0.0,
+        "durations": [], "stop_reasons": defaultdict(int),
+    })
+    tool_stats = defaultdict(lambda: {
+        "calls": 0, "errors": 0, "durations": [],
+        "records": [], "error_records": [],
+    })
+    all_model_durations = []
+    all_tool_durations = []
+    abnormal_stops = []
+    slow_calls_top = []
+    ctx_buckets_def = [
+        ("<50K", 50_000),
+        ("50K-100K", 100_000),
+        ("100K-200K", 200_000),
+        (">200K", float("inf")),
+    ]
+    ctx_bucket_durs = defaultdict(list)
+    daily_stats = defaultdict(lambda: {"calls": 0, "durs": [], "output": 0})
+    cache_total_calls = 0
+    cache_calls_with_cache = 0
+    cache_sum_input = 0
+    cache_sum_cache_read = 0
+    cache_sum_cache_write = 0
+    session_stats = defaultdict(lambda: {"calls": 0, "tokens": 0, "duration": 0.0})
+
+    e2e_latencies = []
+
+    api_error_stats = defaultdict(int)
+    api_total_assistant_calls = 0
+
+    for session_path in session_files:
+        sess_id = os.path.basename(session_path).split(".jsonl")[0]
+        current_session_id = sess_id
+        max_msg_ms = 0
+        pending_tool_calls = {}
+        current_turn_user_ts = None
+        current_turn_last_assistant_ts = None
+
+        for raw_line in tail_lines(session_path, 500):
+            raw_line = raw_line.strip()
+            if not raw_line:
+                continue
+            try:
+                obj = json.loads(raw_line)
+            except Exception:
+                continue
+
+            msg = obj.get("message", {}) or {}
+            role = msg.get("role", "")
+            obj_ts = parse_obj_ts(obj.get("timestamp"))
+            msg_ts_raw = msg.get("timestamp")
+            msg_ts = parse_msg_ts(msg_ts_raw)
+
+            if msg_ts_raw is not None:
+                if msg_ts_raw < max_msg_ms - 1000:
+                    continue
+                if msg_ts_raw > max_msg_ms:
+                    max_msg_ms = msg_ts_raw
+
+            if role == "assistant":
+                provider = msg.get("provider") or ""
+                model = msg.get("model") or "?"
+                if provider == "openclaw" and model in ("delivery-mirror", "gateway-injected"):
+                    continue
+                model_key = f"{provider}/{model}" if provider else model
+                usage = msg.get("usage", {}) or {}
+                stop = msg.get("stopReason", "") or ""
+                inp = usage.get("input", 0) or 0
+                out_v = usage.get("output", 0) or 0
+                cr = usage.get("cacheRead", 0) or 0
+                cw = usage.get("cacheWrite", 0) or 0
+                cost_obj = usage.get("cost", {}) or {}
+                cost = (cost_obj.get("total", 0) or 0) if isinstance(cost_obj, dict) else 0
+
+                s = model_stats[model_key]
+                s["calls"] += 1
+                s["input"] += inp
+                s["output"] += out_v
+                s["cache_read"] += cr
+                s["cache_write"] += cw
+                s["cost"] += cost
+                if stop:
+                    s["stop_reasons"][stop] += 1
+
+                dur = None
+                if obj_ts and msg_ts:
+                    dur = (obj_ts - msg_ts).total_seconds()
+                    if 0 <= dur <= 600:
+                        s["durations"].append(dur)
+                        all_model_durations.append((dur, model_key))
+                        label = obj_ts.strftime("%Y-%m-%d %H:%M:%S")
+                        dedup_key = (label, model_key, inp)
+                        slow_calls_top.append((
+                            dur, "model",
+                            f"{label} | {model_key} | {dur:.1f}s | "
+                            f"in={fmt_tokens(inp + cr)} out={fmt_tokens(out_v)} | stop={stop or 'n/a'}",
+                            dedup_key,
+                        ))
+                        ctx_size = inp + cr
+                        for (b_label, b_upper) in ctx_buckets_def:
+                            if ctx_size < b_upper:
+                                ctx_bucket_durs[b_label].append(dur)
+                                break
+
+                if obj_ts:
+                    day_key = obj_ts.strftime("%m-%d")
+                    d = daily_stats[day_key]
+                    d["calls"] += 1
+                    if dur is not None and 0 <= dur <= 600:
+                        d["durs"].append(dur)
+                    d["output"] += out_v
+
+                if current_session_id:
+                    ss = session_stats[current_session_id]
+                    ss["calls"] += 1
+                    ss["tokens"] += inp + cr + out_v
+                    if dur is not None and 0 <= dur <= 600:
+                        ss["duration"] += dur
+
+                cache_total_calls += 1
+                if cr > 0:
+                    cache_calls_with_cache += 1
+                cache_sum_input += inp
+                cache_sum_cache_read += cr
+                cache_sum_cache_write += cw
+
+                api_total_assistant_calls += 1
+                if stop and stop not in NORMAL_STOPS:
+                    label = obj_ts.strftime("%Y-%m-%d %H:%M:%S") if obj_ts else "?"
+                    abnormal_stops.append(
+                        f"{label} | {model_key} | stop={stop} | "
+                        f"in={fmt_tokens(inp + cr)} out={fmt_tokens(out_v)}"
+                    )
+                    api_error_stats[categorize_api_error(msg, stop)] += 1
+
+                if obj_ts is not None and current_turn_user_ts is not None and out_v > 0:
+                    current_turn_last_assistant_ts = obj_ts
+
+                for part in msg.get("content", []) or []:
+                    if not isinstance(part, dict):
+                        continue
+                    if part.get("type") != "toolCall":
+                        continue
+                    tc_id = part.get("id", "")
+                    if not tc_id:
+                        continue
+                    tc_name = part.get("name", "") or ""
+                    tc_args = part.get("arguments", part.get("input", ""))
+                    pending_tool_calls[tc_id] = (tc_name, tc_args)
+
+            elif role == "toolResult":
+                tool_name = msg.get("toolName") or "?"
+                tool_id = msg.get("toolCallId") or ""
+                details = msg.get("details") or {}
+                dur_ms = details.get("durationMs") if isinstance(details, dict) else None
+                is_error = bool(msg.get("isError", False))
+
+                ts = tool_stats[tool_name]
+                ts["calls"] += 1
+                if is_error:
+                    ts["errors"] += 1
+
+                pending = pending_tool_calls.pop(tool_id, None) if tool_id else None
+                if pending:
+                    args_name, raw_args = pending
+                    args_str = fmt_args(args_name or tool_name, raw_args)
+                else:
+                    args_str = ""
+
+                err_brief = ""
+                if is_error:
+                    content = msg.get("content")
+                    if isinstance(content, list):
+                        for c in content:
+                            if isinstance(c, dict):
+                                t = c.get("text") or c.get("content") or ""
+                                if t:
+                                    err_brief = str(t)
+                                    break
+                            elif isinstance(c, str):
+                                err_brief = c
+                                break
+                    elif isinstance(content, str):
+                        err_brief = content
+                    err_brief = err_brief.replace("\n", " ")[:80]
+
+                dur_s = None
+                if isinstance(dur_ms, (int, float)) and dur_ms >= 0:
+                    dur_s = dur_ms / 1000.0
+
+                rec = {
+                    "dur": dur_s, "args": args_str,
+                    "is_error": is_error, "err_brief": err_brief,
+                    "ts": obj_ts,
+                }
+                ts["records"].append(rec)
+                if is_error:
+                    ts["error_records"].append(rec)
+
+                if dur_s is not None:
+                    ts["durations"].append(dur_s)
+                    all_tool_durations.append((dur_s, tool_name))
+                    label = obj_ts.strftime("%Y-%m-%d %H:%M:%S") if obj_ts else "?"
+                    brief = f" | {args_str}" if args_str else ""
+                    err_suffix = f" | {err_brief}" if (is_error and err_brief) else ""
+                    err_tag = " | error=True" if is_error else ""
+                    slow_calls_top.append((
+                        dur_s, "tool",
+                        f"{label} | {tool_name} | {dur_s:.1f}s{err_tag}{brief}{err_suffix}",
+                        None,
+                    ))
+
+            elif role == "user":
+                if current_turn_user_ts is not None and current_turn_last_assistant_ts is not None:
+                    _lat = (current_turn_last_assistant_ts - current_turn_user_ts).total_seconds()
+                    if 1 <= _lat <= 3600:
+                        e2e_latencies.append(_lat)
+                current_turn_user_ts = obj_ts
+                current_turn_last_assistant_ts = None
+
+        if current_turn_user_ts is not None and current_turn_last_assistant_ts is not None:
+            _lat = (current_turn_last_assistant_ts - current_turn_user_ts).total_seconds()
+            if 1 <= _lat <= 3600:
+                e2e_latencies.append(_lat)
+
+    return dict(
+        model_stats=model_stats,
+        tool_stats=tool_stats,
+        all_model_durations=all_model_durations,
+        all_tool_durations=all_tool_durations,
+        abnormal_stops=abnormal_stops,
+        slow_calls_top=slow_calls_top,
+        ctx_buckets_def=ctx_buckets_def,
+        ctx_bucket_durs=ctx_bucket_durs,
+        daily_stats=daily_stats,
+        cache_total_calls=cache_total_calls,
+        cache_calls_with_cache=cache_calls_with_cache,
+        cache_sum_input=cache_sum_input,
+        cache_sum_cache_read=cache_sum_cache_read,
+        cache_sum_cache_write=cache_sum_cache_write,
+        session_stats=session_stats,
+        e2e_latencies=e2e_latencies,
+        api_error_stats=api_error_stats,
+        api_total_assistant_calls=api_total_assistant_calls,
+    )
+
+
+def render(out: output.Output, data, file_count):
+    # Bottleneck
+    out.subsection("性能耗时分布")
+    all_md = data["all_model_durations"]
+    all_td = data["all_tool_durations"]
+    model_p95 = pct(sorted(d for d, _ in all_md), 0.95) if all_md else 0.0
+    tool_p95 = pct(sorted(d for d, _ in all_td), 0.95) if all_td else 0.0
+
+    def top_contributor(pairs):
+        counts = defaultdict(int)
+        for d, n in pairs:
+            counts[n] += 1
+        if not counts:
+            return None
+        return max(counts.items(), key=lambda x: x[1])[0]
+
+    model_top = top_contributor(all_md) or "?"
+    tool_top = top_contributor(all_td) or "?"
+    bottleneck_items = [
+        ("模型响应", model_p95, f"主要来自 {model_top}"),
+        ("工具执行", tool_p95, f"主要来自 {tool_top}"),
+    ]
+    bottleneck_items.sort(key=lambda x: x[1], reverse=True)
+    if not (all_md or all_td):
+        out.item("（数据不足）")
+    else:
+        for i, (sec, val, hint) in enumerate(bottleneck_items):
+            out.item(f"#{i+1}: {sec}（P95={val:.1f}s, {hint}）")
+
+    out.subsection("模型性能")
+    out.item(f"数据来源: 最近 {file_count} 个 session 文件")
+    out.line("")
+    model_stats = data["model_stats"]
+    if not model_stats:
+        out.item("最近 Session 中未发现模型使用数据")
+    else:
+        for model_key in sorted(model_stats.keys(), key=lambda k: model_stats[k]["calls"], reverse=True):
+            s = model_stats[model_key]
+            durs = sorted(s["durations"])
+            calls = s["calls"]
+            p50 = pct(durs, 0.50)
+            p95 = pct(durs, 0.95)
+            mx = durs[-1] if durs else 0.0
+            total_dur = sum(durs)
+            tokens_unreported = (s["input"] + s["output"] + s["cache_read"]) == 0
+            throughput_str = (
+                "N/A" if s["output"] == 0
+                else f"{(s['output'] / total_dur):.1f} tok/s" if total_dur > 0 else "N/A"
+            )
+            stops = s["stop_reasons"]
+            normal = sum(v for k, v in stops.items() if k in NORMAL_STOPS)
+            success = (normal / calls * 100) if calls else 0.0
+            latency_warn = ""
+            if calls > 3 and len(durs) > 3 and durs[0] == durs[-1]:
+                latency_warn = " [⚠ 时间精度不足]"
+            out.item(model_key)
+            out.item(f"  调用: {calls} | P50: {p50:.1f}s | P95: {p95:.1f}s | "
+                     f"Max: {mx:.1f}s | 吞吐: {throughput_str} | 成功率: {success:.0f}%{latency_warn}")
+            if tokens_unreported:
+                tok_line = "  tokens: 未报告"
+                if s["cache_write"]:
+                    tok_line += f" | cache_write={fmt_tokens(s['cache_write'])}"
+                tok_line += " | cost: N/A" if s["cost"] == 0 else f" | cost: ${s['cost']:.4f}"
+            else:
+                tok_line = (
+                    f"  tokens: in={fmt_tokens(s['input'] + s['cache_read'])} "
+                    f"out={fmt_tokens(s['output'])}"
+                )
+                if s["cache_read"]:
+                    tok_line += f" | cache_read={fmt_tokens(s['cache_read'])}"
+                if s["cache_write"]:
+                    tok_line += f" | cache_write={fmt_tokens(s['cache_write'])}"
+                tok_line += f" | cost: ${s['cost']:.4f}"
+            out.item(tok_line)
+            stops_str = " ".join(f"{k}:{v}" for k, v in sorted(stops.items(), key=lambda x: -x[1]))
+            out.item(f"  stopReasons: {stops_str}" if stops_str else "  stopReasons: (none)")
+            out.line("")
+
+    out.subsection("工具性能（Top 10 by 调用量）")
+    timed_tools = {n: s for n, s in data["tool_stats"].items() if s["durations"]}
+    if not timed_tools:
+        out.item("（无工具调用数据）")
+    else:
+        ranked = sorted(timed_tools.items(), key=lambda kv: kv[1]["calls"], reverse=True)[:10]
+        for name, s in ranked:
+            durs = sorted(s["durations"])
+            calls = s["calls"]
+            err_rate = (s["errors"] / calls * 100) if calls else 0.0
+            dur_str = f"P50={pct(durs,0.50):.3f}s P95={pct(durs,0.95):.3f}s Max={durs[-1]:.3f}s"
+            out.item(f"{name}: {calls} 次 | {dur_str} | 错误 {err_rate:.0f}%")
+            timed = [r for r in s["records"] if r["dur"] is not None]
+            timed.sort(key=lambda r: r["dur"], reverse=True)
+            for i, r in enumerate(timed[:10]):
+                args = r["args"] or "(无参数)"
+                out.item(f"  #{i+1}: {args} ({r['dur']:.3f}s)")
+            shown_ids = {id(r) for r in timed[:10]}
+            err_shown = 0
+            for r in s["error_records"]:
+                if id(r) in shown_ids:
+                    continue
+                if err_shown >= 2:
+                    break
+                args = r["args"] or "(无参数)"
+                dur_txt = f"{r['dur']:.1f}s" if r["dur"] is not None else "n/a"
+                tail = f", {r['err_brief']}" if r["err_brief"] else ""
+                out.item(f"  失败: {args} (error, {dur_txt}{tail})")
+                err_shown += 1
+
+    out.subsection("慢调用 Top 20")
+    slow = sorted(data["slow_calls_top"], key=lambda x: x[0], reverse=True)
+    seen_keys = set()
+    dedup = []
+    for entry in slow:
+        key = entry[3]
+        if key is not None:
+            if key in seen_keys:
+                continue
+            seen_keys.add(key)
+        dedup.append(entry)
+    top20 = dedup[:20]
+    if not top20:
+        out.item("（无数据）")
+    else:
+        for i, entry in enumerate(top20, 1):
+            out.item(f"[{i}] {entry[2]}")
+
+    out.subsection("异常 stopReason — 模型非正常结束（如 error、中断）")
+    abnormal_stops = data["abnormal_stops"]
+    out.item(f"共 {len(abnormal_stops)} 条" + ("（无异常）" if not abnormal_stops else ""))
+    for s in abnormal_stops[:20]:
+        out.item(s)
+
+    out.subsection("模型 API 错误分布")
+    api_err_total = sum(data["api_error_stats"].values())
+    api_total = data["api_total_assistant_calls"]
+    if api_total == 0:
+        out.item("（无调用数据）")
+    else:
+        err_rate = api_err_total / api_total * 100
+        out.item(f"总异常: {api_err_total} (总调用 {api_total} 中, 异常率 {err_rate:.1f}%)")
+        if api_err_total > 0:
+            out.item("分布:")
+            for cat, n in sorted(data["api_error_stats"].items(), key=lambda kv: -kv[1]):
+                out.item(f"  {cat}: {n}")
+
+    out.subsection("端到端消息延迟（user 发送 → assistant 最终响应）")
+    e2e = data["e2e_latencies"]
+    if not e2e:
+        out.item("（数据不足，未发现 user→assistant 配对）")
+    else:
+        lat_sorted = sorted(e2e)
+        p50 = pct(lat_sorted, 0.50)
+        p95 = pct(lat_sorted, 0.95)
+        mx = lat_sorted[-1]
+        out.item(f"样本: {len(lat_sorted)} | P50={p50:.1f}s P95={p95:.1f}s Max={mx:.1f}s")
+        e2e_buckets = [("<10s", 10.0), ("10-30s", 30.0), ("30-60s", 60.0),
+                       ("60-120s", 120.0), (">120s", float("inf"))]
+        bucket_counts = {lbl: 0 for lbl, _ in e2e_buckets}
+        for v in lat_sorted:
+            for (lbl, upper) in e2e_buckets:
+                if v < upper:
+                    bucket_counts[lbl] += 1
+                    break
+        total = len(lat_sorted)
+        out.item("分布:")
+        for (lbl, _) in e2e_buckets:
+            n = bucket_counts[lbl]
+            pct_v = (n / total * 100) if total else 0.0
+            out.item(f"  {lbl}: {n} ({pct_v:.1f}%)")
+
+    out.subsection("延迟 vs 上下文大小")
+    ctx_buckets_def = data["ctx_buckets_def"]
+    ctx_durs = data["ctx_bucket_durs"]
+    if not any(ctx_durs.get(l) for l, _ in ctx_buckets_def):
+        out.item("（数据不足）")
+    else:
+        out.line(f"    {'上下文段':<14} {'调用数':>8} {'P50延迟':>10} {'P95延迟':>10}")
+        for (b_label, _) in ctx_buckets_def:
+            durs = sorted(ctx_durs.get(b_label, []))
+            if not durs:
+                out.line(f"    {b_label:<14} {0:>8} {'-':>10} {'-':>10}")
+                continue
+            p50 = pct(durs, 0.50)
+            p95 = pct(durs, 0.95)
+            out.line(f"    {b_label:<14} {len(durs):>8} {p50:>9.1f}s {p95:>9.1f}s")
+
+    out.subsection("每日趋势（最近 7 天）")
+    daily_stats = data["daily_stats"]
+    if not daily_stats:
+        out.item("（数据不足）")
+    else:
+        today = datetime.now(timezone.utc).date()
+        day_list = [(today - timedelta(days=i)).strftime("%m-%d") for i in range(7)]
+        out.line(f"    {'日期':<10} {'调用数':>8} {'P50延迟':>10} {'总输出tokens':>14}")
+        for d_key in day_list:
+            d = daily_stats.get(d_key)
+            if not d or d["calls"] == 0:
+                out.line(f"    {d_key:<10} {0:>8} {'-':>10} {'-':>14}")
+                continue
+            durs = sorted(d["durs"])
+            p50 = pct(durs, 0.50) if durs else 0.0
+            out.line(f"    {d_key:<10} {d['calls']:>8} {p50:>9.1f}s {fmt_tokens(d['output']):>14}")
+
+    out.subsection("Cache 命中率")
+    if data["cache_total_calls"] == 0:
+        out.item("（无数据）")
+    else:
+        hit_pct = (data["cache_calls_with_cache"] / data["cache_total_calls"] * 100)
+        out.item(
+            f"总调用: {data['cache_total_calls']} | "
+            f"触发 cache_read 的调用: {data['cache_calls_with_cache']} ({hit_pct:.1f}%)"
+        )
+        out.item(
+            f"cache_read: {fmt_tokens(data['cache_sum_cache_read'])} | "
+            f"input(非 cache): {fmt_tokens(data['cache_sum_input'])} | "
+            f"cache_write: {fmt_tokens(data['cache_sum_cache_write'])}"
+        )
+        denom = data["cache_sum_input"] + data["cache_sum_cache_read"]
+        if denom > 0:
+            ratio = data["cache_sum_cache_read"] / denom * 100
+            out.item(
+                f"上下文 cache 占比: cacheRead/(input+cacheRead) = "
+                f"{ratio:.3f}% ({fmt_tokens(data['cache_sum_cache_read'])}/{fmt_tokens(denom)})"
+            )
+
+    out.subsection("工具错误明细")
+    tool_stats = data["tool_stats"]
+    err_total = sum(s["errors"] for s in tool_stats.values())
+    call_total = sum(s["calls"] for s in tool_stats.values())
+    if err_total == 0:
+        out.item(f"共 0 次错误 (总调用 {call_total} 次中)")
+    else:
+        out.item(f"共 {err_total} 次错误 (总调用 {call_total} 次中):")
+        for name in sorted(tool_stats.keys(), key=lambda k: tool_stats[k]["errors"], reverse=True):
+            s = tool_stats[name]
+            if s["errors"] == 0:
+                continue
+            out.line(f"    {name} ({s['errors']}次):")
+            for r in s["error_records"][:3]:
+                ts_label = r["ts"].strftime("%Y-%m-%d %H:%M:%S") if r["ts"] else "?"
+                brief = r["err_brief"] or "(无错误内容)"
+                out.line(f"      {ts_label} | {brief[:100]}")
+
+    out.subsection("Session 消耗 Top 5")
+    session_stats = data["session_stats"]
+    if not session_stats:
+        out.item("（无数据）")
+    else:
+        ranked = sorted(session_stats.items(), key=lambda kv: kv[1]["tokens"], reverse=True)[:5]
+        out.line(f"    {'session':<40} {'调用数':>8} {'总tokens':>10} {'模型耗时累计':>12}")
+        for sid, ss in ranked:
+            out.line(f"    {sid:<40} {ss['calls']:>8} "
+                     f"{fmt_tokens(ss['tokens']):>10} {ss['duration']:>11.0f}s")
+
+
+def main() -> int:
+    parser = cli.build_common_parser(
+        description="模块 7：模型与性能数据",
+        prog="07_performance",
+    )
+    args = parser.parse_args()
+    out = output.init("performance", json_mode=args.json, no_color=args.no_color)
+    out.section("模块 7：模型与性能数据")
+
+    session_files = collect_session_files(args.sessions_base, limit=20)
+    if not session_files:
+        out.item("未找到 Session 文件")
+        return out.done()
+
+    data = analyze_sessions(session_files)
+    render(out, data, len(session_files))
+
+    if args.json:
+        out.set_data("model_count", len(data["model_stats"]))
+        out.set_data("session_files_analyzed", len(session_files))
+        out.set_data("e2e_latency_count", len(data["e2e_latencies"]))
+    return out.done()
+
+
+if __name__ == "__main__":
+    sys.exit(main())