成本与性能管理 —— Token 监控、Stats 统计与成本控制

系列: AI Agent 实战笔记日期: 2026-05-22 标签: OpenCode, 成本控制, Token 监控, 性能优化难度: ⭐⭐⭐

简介

在前面的文章中，我们已经掌握了 OpenCode 的 MCP 集成能力，让 Agent 可以连接无限的外部工具和服务。但随着使用场景的扩展，一个现实问题浮出水面：

AI Agent 的运行成本，到底是多少？

你可能遇到过这些情况：

一次简单的代码审查消耗了数万 Token
长时间运行的 Agent 会话不知不觉花了几十美元
不知道哪些任务最烧钱，哪些模型最划算
团队多人使用时，成本完全不可控

这些都是真实存在的问题。AI Agent 的强大能力背后是实实在在的 Token 消耗和账单。

不懂成本管理的 Agent 使用，就像开着一辆没有油表的跑车——你不知道什么时候会耗尽预算。

本文将系统讲解 OpenCode 的成本与性能管理：

opencode stats：内置统计命令的完整使用指南
Token 监控：实时监控、历史分析、趋势预测
成本控制：预算设置、告警策略、自动限制
性能优化：模型选择、上下文管理、缓存策略
团队成本管理：多人协作场景下的成本控制方案

一、opencode stats 命令详解

1.1 基本用法

OpenCode 内置了 stats 命令，让你快速了解 Token 消耗和成本情况：

bash

# 查看当前 Session 的统计信息
$ opencode stats

# 输出示例：
# ═══════════════════════════════════════
#  Session Statistics
# ═══════════════════════════════════════
#
#  Model: claude-sonnet-4-20250514
#  Provider: anthropic
#  Duration: 12m 34s
#  Turns: 15
#
#  ┌─────────────────┬──────────┬──────────┐
#  │ Token Type      │ Count    │ Cost     │
#  ├─────────────────┼──────────┼──────────┤
#  │ Input Tokens    │ 128,450  │ $0.385   │
#  │ Output Tokens   │ 12,340   │ $0.185   │
#  │ Cache Read      │ 45,200   │ $0.034   │
#  │ Cache Creation  │ 18,900   │ $0.038   │
#  ├─────────────────┼──────────┼──────────┤
#  │ Total           │ 204,890  │ $0.642   │
#  └─────────────────┴──────────┴──────────┘
#
#  Average tokens/turn: 13,659
#  Average cost/turn: $0.043
#  Average response time: 2.3s

1.2 统计字段说明

字段	含义	说明
Input Tokens	输入 Token 数	发送给模型的上下文 Token（包含系统提示、历史消息、工具结果等）
Output Tokens	输出 Token 数	模型生成的回复 Token
Cache Read	缓存读取	从 Prompt Cache 中命中的 Token（成本大幅降低）
Cache Creation	缓存创建	新写入 Prompt Cache 的 Token（有写入成本）
Duration	会话持续时间	从开始到当前的时间
Turns	对话轮数	用户-Agent 交互的回合数
Average tokens/turn	每轮平均 Token	帮助判断上下文是否膨胀
Average cost/turn	每轮平均成本	帮助评估任务的成本效益

1.3 不同视角的统计

bash

# 查看历史所有 Session 的汇总统计
$ opencode stats --all

# 按日期范围查看
$ opencode stats --since "2026-05-20" --until "2026-05-22"

# 按模型分组统计
$ opencode stats --group-by model

# 输出示例：
# ═══════════════════════════════════════════════
#  Cost by Model (Last 3 days)
# ═══════════════════════════════════════════════
#
#  ┌──────────────────────────────┬─────────┬──────────┬──────────┐
#  │ Model                        │ Sessions│ Tokens   │ Cost     │
#  ├──────────────────────────────┼─────────┼──────────┼──────────┤
#  │ claude-sonnet-4-20250514     │ 12      │ 1.2M     │ $3.84    │
#  │ claude-opus-4-20250514       │ 3       │ 450K     │ $4.50    │
#  │ gpt-4.1                      │ 8       │ 800K     │ $2.40    │
#  │ gemini-2.5-pro               │ 5       │ 600K     │ $1.80    │
#  ├──────────────────────────────┼─────────┼──────────┼──────────┤
#  │ Total                        │ 28      │ 3.05M    │ $12.54   │
#  └──────────────────────────────┴─────────┴──────────┴──────────┘

1.4 JSON 格式输出

便于脚本处理和集成到监控系统：

bash

# 导出为 JSON
$ opencode stats --json

# 输出：
{
  "session_id": "abc123def456",
  "model": "claude-sonnet-4-20250514",
  "provider": "anthropic",
  "start_time": "2026-05-22T10:00:00Z",
  "duration_seconds": 754,
  "turns": 15,
  "tokens": {
    "input": 128450,
    "output": 12340,
    "cache_read": 45200,
    "cache_create": 18900,
    "total": 204890
  },
  "cost": {
    "input": 0.385,
    "output": 0.185,
    "cache_read": 0.034,
    "cache_create": 0.038,
    "total": 0.642,
    "currency": "USD"
  },
  "performance": {
    "avg_response_time_ms": 2300,
    "p50_response_time_ms": 1800,
    "p95_response_time_ms": 4500,
    "p99_response_time_ms": 8200
  }
}

二、Token 监控

2.1 实时监控

在 TUI 中，OpenCode 会实时显示当前会话的 Token 使用情况：

text

┌─────────────────────────────────────────┐
│ 📊 Session Monitor                      │
├─────────────────────────────────────────┤
│ Model: claude-sonnet-4-20250514         │
│ Turns: 8       Duration: 5m 12s        │
│                                         │
│ Input Tokens:    ████████░░  67,200     │
│ Output Tokens:   ████░░░░░░  8,450      │
│ Cache Hit Rate:  █████████░  72%        │
│                                         │
│ Current Cost: $0.218                    │
│ Avg per turn: $0.027                    │
└─────────────────────────────────────────┘

2.2 Token 消耗趋势分析

通过历史数据，你可以分析 Token 消耗的趋势：

bash

# 生成每日消耗报告
$ opencode stats --daily --since "2026-05-01"

# 输出示例：
# Daily Token Consumption
# ┌────────────┬──────────┬──────────┬──────────┐
# │ Date       │ Tokens   │ Cost     │ Sessions │
# ├────────────┼──────────┼──────────┼──────────┤
# │ 2026-05-20 │ 1.2M     │ $3.84    │ 8        │
# │ 2026-05-21 │ 2.1M     │ $6.72    │ 15       │
# │ 2026-05-22 │ 890K     │ $2.85    │ 6        │
# ├────────────┼──────────┼──────────┼──────────┤
# │ Total      │ 4.19M    │ $13.41   │ 29       │
# │ Avg/Day    │ 1.40M    │ $4.47    │ 9.7      │
# └────────────┴──────────┴──────────┴──────────┘

2.3 识别 Token 消耗热点

哪些任务最烧钱？通过 stats 可以一目了然：

bash

# 按任务类型统计成本
$ opencode stats --group-by task-type

# 输出示例：
# ┌─────────────────────┬──────────┬──────────┬──────────┐
# │ Task Type           │ Sessions │ Tokens   │ Cost     │
# ├─────────────────────┼──────────┼──────────┼──────────┤
# │ PR Review           │ 45       │ 2.1M     │ $6.72    │
# │ Code Generation     │ 32       │ 4.5M     │ $14.40   │
# │ Refactoring         │ 18       │ 1.8M     │ $5.76    │
# │ Bug Investigation   │ 25       │ 3.2M     │ $10.24   │
# │ Documentation       │ 12       │ 0.8M     │ $2.56    │
# │ Code Review         │ 38       │ 1.5M     │ $4.80    │
# └─────────────────────┴──────────┴──────────┴──────────┘

关键发现：Code Generation 虽然 Session 数不是最多，但 Token 消耗和成本都是最高的。这是因为代码生成任务通常需要：

大量的上下文输入（项目结构、现有代码、依赖关系）
较长的输出（完整的新代码文件）
多轮迭代（生成 → 审查 → 修改）

2.4 缓存命中率监控

Prompt Cache 是降低成本的关键。监控缓存命中率：

bash

$ opencode stats --cache-analysis

# 输出示例：
# ┌──────────────────────┬──────────┬──────────┬──────────┐
# │ Metric               │ Value    │ Savings  │ Rate     │
# ├──────────────────────┼──────────┼──────────┼──────────┤
# │ Cache Read Tokens    │ 4.2M     │ $12.60   │          │
# │ Cache Create Tokens  │ 1.8M     │          │          │
# │ Total Input Tokens   │ 12.5M    │          │          │
# │ Cache Hit Rate       │          │          │ 33.6%    │
# │ Total Cache Savings  │          │ $12.60   │          │
# └──────────────────────┴──────────┴──────────┴──────────┘

优化建议：

缓存命中率低于 30% 说明你的会话模式可能不够稳定
保持稳定的系统提示和项目上下文可以提高缓存命中率
频繁切换模型会导致缓存失效（不同模型的缓存是独立的）

三、成本控制策略

3.1 设置预算上限

在 settings.json 中配置预算限制：

json

{
  "budget": {
    "daily_limit": 10.00,
    "monthly_limit": 200.00,
    "per_session_limit": 5.00,
    "per_request_limit": 2.00,
    "currency": "USD",
    "action_on_limit": "warn"
  }
}

action_on_limit 选项：

选项	行为
`warn`	达到限制时发出警告，但继续运行
`soft_stop`	达到限制后拒绝新的请求，但允许当前请求完成
`hard_stop`	达到限制后立即终止，当前请求也会被中断

3.2 告警配置

json

{
  "budget": {
    "daily_limit": 10.00,
    "alerts": [
      {
        "threshold_percent": 50,
        "message": "⚠️ 今日已使用 50% 的预算（$5.00/$10.00）"
      },
      {
        "threshold_percent": 80,
        "message": "🔴 今日已使用 80% 的预算（$8.00/$10.00），请谨慎使用"
      },
      {
        "threshold_percent": 100,
        "message": "🛑 今日预算已用完，新的请求将被拒绝"
      }
    ]
  }
}

3.3 模型成本对比

了解不同模型的成本差异是成本控制的第一步：

bash

# 查看支持的模型及其成本
$ opencode models --show-cost

# 输出示例：
# ┌─────────────────────────────────────┬───────────┬───────────┬──────────┐
# │ Model                               │ Input/1M  │ Output/1M │ Cache/1M │
# ├─────────────────────────────────────┼───────────┼───────────┼──────────┤
# │ claude-opus-4-20250514              │ $15.00    │ $75.00    │ $1.50    │
# │ claude-sonnet-4-20250514            │ $3.00     │ $15.00    │ $0.30    │
# │ claude-haiku-3-20241022             │ $0.80     │ $4.00     │ $0.08    │
# │ gpt-4.1                             │ $2.00     │ $8.00     │ $0.50    │
# │ gpt-4.1-mini                        │ $0.40     │ $1.60     │ $0.10    │
# │ gpt-4.1-nano                        │ $0.10     │ $0.40     │ $0.025   │
# │ gemini-2.5-pro                      │ $1.25     │ $10.00    │ $0.31    │
# └─────────────────────────────────────┴───────────┴───────────┴──────────┘

关键洞察：Opus 的成本是 Sonnet 的 5 倍，是 Haiku 的 18.75 倍。合理选择模型可以大幅降低成本。

3.4 自动模型路由

OpenCode 支持根据任务复杂度自动选择模型：

json

{
  "model_routing": {
    "enabled": true,
    "rules": [
      {
        "task_type": "simple_edit",
        "model": "gpt-4.1-nano",
        "description": "简单的代码编辑、格式修复"
      },
      {
        "task_type": "code_review",
        "model": "claude-sonnet-4-20250514",
        "description": "代码审查、PR review"
      },
      {
        "task_type": "architecture",
        "model": "claude-opus-4-20250514",
        "description": "架构设计、复杂重构"
      },
      {
        "task_type": "default",
        "model": "claude-sonnet-4-20250514",
        "description": "默认模型"
      }
    ]
  }
}

这种方式确保简单任务用便宜的模型，复杂任务才调用高级模型，实现成本最优。

四、性能优化

4.1 上下文管理

上下文膨胀是 Token 浪费的主要原因之一：

bash

# ❌ 不好的做法：每次加载整个项目
$ opencode run --prompt "修复 bug" --context **/*

# ✅ 好的做法：只加载相关文件
$ opencode run --prompt "修复 auth 模块的 bug" \
  --context src/auth/*.ts \
  --context tests/auth/*.test.ts

上下文优化建议：

精确引用文件：只加载与任务相关的文件，而不是整个目录
使用 @ 符号引用：在 TUI 中使用 @filename 精准加载特定文件
定期清理会话：长时间运行的会话会积累大量上下文，适时开启新会话
利用代码搜索：让 Agent 使用 grep/search 工具定位相关代码，而非全部加载

4.2 减少不必要的轮次

每次用户-Agent 交互都会产生新的 Token 消耗：

bash

# ❌ 多轮低效对话
$ opencode run --prompt "读取 main.go 文件"
$ opencode run --prompt "找到数据库连接部分"
$ opencode run --prompt "改成使用连接池"

# ✅ 一轮完整指令
$ opencode run --prompt "
  读取 main.go 文件中的数据库连接部分，
  将其改造为使用连接池模式。
  要求：
  1. 使用 pgxpool 替代单连接
  2. 最大连接数设为 20
  3. 最小空闲连接数设为 5
  4. 连接超时设为 30 秒
"

4.3 Prompt Cache 优化

最大化利用 Prompt Cache 可以显著降低成本：

json

{
  "cache_settings": {
    "enabled": true,
    "strategy": "auto",
    "prefix_stability": "high"
  }
}

Cache 优化策略：

保持系统提示稳定：频繁修改系统提示会导致缓存失效
项目结构作为前缀：将项目结构信息放在上下文前面，因为它很少变化
避免中间插入：在稳定上下文和可变上下文之间插入内容会破坏缓存

4.4 批量任务优化

bash

# ❌ 逐个文件处理（每次都是完整的上下文 + 响应）
$ opencode run --prompt "修复 file1.go 中的 lint 问题"
$ opencode run --prompt "修复 file2.go 中的 lint 问题"
$ opencode run --prompt "修复 file3.go 中的 lint 问题"

# ✅ 批量处理（一次加载上下文，处理所有文件）
$ opencode run --prompt "
  修复以下文件中的所有 lint 问题：
  - file1.go
  - file2.go
  - file3.go

  对每个文件单独修改，保持其他文件不变。
"

4.5 响应时间优化

bash

# 查看各模型的响应时间
$ opencode stats --performance

# 输出示例：
# ┌─────────────────────────────────────┬─────────┬─────────┬─────────┐
# │ Model                               │ Avg(ms) │ P50(ms) │ P95(ms) │
# ├─────────────────────────────────────┼─────────┼─────────┼─────────┤
# │ claude-sonnet-4-20250514            │ 2,340   │ 1,800   │ 4,500   │
# │ gpt-4.1                             │ 1,850   │ 1,200   │ 3,800   │
# │ gpt-4.1-mini                        │ 980     │ 750     │ 1,800   │
# │ gemini-2.5-pro                      │ 3,200   │ 2,500   │ 6,100   │
# │ claude-haiku-3-20241022             │ 650     │ 500     │ 1,200   │
# └─────────────────────────────────────┴─────────┴─────────┴─────────┘

对于对延迟敏感的场景（如交互式编码），可以考虑使用更快的模型。

五、团队成本管理

5.1 团队预算分配

json

{
  "team_budget": {
    "enabled": true,
    "total_monthly": 500.00,
    "per_member_daily": 15.00,
    "shared_pool": 200.00,
    "rollover": false
  }
}

5.2 成本报告自动化

bash

# 生成每周成本报告
$ opencode stats --weekly-report --format markdown > weekly-cost.md

# 集成到 CI/CD 管道
# 在 GitHub Actions 中定期运行
# name: Weekly Cost Report
# on:
#   schedule:
#     - cron: '0 9 * * MON'
# jobs:
#   cost-report:
#     runs-on: ubuntu-latest
#     steps:
#       - uses: actions/checkout@v4
#       - run: opencode stats --weekly --json > cost-report.json
#       - run: node generate-report.js
#       - uses: peter-evans/create-issue-from-file@v5
#         with:
#           title: "Weekly AI Cost Report"
#           content-filepath: ./weekly-cost.md

5.3 成本分摊与审计

bash

# 按用户统计成本
$ opencode stats --group-by user --since "2026-05-01"

# 按项目统计成本
$ opencode stats --group-by project --since "2026-05-01"

# 导出 CSV 用于进一步分析
$ opencode stats --csv --since "2026-05-01" > cost-export.csv

六、实用成本优化清单

日常检查清单

使用 opencode stats 定期查看成本
检查缓存命中率，目标 > 50%
审视模型选择，简单任务是否用了过贵的模型
检查是否有长时间运行且成本异常高的会话
确认预算限制和告警已配置

月度优化清单

分析成本趋势，识别异常波动
评估各任务类型的成本效益
更新模型路由规则
审查团队成员的使用模式
调整预算上限

快速省钱技巧

技巧	预估节省	实施难度
开启 Prompt Cache	20-40%	低
使用 Haiku 处理简单任务	30-50%	低
精确控制上下文范围	15-25%	中
批量处理相似任务	10-20%	低
减少不必要的对话轮次	10-15%	中
设置预算上限和告警	防止超支	低

总结

本文系统讲解了 OpenCode 的成本与性能管理：

opencode stats 是核心工具，支持多视角、多格式的统计查询
Token 监控帮助你实时了解消耗情况，识别热点和优化空间
成本控制通过预算限制、告警和自动模型路由实现精细化管控
性能优化涵盖上下文管理、轮次减少、缓存利用和批量处理
团队成本管理提供预算分配、自动化报告和审计能力

核心原则：成本管理不是要限制 AI Agent 的能力，而是要让每一分投入都产生最大价值。好的成本管理策略可以让你的 Agent 使用成本降低 50% 以上，同时不损失任何效率。

成本控制到位了，但还有一个关键问题：你的 AI Agent 安全吗？ 在《安全与权限》中，我们将深入 OpenCode 的安全体系：

沙箱边界：文件系统隔离、网络访问控制、进程限制
命令审批：哪些命令需要人工确认、如何配置审批规则
安全策略：最小权限原则、敏感数据保护、代码执行策略
审计日志：操作追踪、合规报告、异常检测