予約実行が始まる前に、使うモデルが本当に応答するか1回だけ確かめる

import Anthropic from "@anthropic-ai/sdk";
 
const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
 
type Ineligibility = "retired" | "withdrawn" | "restricted" | "transient";
 
interface ProbeResult {
  model: string;
  ok: boolean;
  reason?: Ineligibility;
  detail?: string;
}
 
// API が返したエラーを「使えない」の3分類＋一時障害に振り分ける
function classify(err: unknown): Ineligibility {
  const status = (err as { status?: number })?.status;
  const message = String((err as { message?: string })?.message ?? "").toLowerCase();
 
  if (status === 404 || message.includes("not found")) return "retired";
  if (status === 403 || message.includes("permission")) return "restricted";
  if (message.includes("currently unavailable") || message.includes("not available"))
    return "withdrawn";
  // 429 / 529 / ネットワーク断などは待てば回復する一時障害として扱う
  return "transient";
}
 
// 1モデルだけを max_tokens:1 で叩いて応答可否を確かめる
async function probe(model: string): Promise<ProbeResult> {
  try {
    await client.messages.create({
      model,
      max_tokens: 1,
      messages: [{ role: "user", content: "ping" }],
    });
    return { model, ok: true };
  } catch (err) {
    const reason = classify(err);
    return { model, ok: false, reason, detail: String((err as Error)?.message ?? "") };
  }
}

const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
 
interface Resolution {
  chosen: string | null;
  attempts: ProbeResult[];
}
 
// candidates は「使いたい順」。capability で絞った後の並びを渡す前提
async function resolveEligibleModel(candidates: string[]): Promise<Resolution> {
  const attempts: ProbeResult[] = [];
 
  for (const model of candidates) {
    let result = await probe(model);
 
    // 一時障害なら1回だけ 2 秒待って再確認する（引退/撤回/制限は待たない）
    if (!result.ok && result.reason === "transient") {
      await sleep(2000);
      result = await probe(model);
    }
 
    attempts.push(result);
    if (result.ok) {
      return { chosen: model, attempts };
    }
  }
 
  return { chosen: null, attempts };
}

interface RunConfig {
  model: string;
  resolvedAt: string;
  fallbackFrom: string[]; // スキップした候補（監査用）
}
 
async function buildRunConfig(candidates: string[]): Promise<RunConfig> {
  const { chosen, attempts } = await resolveEligibleModel(candidates);
 
  // 構造化ログを1行だけ。無人実行は後から追えることが命綱になる
  console.log(
    JSON.stringify({
      event: "model_preflight",
      ts: new Date().toISOString(),
      chosen,
      skipped: attempts
        .filter((a) => !a.ok)
        .map((a) => ({ model: a.model, reason: a.reason })),
    })
  );
 
  if (!chosen) {
    // 候補が全滅したらここで止める。誤ったモデルで走り出すより安全
    throw new Error(
      `preflight failed: no eligible model among [${candidates.join(", ")}]`
    );
  }
 
  return {
    model: chosen,
    resolvedAt: new Date().toISOString(),
    fallbackFrom: attempts.filter((a) => !a.ok).map((a) => a.model),
  };
}
 
// 利用側はこれだけ。本処理はモデルIDを意識しない
const config = await buildRunConfig([
  "claude-opus-4-8",
  "claude-haiku-4-5-20251001",
]);
// config.model を以降のすべての messages.create に渡す