《互联网产品的 AI 架构·推理性能与成本工程》9.1 成本模型与隐形成本

计划显性 token = 51,940 微元
实际显性 token = 60,760 微元
缓存偏差       = +8,820 微元
计划总成本     = 73,180 微元
实际总成本     = 82,000 微元
实际 - 计划    = +8,820 微元

attempts      = successes + failedAfterInput + failedBeforeProvider
explicit      = successInput × (cachedShare × cachedPrice + (1 - cachedShare) × inputPrice)
              + successOutput × outputPrice
hidden        = failedToken + duplicateWaste + idle + transfer
total         = explicit + hidden
plannedTotal  = plannedExplicit + failedToken + duplicateWaste + idle + transfer
cacheVariance = explicit - plannedExplicit

// file: src/perf/cost.ts
// tier: L1
// verify: node --test test/perf/cost.test.ts

import { AiError } from "../core/errors.ts";

/** 价格卡统一用微元 / 百万 token，避免在累加过程中引入浮点误差。 */
export interface PriceCard {
  inputMicrosPerMTok: number;
  outputMicrosPerMTok: number;
  /** 缓存命中的输入单价；通常远低于全价输入。 */
  cachedInputMicrosPerMTok: number;
}

/** 一次账期内的尝试结构：成功、已产生输入后失败、尚未到达提供方就失败。 */
export interface AttemptMix {
  /** 业务请求数，不是尝试数。一个业务请求可能对应多次尝试。 */
  logicalRequests: number;
  /** 成功并计费的尝试数；可能大于业务请求数，代表重复成功。 */
  successes: number;
  /** 已经处理了部分或全部输入才失败的尝试，成本真实发生。 */
  failedAfterInput: number;
  /** 在网关侧就被拒绝的尝试，没有产生提供方成本。 */
  failedBeforeProvider: number;
  inputTokensPerAttempt: number;
  outputTokensPerSuccess: number;
}

export interface CachePlan {
  /** 容量与成本预估时假设的缓存命中比例。 */
  plannedCachedInputShare: number;
  /** 实际发生的缓存命中比例。 */
  actualCachedInputShare: number;
}

export interface CapacityPlan {
  /** 为峰值预留的容量成本，无论是否被用满都要付。 */
  reservedMicros: number;
  /** 预留容量的实际利用率，0 到 1。 */
  utilization: number;
}

export interface TransferPlan {
  /** 跨区传输的字节数，包含请求、响应与日志复制。 */
  bytes: number;
  microsPerGB: number;
  /** 同一份数据写到几个区域；1 表示不复制。 */
  replicas: number;
}

export interface CostScenario {
  price: PriceCard;
  attempts: AttemptMix;
  cache: CachePlan;
  capacity: CapacityPlan;
  transfer: TransferPlan;
}

export interface CostBreakdown {
  successInputTokens: number;
  successOutputTokens: number;
  /** 成功请求的显性 token 成本，已经按实际缓存命中率折算。 */
  successTokenMicros: number;
  /** 如果缓存命中率达到计划值，成功请求本应付出的 token 成本。 */
  plannedSuccessTokenMicros: number;
  failedInputTokens: number;
  /** 失败尝试已经发生的 token 成本，不会因为结果失败而退回。 */
  failedTokenMicros: number;
  /** 超过业务请求数的成功尝试，即同一请求被计费了两次。 */
  duplicateSuccesses: number;
  duplicateWasteMicros: number;
  /** 实际减计划的有符号差额；正数表示缓存未命中导致多付。 */
  cacheVarianceMicros: number;
  /** 只保留多付的部分，便于看板单列；它已经包含在 successTokenMicros 内。 */
  cacheMissMicros: number;
  /** 预留容量中未被使用的那一部分。 */
  idleMicros: number;
  transferMicros: number;
  explicitMicros: number;
  /** 成功 token 之外的实际成本：失败、重复成功、空闲容量与跨区传输。 */
  hiddenMicros: number;
  totalMicros: number;
  /** 按计划缓存命中率推算的总成本；与实际总成本之差即缓存偏差。 */
  plannedTotalMicros: number;
  costPerThousandSuccessMicros: number;
  costPerThousandLogicalMicros: number;
}

function fail(message: string): never {
  throw new AiError("invalid-request", `cost: ${message}`);
}

function integer(value: number, field: string, min = 0): number {
  if (!Number.isInteger(value) || value < min) fail(`${field} must be an integer >= ${min}`);
  return value;
}

function ratio(value: number, field: string): number {
  if (!Number.isFinite(value) || value < 0 || value > 1) fail(`${field} must be in [0, 1]`);
  return value;
}

/** 向上取整只发生在一次乘法之后，避免逐 token 舍入把成本放大。 */
export function tokenMicros(tokens: number, microsPerMTok: number): number {
  integer(tokens, "tokens");
  integer(microsPerMTok, "microsPerMTok");
  if (tokens === 0 || microsPerMTok === 0) return 0;
  return Math.ceil((tokens * microsPerMTok) / 1_000_000);
}

/** 输入成本拆成缓存命中与未命中两段，分别套用不同单价。 */
export function cachedInputMicros(inputTokens: number, cachedShare: number, price: PriceCard): number {
  integer(inputTokens, "inputTokens");
  ratio(cachedShare, "cachedShare");
  const cachedTokens = Math.round(inputTokens * cachedShare);
  return (
    tokenMicros(cachedTokens, price.cachedInputMicrosPerMTok) +
    tokenMicros(inputTokens - cachedTokens, price.inputMicrosPerMTok)
  );
}

/** 跨区传输按 GB 计价，字节先换算成 GB 再向上取整。 */
export function transferMicros(bytes: number, microsPerGB: number, replicas = 1): number {
  integer(bytes, "bytes");
  integer(microsPerGB, "microsPerGB");
  integer(replicas, "replicas", 1);
  if (bytes === 0 || microsPerGB === 0) return 0;
  return Math.ceil((bytes * microsPerGB * replicas) / 1_000_000_000);
}

/**
 * 成本模型把“显性 token 成本”和四类隐藏成本分开：
 * 失败尝试、重复成功、缓存未命中、空闲容量与跨区传输。
 * 所有金额都是整数微元，可逐项相加并与账单对齐。
 */
export function estimateCost(scenario: CostScenario): CostBreakdown {
  const { price, attempts, cache, capacity, transfer } = scenario;
  integer(price.inputMicrosPerMTok, "price.inputMicrosPerMTok");
  integer(price.outputMicrosPerMTok, "price.outputMicrosPerMTok");
  integer(price.cachedInputMicrosPerMTok, "price.cachedInputMicrosPerMTok");
  if (price.cachedInputMicrosPerMTok > price.inputMicrosPerMTok) {
    fail("cached input price must not exceed full input price");
  }

  integer(attempts.logicalRequests, "attempts.logicalRequests", 1);
  integer(attempts.successes, "attempts.successes");
  integer(attempts.failedAfterInput, "attempts.failedAfterInput");
  integer(attempts.failedBeforeProvider, "attempts.failedBeforeProvider");
  integer(attempts.inputTokensPerAttempt, "attempts.inputTokensPerAttempt");
  integer(attempts.outputTokensPerSuccess, "attempts.outputTokensPerSuccess");
  ratio(cache.plannedCachedInputShare, "cache.plannedCachedInputShare");
  ratio(cache.actualCachedInputShare, "cache.actualCachedInputShare");
  integer(capacity.reservedMicros, "capacity.reservedMicros");
  ratio(capacity.utilization, "capacity.utilization");

  const successInputTokens = attempts.successes * attempts.inputTokensPerAttempt;
  const successOutputTokens = attempts.successes * attempts.outputTokensPerSuccess;
  const successTokenMicros =
    cachedInputMicros(successInputTokens, cache.actualCachedInputShare, price) +
    tokenMicros(successOutputTokens, price.outputMicrosPerMTok);

  const failedInputTokens = attempts.failedAfterInput * attempts.inputTokensPerAttempt;
  const failedTokenMicros = cachedInputMicros(failedInputTokens, cache.actualCachedInputShare, price);

  const duplicateSuccesses = Math.max(0, attempts.successes - attempts.logicalRequests);
  const duplicateWasteMicros =
    cachedInputMicros(
      duplicateSuccesses * attempts.inputTokensPerAttempt,
      cache.actualCachedInputShare,
      price,
    ) + tokenMicros(duplicateSuccesses * attempts.outputTokensPerSuccess, price.outputMicrosPerMTok);

  const plannedSuccessTokenMicros =
    cachedInputMicros(successInputTokens, cache.plannedCachedInputShare, price) +
    tokenMicros(successOutputTokens, price.outputMicrosPerMTok);
  const cacheVarianceMicros = successTokenMicros - plannedSuccessTokenMicros;
  const cacheMissMicros = Math.max(0, cacheVarianceMicros);

  const idleMicros = Math.ceil(capacity.reservedMicros * (1 - capacity.utilization));
  const transferCostMicros = transferMicros(transfer.bytes, transfer.microsPerGB, transfer.replicas);

  const explicitMicros = successTokenMicros;
  const hiddenMicros = failedTokenMicros + duplicateWasteMicros + idleMicros + transferCostMicros;
  const totalMicros = explicitMicros + hiddenMicros;

  return {
    successInputTokens,
    successOutputTokens,
    successTokenMicros,
    plannedSuccessTokenMicros,
    failedInputTokens,
    failedTokenMicros,
    duplicateSuccesses,
    duplicateWasteMicros,
    cacheVarianceMicros,
    cacheMissMicros,
    idleMicros,
    transferMicros: transferCostMicros,
    explicitMicros,
    hiddenMicros,
    totalMicros,
    plannedTotalMicros:
      plannedSuccessTokenMicros + failedTokenMicros + duplicateWasteMicros + idleMicros + transferCostMicros,
    costPerThousandSuccessMicros:
      attempts.successes === 0 ? 0 : Math.ceil((totalMicros * 1000) / attempts.successes),
    costPerThousandLogicalMicros: Math.ceil(
      (totalMicros * 1000) / attempts.logicalRequests,
    ),
  };
}

/** 把总成本按成功请求数摊开，回答“每次可用结果到底花了多少”。 */
export function effectiveCostPerSuccessMicros(breakdown: CostBreakdown): number {
  return breakdown.costPerThousandSuccessMicros / 1000;
}

node --test test/perf/cost.test.ts

ℹ tests 11
ℹ pass 11
ℹ fail 0
ℹ duration_ms 207.575667