単価が40%下がっても、タスク単価は下がるとは限らない — Opus 4.8 から Sonnet 5 への移行損益をトークン消費プロファイルで測る

// consumption.ts — タスク単位の消費ベクトルを積み上げる
export interface ConsumptionVector {
  taskId: string;
  model: string;
  turns: number;            // API呼び出し回数（ツール往復を含む）
  inputTokens: number;      // 非キャッシュ入力
  outputTokens: number;
  cacheReadTokens: number;  // cache_read_input_tokens
  cacheWriteTokens: number; // cache_creation_input_tokens
  retries: number;          // 失敗→再実行した回数
  completed: boolean;       // 成功ゲートを通過したか
}
 
export function emptyVector(taskId: string, model: string): ConsumptionVector {
  return { taskId, model, turns: 0, inputTokens: 0, outputTokens: 0,
           cacheReadTokens: 0, cacheWriteTokens: 0, retries: 0, completed: false };
}
 
// 1ターンぶんの usage を加算する。usage が欠けたレスポンスは
// 「消費不明」として扱い、後段の集計から除外できるよう印を残す
export function addTurn(v: ConsumptionVector, usage: {
  input_tokens: number; output_tokens: number;
  cache_read_input_tokens?: number; cache_creation_input_tokens?: number;
}): ConsumptionVector {
  return {
    ...v,
    turns: v.turns + 1,
    inputTokens: v.inputTokens + usage.input_tokens,
    outputTokens: v.outputTokens + usage.output_tokens,
    cacheReadTokens: v.cacheReadTokens + (usage.cache_read_input_tokens ?? 0),
    cacheWriteTokens: v.cacheWriteTokens + (usage.cache_creation_input_tokens ?? 0),
  };
}

// paired-run.ts — 新旧モデルの並走計測
import { ConsumptionVector, emptyVector, addTurn } from "./consumption";
 
interface TaskSpec {
  id: string;
  run: (model: string, onUsage: (u: any) => void) => Promise<unknown>;
  succeeded: (result: unknown) => boolean; // 成功ゲート
  maxRetries: number;
}
 
export async function measureOnce(
  spec: TaskSpec, model: string
): Promise<ConsumptionVector> {
  let v = emptyVector(spec.id, model);
  for (let attempt = 0; attempt <= spec.maxRetries; attempt++) {
    if (attempt > 0) v = { ...v, retries: v.retries + 1 };
    try {
      const result = await spec.run(model, (usage) => { v = addTurn(v, usage); });
      if (spec.succeeded(result)) return { ...v, completed: true };
    } catch { /* 失敗はリトライ勘定に積んで継続 */ }
  }
  return v; // completed: false のまま返し、集計側で分けて扱う
}
 
// 同じ仕様を両モデルで N 回ずつ。到着順の偏りを避けるため交互に流す
export async function pairedRun(
  spec: TaskSpec, models: [string, string], n: number
): Promise<ConsumptionVector[]> {
  const out: ConsumptionVector[] = [];
  for (let i = 0; i < n; i++) {
    for (const m of models) out.push(await measureOnce(spec, m));
  }
  return out;
}

// break-even.ts — 移行を許容できる増分ターン数の逆算
interface Price { inPerMTok: number; outPerMTok: number; }
interface Shape { base: number; growthPerTurn: number; outPerTurn: number; }
 
function taskCost(p: Price, s: Shape, turns: number): number {
  const input = turns * s.base + s.growthPerTurn * (turns * (turns - 1)) / 2;
  const output = turns * s.outPerTurn;
  return (input * p.inPerMTok + output * p.outPerMTok) / 1e6;
}
 
// 旧モデル baselineTurns のコストを上限に、新モデルが並ぶターン数を探す
export function breakEvenTurns(
  oldP: Price, newP: Price, s: Shape, baselineTurns: number
): number {
  const ceiling = taskCost(oldP, s, baselineTurns);
  let lo = baselineTurns, hi = baselineTurns * 4;
  for (let i = 0; i < 40; i++) {
    const mid = (lo + hi) / 2;
    taskCost(newP, s, mid) < ceiling ? (lo = mid) : (hi = mid);
  }
  return lo;
}
 
const shape = { base: 3000, growthPerTurn: 1200, outPerTurn: 400 };
const opus = { inPerMTok: 5, outPerMTok: 25 };
console.log(breakEvenTurns(opus, { inPerMTok: 2, outPerMTok: 10 }, shape, 4)); // ≈ 7.6
console.log(breakEvenTurns(opus, { inPerMTok: 3, outPerMTok: 15 }, shape, 4)); // ≈ 5.7