🎯 今日核心问题

  1. 模型的账单为什么和「token 数 × 单价」算出来的差一截?差额来自哪三类 token?
  2. 缓存命中的输入和缓存未命中的输入,同一个 prompt 里价格差 10 倍,怎么分开计?
  3. 一次典型工单任务到底花多少钱?把这个数算到小数点后四位。

📖 精读提纲

【一】计价公式:三段式,不是两段式

单价表上通常有三个数:输入价、输出价、缓存命中输入价。所以一次调用的真实成本是:

cost = (uncachedInputTokens × P_in + cachedInputTokens × P_cache + outputTokens × P_out) / 1_000_000

注意三个陷阱。第一,输出单价通常是输入的 4 倍,所以「让模型回答得啰嗦」比「给它更多上下文」贵得多——一个 800 token 的答复和 200 token 的答复,成本差 3 倍。第二,缓存只对前缀生效,Prompt 里一旦把可变内容(时间戳、用户问题)放在前面,缓存永远命中不了。第三,推理型模型的思考 token 也计费且算输出,账单上常有一项 reasoning_tokens,很贵。

【二】真实算式:一次售后工单任务

取一个真实可复现的场景:用户问「我的订单 A20261208001 显示已发货但三天没物流,能退款吗」。Agent 跑 3 轮 ReAct,调用 2 个工具。

单价比照主流中档模型的公开价(每百万 token,美元):输入 $0.30、缓存命中输入 $0.03、输出 $1.20。

汇总:未缓存输入 640+380+520 = 1540,缓存输入 1200+1840+2220 = 5260,输出 90+60+320 = 470。

cost = (1540  × 0.30 + 5260 × 0.03 + 470 × 1.20) / 1_000_000
     = (0.462     + 0.1578    + 0.564) / 1000
     = 1.1838 / 1000
     = $0.001184  ≈ 0.0085 元(按 7.2 汇率)

若未做缓存: (1540+5260) × 0.30 = 2.04 → 总 2.604 / 1000 = $0.002604
缓存把这次调用降了 54.5%。

再算单量:一天 2 万次工单任务 → 日成本 $23.68,月成本约 $710(≈ 5100 元)。这个数字才是有意义的经营指标,而不是「每百万 token 多少钱」。

【三】把计价做成代码,而不是 Excel

Excel 对不上账的原因永远是「token 数来源不一致」:你在估算,而模型供应商在按自己的分词器算中文。正确做法是以 API 响应里的 usage 字段为准,不要自己 tiktoken 估算;只有在做容量规划时才用估算。

价格要版本化、要能按日期切换——供应商调价、模型换代时,历史报表必须仍按当时的价格复算。所以价格表应该是带 effectiveFrom 的配置,而不是一个常量。

【四】常见误区

💻 代码示例

定价表 + 计价器:支持按日期取价、微美元整数、缓存分档:

public record ModelPrice(String model, LocalDate effectiveFrom,
                         long inputMicroUsdPerMillion,
                         long cachedInputMicroUsdPerMillion,
                         long outputMicroUsdPerMillion) {

    /** 每百万 token 的微美元价,$0.30/M = 300000 微美元/M */
    public static final List<ModelPrice> CATALOG = List.of(
            new ModelPrice("model-large",  LocalDate.of(2026, 1, 1),  3_000_000, 300_000, 15_000_000),
            new ModelPrice("model-medium", LocalDate.of(2026, 1, 1),    300_000,  30_000,  1_200_000),
            new ModelPrice("model-small",  LocalDate.of(2026, 1, 1),     80_000,   8_000,    240_000));
}

@Component
public class CostCalculator {

    private final Map<String, NavigableMap<LocalDate, ModelPrice>> byModel = new HashMap<>();

    public CostCalculator() {
        for (ModelPrice p : ModelPrice.CATALOG) {
            byModel.computeIfAbsent(p.model(), k -> new TreeMap<>()).put(p.effectiveFrom(), p);
        }
    }

    public ModelPrice priceAt(String model, LocalDate date) {
        Map.Entry<LocalDate, ModelPrice> e = byModel.getOrDefault(model, new TreeMap<>())
                .floorEntry(date);
        if (e == null) throw new IllegalStateException("no price for model " + model);
        return e.getValue();
    }

    /** 返回微美元整数 */
    public long costMicroUsd(String model, LocalDate date, long input, long cachedInput, long output) {
        ModelPrice p = priceAt(model, date);
        if (cachedInput > input) throw new IllegalArgumentException("cached > input");
        long uncached = input - cachedInput;
        long usdMicro = (uncached * p.inputMicroUsdPerMillion()
                + cachedInput * p.cachedInputMicroUsdPerMillion()
                + output * p.outputMicroUsdPerMillion()) / 1_000_000L;
        return usdMicro;
    }
}

接到上一节的 LoggedChatClient 里,每次调用就记账一次(含失败重试):

Usage u = resp.usage();
long cost = costCalculator.costMicroUsd(
        req.model(), LocalDate.now(),
        u.promptTokens(), u.cachedTokens(), u.completionTokens());

ledger.append(new TokenLedger.Entry(
        traceId, req.model(), u.promptTokens(), u.cachedTokens(), u.completionTokens(), cost));

counter("agent.cost.microusd", "model", req.model()).increment(cost);

log.atInfo().addKeyValue("model", req.model())
   .addKeyValue("in", u.promptTokens()).addKeyValue("cached", u.cachedTokens())
   .addKeyValue("out", u.completionTokens()).addKeyValue("costMicroUsd", cost)
   .log("cost.booked");

一个能自证的单元测试,把上面的手算过程固化成断言(含缓存节省率):

@Test
void typicalTicketTaskCost() {
    // 三次调用聚合:未缓存输入 1540、缓存输入 5260、输出 470
    long c = calc.costMicroUsd("model-medium", LocalDate.of(2026, 12, 11), 1540 + 5260, 5260, 470);
    assertThat(c).isEqualTo(1184L);            // $0.001184

    long noCache = calc.costMicroUsd("model-medium", LocalDate.of(2026, 12, 11), 1540 + 5260, 0, 470);
    assertThat((double) c / noCache).isLessThan(0.5);   // 缓存省掉一半以上

    // 放大到日/月量级
    assertThat(c * 20_000L).isEqualTo(23_680_000L);      // 日 $23.68
}

✏️ 今日动手

从线上捞 100 条 trace 的 usage,用 jq 汇总三列 token,套用上面的公式算出真实单次成本,再和你直觉里的估算比一比。然后做一件更有价值的事:把这 100 条按「输出 token 数」排序,看前 10% 的请求吃掉了多少总成本——通常会看到 40% 以上的成本集中在 10% 的请求上,这 10% 就是明天优化的靶子。

🔖 明日预告

算清了钱花在哪,明天开始省:模型降级(什么任务配什么模型)、语义缓存(命中率与风险的平衡)、Prompt 瘦身(从 1840 token 压到 700)。三招叠加,实地把单次成本压到三分之一。