第 52.5 章：Token 经济学 — 每一个 Token 都在燃烧预算

// → 最简 token 估算器（保守估计，实际值通常在 80%-95% 之间）
function estimateTokens(text: string): number {
  // 英文/代码：按空格分词，每个词 ~1.3 token
  const englishWords = text.match(/[a-zA-Z0-9_]+/g)?.length ?? 0

  // 中文/日文/韩文：每个字符 ~0.6 token
  const cjkChars = text.match(/[一-鿿぀-ゟ゠-ヿ가-힯]/g)?.length ?? 0

  // 标点和空白：每两个字符 ~1 token
  const other = text.length - englishWords * 5 - cjkChars // 粗略估算

  return Math.ceil(englishWords * 1.3 + cjkChars * 0.6 + other * 0.5)
}

// 验证
console.log(estimateTokens("hello world"))                // ~3 (实际 2)
console.log(estimateTokens("你好世界"))                    // ~2 (实际 4)
console.log(estimateTokens("async function main() {}"))   // ~7 (实际 6)

// → src/context.ts (简化)
// 静态区（可缓存）：
//   - 角色定义、行为规则、Markdown 格式规范
//   - 工具列表的 name + description + input_schema
//
// --- SYSTEM_PROMPT_DYNAMIC_BOUNDARY ---
//
// 动态区（不可缓存）：
//   - 当前工作目录
//   - Git 状态
//   - 当前打开的文件
//   - CLAUDE.md 内容
//   - Memory 条目

// → 缓存预热：只写缓存，不生成回复
await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 0,  // 不生成内容
  system: [{
    type: "text",
    text: systemPromptStaticPart,
    cache_control: { type: "ephemeral" }
  }],
  tools: tools.map(t => ({
    ...t,
    cache_control: { type: "ephemeral" }
  })),
  messages: [{ role: "user", content: "ping" }]
})
// 这个请求的成本 = 缓存写入价格 (1.25×)，但 max_tokens:0 无输出成本

// → 模型选择决策树（你需要在卷五框架中实现类似逻辑）
function chooseModel(
  task: TaskType,
  complexity: "low" | "medium" | "high",
  budget: Budget
): ModelId {
  // 1. 预算受限 → 强制降级
  if (budget.dailyRemaining < OpusCostPerTask * 2) {
    if (budget.dailyRemaining < SonnetCostPerTask * 2) {
      return "haiku"  // 只有 Haiku 付得起了
    }
    return "sonnet"   // 至少用 Sonnet
  }

  // 2. 任务复杂度匹配
  switch (complexity) {
    case "low":
      // 读文件列表、检查 git status → Haiku 完全够
      return "haiku"
    case "medium":
      return "sonnet"
    case "high":
      return "opus"
  }

  // 3. 安全相关任务 → 永远用最强模型
  if (task.involvesSecurity || task.involvesAuth) {
    return "opus"
  }

  return "sonnet" // 默认
}

// 工具调用的 input 是 JSON
// { "city": "___" } —— 模型需要填城市名

// top_p=0.9：几乎只填 "北京"、"上海"、"深圳" 这些高概率城市
// top_p=1.0：可能填 "北𖠵"、"🜀" 等无效 token

// 评估配置：锁定采样参数以确保可复现
const evalConfig = {
  temperature: 0,       // 确定性输出
  top_p: 0.9,           // 截断长尾
  // 不用 top_k（与 top_p 互斥）
}

// → Agent 配置中加入采样参数
interface AgentSamplingConfig {
  temperature: number      // 0-1
  top_p: number            // 0-1
  top_k?: number           // 与 top_p 互斥，一般不设
}

// 每种任务类型的预设
const SAMPLING_PRESETS: Record<string, AgentSamplingConfig> = {
  "bug-fix":      { temperature: 0.1, top_p: 0.9 },
  "code-review":  { temperature: 0.0, top_p: 0.9 },
  "code-gen":     { temperature: 0.3, top_p: 0.95 },
  "brainstorm":   { temperature: 0.7, top_p: 1.0 },
  "default":       { temperature: 0.3, top_p: 0.95 },
}

// Agent 创建时根据任务类型自动选择
function createAgent(taskType: string): AgentLoop {
  const sampling = SAMPLING_PRESETS[taskType] ?? SAMPLING_PRESETS.default
  return new AgentLoop({ ...sampling, /* 其他配置 */ })
}

// 模式 1：固定预算 — 总消耗可预测
thinking: { type: "enabled", budget_tokens: 8000 }

// 模式 2：自适应 — 模型自己决定想多少
thinking: { type: "adaptive" }

// → src/cost-tracker.ts 的核心思路（简化重写）
class CostTracker {
  private sessions = new Map<string, SessionCost>()

  recordUsage(sessionId: string, usage: Usage, model: string) {
    const session = this.getOrCreate(sessionId)
    const price = MODEL_PRICES[model]

    const inputCost = (usage.input_tokens / 1_000_000) * price.input
    const cacheWriteCost = (usage.cache_creation_input_tokens / 1_000_000) * price.input * 1.25
    const cacheReadCost = (usage.cache_read_input_tokens / 1_000_000) * price.input * 0.10
    const outputCost = (usage.output_tokens / 1_000_000) * price.output

    session.totalCost += inputCost + cacheWriteCost + cacheReadCost + outputCost
    session.totalTokens.input += usage.input_tokens
    session.totalTokens.output += usage.output_tokens
    session.turns += 1
  }

  getSessionCost(sessionId: string): number {
    return this.sessions.get(sessionId)?.totalCost ?? 0
  }

  shouldWarn(sessionId: string, limit: number): boolean {
    return this.getSessionCost(sessionId) > limit * 0.8 // 超过 80% 告警
  }
}

// → 成本控制的三道防线
class CostController {
  constructor(
    private limits: {
      maxTokensPerTurn: number    // 单轮上限
      maxCostPerSession: number   // 会话上限
      maxTurnsPerTask: number     // 轮次上限
    }
  ) {}

  // 防线 1：调用前检查
  checkBeforeCall(agent: AgentLoop): boolean {
    if (agent.sessionCost > this.limits.maxCostPerSession * 0.9) {
      console.warn("⚠️ 会话成本即将达到上限，当前任务后将停止")
    }
    return agent.sessionCost < this.limits.maxCostPerSession
  }

  // 防线 2：调用后追踪
  trackAfterCall(agent: AgentLoop, usage: Usage): void {
    agent.sessionCost += this.computeCost(usage, agent.model)
    agent.turnCount += 1

    if (agent.turnCount > this.limits.maxTurnsPerTask) {
      throw new CostLimitExceeded("已超过最大轮次限制")
    }
  }

  // 防线 3：自动降级
  maybeDowngrade(agent: AgentLoop): ModelId {
    if (agent.sessionCost > this.limits.maxCostPerSession * 0.5) {
      return "haiku" // 后半程省钱
    }
    return agent.model
  }
}

// 你的 ApiClient 默认行为
const client = new ApiClient({
  apiKey: "...",
  enableCaching: true,  // 默认开启
  cacheWarmup: 3,       // 预期 3+ 轮时预热
})

const agent = framework.createAgent({
  model: "claude-sonnet-4-6",
  maxTokensPerTurn: 32_000,
  maxCostPerSession: 5.00,  // 单会话不超过 $5
  maxTurnsPerTask: 25,
})

// 不是所有工具都需要发给模型
// 按任务场景裁剪工具列表，减少缓存体积
const tools = router.getToolsForScenario("code-review") // 只带相关工具

// 不仅当 context > 阈值时触发
// 也要当 session 成本 > 一半预算时主动压缩
if (agent.sessionCost > agent.maxSessionCost * 0.5) {
  await agent.compact({ strategy: "aggressive" })
}

// → minimal-cost-tracker.ts
const MODEL_PRICES = {
  "claude-sonnet-4-6": { input: 3, output: 15 },
  "claude-haiku-4-5": { input: 0.80, output: 4 },
}

function computeCost(usage: { input_tokens: number; output_tokens: number; cache_read: number }, model: string) {
  const price = MODEL_PRICES[model]
  const inputCost = (usage.input_tokens / 1_000_000) * price.input
  const cacheReadCost = (usage.cache_read / 1_000_000) * price.input * 0.10
  const outputCost = (usage.output_tokens / 1_000_000) * price.output
  return inputCost + cacheReadCost + outputCost
}

// 测试
console.log(computeCost({ input_tokens: 45000, output_tokens: 3500, cache_read: 30000 }, "claude-sonnet-4-6"))
// 预期：约 $0.19