
#WorkBuddy #Token #省钱攻略 #AI办公

## 一、开场：我以为自己是轻度用户
![1.jpeg](https://developer.qcloudimg.com/http-save/yehe-12822470/d4078865f7c2269eab47a50a608da1a1.png)
前阵子我干了一件蠢事：以为自己只是"随便问问 AI"，结果绑定的智谱 API 免费额度（约 5000 万 Token）在 **3.5 小时**里被烧得干干净净。

我当时第一反应是——这 AI 是不是在后台偷偷乱调用？

但我没去骂街，而是让 WorkBuddy 调出它**自己的会话日志**，把每一笔账算了个底朝天。今天把方法和结论分享出来，帮你别踩同一个坑。

> 注：WorkBuddy 本身可以接入你自带的模型 API Key（我接的是智谱 GLM），用量都记在你自己的额度池里，所以"烧钱"烧的是你自己的 Token，不是平台积分。这也是为什么我非得算清楚不可。

## 二、先说结论（省流版）

Token 不是被"某一个对话框"匀速烧掉的，而是被 **三个并行会话 + 不断膨胀的上下文**联手吃光的。

单看一个对话框，你永远算不清账。

## 三、我是怎么查的

WorkBuddy 每次调用模型，都会把用量写进本地会话日志：每条记录都带着 **inputTokens** / **outputTokens** / **totalTokens**，还有缓存命中数。

我让 WorkBuddy 写了个 Python 脚本，扫描本机所有会话文件，按"**一次用户请求 = 一个任务**"聚合统计。核心逻辑就三步：

1. 用 **startsNewUserRequest** 标志切分任务；
2. 累加每个任务的 **providerData.usage**；
3. 顺带算出"单次最大上下文"，定位最烧钱的调用。
![2.jpeg](https://developer.qcloudimg.com/http-save/yehe-12822470/f7d6ee011afad9480cb7df309b2bfb25.png)
下面是这个统计脚本的完整代码，复制保存为 token_stat.py 直接就能跑（把 PROJ 改成你本机 WorkBuddy 的 projects 目录即可）：

```python
# -*- coding: utf-8 -*-
"""
任务 Token 统计工具
--------------------------------------------
原理：WorkBuddy 把每次对话完整写进 .jsonl 会话文件，其中每条 API 响应都带
providerData.usage（inputTokens / outputTokens / totalTokens / 缓存命中）。
本脚本按「一次用户请求 = 一个任务」把其下所有 API 调用的 token 累加起来，
并标出该任务用的是哪个模型（这决定了烧的是谁的额度）。

用法（在本机 Git Bash / cmd 里）：
    python token_stat.py                  # 只统计今天 19:00 之后的全部会话
    python token_stat.py --all            # 统计全部历史
    python token_stat.py 2026-10-14 19:00 # 从指定时间点开始
    python token_stat.py 2026-10-14        # 统计某一天全天
"""
import json, os, sys, glob, datetime

sys.stdout.reconfigure(encoding="utf-8", errors="replace")

PROJ = r"C:\Users\123\.workbuddy\projects"   # ← 改成你本机 WorkBuddy 的 projects 目录


def iter_jsonl():
    for p in glob.glob(os.path.join(PROJ, "*", "*.jsonl")):
        yield p


def extract_query(o):
    c = o.get("content")
    if isinstance(c, list):
        full = "".join(str(b.get("text", "")) for b in c if isinstance(b, dict))
    else:
        full = str(c or "")
    if "<user_query>" in full:
        s = full.split("<user_query>")[1].split("</user_query>")[0]
    else:
        s = full.split("</system-reminder>")[-1]
    return s.strip().replace("\n", " ")[:34]


def load(path):
    """返回该文件里的任务列表。"""
    tasks, cur = [], None
    with open(path, encoding="utf-8") as fh:
        for line in fh:
            line = line.strip()
            if not line:
                continue
            try:
                o = json.loads(line)
            except Exception:
                continue
            pd = o.get("providerData") or {}
            if o.get("type") == "message" and o.get("role") == "user" and pd.get("startsNewUserRequest"):
                cur = {"file": os.path.basename(path)[:8], "dt": datetime.datetime.fromtimestamp(o["timestamp"] / 1000),
                       "q": extract_query(o), "n": 0, "in": 0, "out": 0, "tot": 0, "cache": 0, "mx": 0,
                       "mod": {}}
                tasks.append(cur)
            u = pd.get("usage")
            if u and cur:
                it = u.get("inputTokens", 0) or 0
                ot = u.get("outputTokens", 0) or 0
                cur["n"] += 1
                cur["in"] += it
                cur["out"] += ot
                cur["tot"] += u.get("totalTokens", 0) or 0
                cur["mx"] = max(cur["mx"], it)
                for d in (u.get("inputTokensDetails") or [{}]):
                    if isinstance(d, dict):
                        cur["cache"] += d.get("cached_tokens", 0) or 0
                m = pd.get("requestModelName") or pd.get("model") or "?"
                cur["mod"][m] = cur["mod"].get(m, 0) + 1
    return tasks


def main():
    args = [a for a in sys.argv[1:]]
    now = datetime.datetime.now()
    if "--all" in args:
        start, end = datetime.datetime(1970, 1, 1), now
    elif len(args) >= 2:
        start = datetime.datetime.strptime(args[0] + " " + args[1], "%Y-%m-%d %H:%M")
        end = now
    elif len(args) == 1:
        start = datetime.datetime.strptime(args[0], "%Y-%m-%d")
        end = start + datetime.timedelta(days=1)
    else:
        start = now.replace(hour=19, minute=0, second=0, microsecond=0)
        end = now

    alltasks = []
    for p in iter_jsonl():
        alltasks += load(p)
    post = sorted([t for t in alltasks if start <= t["dt"] < end], key=lambda t: t["dt"])

    print(f"统计窗口: {start:%Y-%m-%d %H:%M} → {end:%Y-%m-%d %H:%M}")
    print(f"{'时间':<6}|{'会':<9}|{'调用':>4}|{'输入合计':>11}|{'输出':>7}|{'合计':>11}|{'缓存命中':>11}|{'单次最大':>9}| 模型 | 任务")
    print("-" * 140)
    for t in post:
        mod = ",".join(f"{k}×{v}" for k, v in t["mod"].items())
        print(f"{t['dt']:%H:%M} |{t['file']:<9}|{t['n']:>4}|{t['in']:>11,}|{t['out']:>7,}|{t['tot']:>11,}|"
              f"{t['cache']:>11,}|{t['mx']:>9,}| {mod[:20]:<20} | {t['q']}")
    print("-" * 140)
    si = sum(t["in"] for t in post)
    so = sum(t["out"] for t in post)
    st = sum(t["tot"] for t in post)
    sc = sum(t["cache"] for t in post)
    if st:
        print(f"合计: 任务 {len(post)} 个 | API调用 {sum(t['n'] for t in post)} 次 | 输入 {si:,} | 输出 {so:,} | "
              f"总量 {st:,} | 缓存命中 {sc:,} ({sc/st*100:.0f}%) | 新输入 {si-sc:,}")
    else:
        print("窗口内没有数据。")

    # 按模型汇总
    per = {}
    for p in iter_jsonl():
        with open(p, encoding="utf-8") as fh:
            for line in fh:
                try:
                    o = json.loads(line)
                except Exception:
                    continue
                pd = o.get("providerData") or {}
                u = pd.get("usage")
                if not u:
                    continue
                dt = datetime.datetime.fromtimestamp(o["timestamp"] / 1000)
                if not (start <= dt < end):
                    continue
                m = pd.get("requestModelName") or pd.get("model") or "?"
                d = per.setdefault(m, {"n": 0, "tot": 0, "out": 0, "cache": 0})
                d["n"] += 1
                d["tot"] += u.get("totalTokens", 0) or 0
                d["out"] += u.get("outputTokens", 0) or 0
                for x in (u.get("inputTokensDetails") or [{}]):
                    if isinstance(x, dict):
                        d["cache"] += x.get("cached_tokens", 0) or 0
    print("\n按模型汇总:")
    for m, d in sorted(per.items(), key=lambda kv: -kv[1]["tot"]):
        print(f"  {m:<28} 调用{d['n']:>4} 次 | 总量 {d['tot']:>12,} | 输出 {d['out']:>8,} | 缓存 {d['cache']:>12,}")

    # 按会话汇总
    bysess = {}
    for t in post:
        d = bysess.setdefault(t["file"], {"tasks": 0, "n": 0, "tot": 0, "out": 0, "cache": 0, "mod": {}})
        d["tasks"] += 1
        d["n"] += t["n"]
        d["tot"] += t["tot"]
        d["out"] += t["out"]
        d["cache"] += t["cache"]
        for m, c in t["mod"].items():
            d["mod"][m] = d["mod"].get(m, 0) + c
    print("\n按会话汇总 (前8位ID):")
    for sid, d in sorted(bysess.items(), key=lambda kv: -kv[1]["tot"]):
        mm = ",".join(f"{k}×{v}" for k, v in sorted(d["mod"].items(), key=lambda kv: -kv[1]))
        print(f"  {sid:<10} 任务{d['tasks']:>3} 个 | 调用{d['n']:>4} 次 | 总量 {d['tot']:>12,} | "
              f"输出 {d['out']:>8,} | 缓存 {d['cache']:>12,} | {mm}")


if __name__ == "__main__":
    main()
```

跑出来那一刻我傻了——

- 时间跨度 **19:00 → 22:35**，仅 3.5 小时；
- **三个会话同时在跑**，合计 44 个任务、312 次 API 调用；
- 总消耗 **66,004,665 Token**，其中 **95% 命中了上下文缓存**（已经算省了）；
- 我自己的智谱 Key 主要喂给了"本对话"（约 2440 万）和"性格分析"（约 530 万）。

## 四、真正吃 Token 的两个元凶

**1. 多开并行是"超加法"**
你以为开两个话题是 1+1=2，实测是 1+1≥3。每个会话都要独立背着整段上下文反复调用 API，三个会话就是三倍上下文在同时往返。

**2. 上下文膨胀**
长对话里，上下文会从几万 Token 一路涨到 25 万+，而成本 ≈ **上下文大小 × 调用次数**。你每多说一句话，后面每一次工具调用，都要把前面那 25 万全部重发一遍。
![3.jpeg](https://developer.qcloudimg.com/http-save/yehe-12822470/120d5edc759ab59b5268d5b755cf89bd.png)
## 五、给你的省 Token 清单

- **别并行开多个重活会话**，能合并不一定拆；
- **长对话定期"另起新会话"清上下文**，比硬撑着聊到底划算；
- **善用缓存**：WorkBuddy 自带上下文缓存，命中就不重复计费（我那 95% 命中就是它的功劳）；
- **大文件/长视频先抽帧再喂**，别整段丢进去；
- **重度用户更要摸清自己的用量**，像上面这样定期拉日志对账，别等额度见底才反应过来。

## 六、结尾

算清这笔账，最大的收获不是省了多少，而是——

> AI 不会主动告诉你钱花哪了，得你自己把日志拉出来对账。WorkBuddy 的好处是，它连"查自己账"这种活都能帮你干。

如果你也想跑同款统计，上面那段脚本复制就能用，把 PROJ 路径改成你自己的就行。


前阵子我干了一件蠢事：以为自己只是"随便问问 AI"，结果绑定的智谱 API 免费额度（约 5000 万 Token）在 3.5 小时里被烧得干干净净。

# 我是怎么用 WorkBuddy 把 5000 万 Token 算清楚的（附自查脚本）

人工智能

AI办公省钱攻略：WorkBuddy用户亲述3.5小时烧光5000万Token的教训，揭秘多会话并行与上下文膨胀双重元凶，提供实用Token统计脚本与五大省Token技巧，助你精准控制AI调用成本。

代码解释

WorkBuddy 

Python

JSON

2026上云采购 | AI焕新·智启新局

workbuddy

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

# 我是怎么用 WorkBuddy 把 5000 万 Token 算清楚的（附自查脚本）-腾讯云开发者社区-腾讯云

# 我是怎么用 WorkBuddy 把 5000 万 Token 算清楚的（附自查脚本）

# 我是怎么用 WorkBuddy 把 5000 万 Token 算清楚的（附自查脚本）

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐