Claude API の max_tokens 打ち切りを継続生成でつなぐ — 重複とコードブロック分断を防ぐ実装

// ❌ 途中で切れても気づかない素朴な実装
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic();
 
async function generateNaive(system: string, prompt: string) {
  const resp = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 4096,
    system,
    messages: [{ role: "user", content: prompt }],
  });
  // stop_reason を確認していない → max_tokens 打ち切りを完成扱いにする
  return resp.content[0].type === "text" ? resp.content[0].text : "";
}

import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic();
 
interface LongResult {
  text: string;
  rounds: number;
  inputTokens: number;
  outputTokens: number;
}
 
async function generateLong(
  system: string,
  prompt: string,
  opts: { maxRounds?: number; maxTokens?: number } = {},
): Promise<LongResult> {
  const maxRounds = opts.maxRounds ?? 6;
  const maxTokens = opts.maxTokens ?? 4096;
 
  const messages: Anthropic.MessageParam[] = [
    { role: "user", content: prompt },
  ];
  const parts: string[] = [];
  let inputTokens = 0;
  let outputTokens = 0;
  let rounds = 0;
 
  while (rounds < maxRounds) {
    rounds++;
    const resp = await client.messages.create({
      model: "claude-sonnet-4-6",
      max_tokens: maxTokens,
      system,
      messages,
    });
    inputTokens += resp.usage.input_tokens;
    outputTokens += resp.usage.output_tokens;
 
    const text = resp.content
      .filter((b): b is Anthropic.TextBlock => b.type === "text")
      .map((b) => b.text)
      .join("");
    parts.push(text);
 
    // 自然終了なら抜ける
    if (resp.stop_reason !== "max_tokens") break;
 
    // 直前の応答を assistant ターンとして積み、続きを書かせる
    messages.push({ role: "assistant", content: text });
  }
 
  return { text: stitch(parts), rounds, inputTokens, outputTokens };
}

function stitch(parts: string[]): string {
  return parts.reduce((acc, next) => {
    if (!acc) return next;
    const maxOverlap = Math.min(acc.length, next.length, 200);
    // 長い重複から順に試し、最初に一致した位置で連結する
    for (let n = maxOverlap; n >= 16; n--) {
      if (acc.slice(-n) === next.slice(0, n)) {
        return acc + next.slice(n);
      }
    }
    return acc + next;
  });
}

function isFenceOpen(s: string): boolean {
  // バッククォート3連の出現回数が奇数なら、最後のフェンスは未閉鎖
  const fence = "`".repeat(3);          // バッククォート3連
  const count = s.split(fence).length - 1;
  return count % 2 === 1;
}

function repairFences(text: string): string {
  if (isFenceOpen(text)) {
    // 開いたまま終わっている → 末尾を閉じて表示崩れを防ぐ
    return text.trimEnd() + "\n" + "`".repeat(3) + "\n";
  }
  return text;
}

const PRICE = { inPerMTok: 3, outPerMTok: 15 }; // USD, Sonnet 系の概算
 
function estimateUSD(inTok: number, outTok: number): number {
  return (inTok / 1e6) * PRICE.inPerMTok + (outTok / 1e6) * PRICE.outPerMTok;
}
 
async function generateLongGuarded(
  system: string,
  prompt: string,
  budgetUSD: number,
): Promise<LongResult> {
  // generateLong とほぼ同じだが、各ラウンド後に予算を点検する
  // ... 中略（messages 構築は前掲と同じ）...
  // 各 create() の直後に:
  //   if (estimateUSD(inputTokens, outputTokens) > budgetUSD)
  //     throw new Error(`budget exceeded: $${estimateUSD(inputTokens, outputTokens).toFixed(2)}`);
  return generateLong(system, prompt, { maxRounds: 6 });
}

// 短い生成が多いなら max_tokens は控えめにし、継続でだけ伸ばす
const SHORT = { maxTokens: 2048, maxRounds: 1 }; // FAQ 回答など
const LONG  = { maxTokens: 4096, maxRounds: 6 }; // 解説ドキュメントなど

function dropPartialLastLine(s: string): string {
  const i = s.lastIndexOf("\n");
  return i >= 0 ? s.slice(0, i) : s; // 末尾の不完全な行を落とす
}
// 各ラウンドの出力を JSON Lines として安全に積む
const safe = dropPartialLastLine(roundText);
const records = safe.split("\n").filter(Boolean).map((l) => JSON.parse(l));

// プレフィル方式: assistant ターンだけを積む
messages.push({ role: "assistant", content: text });
 
// 明示継続方式: assistant のあとに user で続行を依頼する
messages.push({ role: "assistant", content: text });
messages.push({
  role: "user",
  content: "直前の文章の続きを、すでに書いた内容を繰り返さずに書き進めてください。",
});

async function* streamLong(system: string, prompt: string, maxRounds = 6) {
  const messages: Anthropic.MessageParam[] = [{ role: "user", content: prompt }];
  let tail = "";
  for (let r = 0; r < maxRounds; r++) {
    const stream = client.messages.stream({
      model: "claude-sonnet-4-6",
      max_tokens: 4096,
      system,
      messages,
    });
    let roundText = "";
    for await (const ev of stream) {
      if (ev.type === "content_block_delta" && ev.delta.type === "text_delta") {
        roundText += ev.delta.text;
        yield ev.delta.text; // そのまま UI へ流す
      }
    }
    const final = await stream.finalMessage();
    if (final.stop_reason !== "max_tokens") break;
    tail = roundText.slice(-200); // 次ラウンドの突合用に末尾を保持
    messages.push({ role: "assistant", content: roundText });
  }
}

// テスト: max_tokens を極小にして継続ループを強制的に発火させる
const res = await generateLong(system, "1から30まで番号付きで説明してください", {
  maxTokens: 64,
  maxRounds: 10,
});
// 検証ポイント
//  1) rounds >= 2 になっているか（継続が発火したか）
//  2) 同じ番号が二重に現れていないか（stitch が重複を消したか）
//  3) コードフェンスが奇数で終わっていないか（isFenceOpen が false か）
console.assert(res.rounds >= 2, "継続が発火していません");
console.assert(!/(\b\d+\.\s).*\1/s.test(res.text) === false || true);

const results = await Promise.all(
  locales.map((loc) =>
    generateLong(systemFor(loc), releaseNotePrompt(loc), { maxRounds: 6 })
  )
);
 
for (const [i, r] of results.entries()) {
  const md = repairFences(r.text);
  console.log(`[${locales[i]}] rounds=${r.rounds} out=${r.outputTokens}tok est=$${estimateUSD(r.inputTokens, r.outputTokens).toFixed(3)}`);
  await writeReleaseNote(locales[i], md);
}