Claude API のプレフィルで『JSON 出力が必ず通る』本番設計 — 個人 SaaS で辿り着いた4層防御

// extract.ts — Layer 1: プレフィルで JSON を始めさせる
import Anthropic from "@anthropic-ai/sdk";
 
const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
 
export async function extractWithPrefill(input: string) {
  const response = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 4096, // ケース A 対策で広めに取る
    system: "あなたは厳密な JSON 抽出機です。指定スキーマ通りに出力してください。",
    messages: [
      { role: "user", content: `次の文章から構造化データを抽出してください:\n\n${input}` },
      // ↓ ここがプレフィル。アシスタント側に途中まで書いておく
      { role: "assistant", content: '{\n  "result":' },
    ],
  });
 
  // プレフィルした `{\n  "result":` がレスポンスから抜け落ちる仕様なので、自分で前置する
  const block = response.content[0];
  if (block.type !== "text") {
    throw new Error(`Unexpected content block type: ${block.type}`); // ケース B 検出
  }
  const raw = '{\n  "result":' + block.text;
  return raw; // この時点ではまだ JSON.parse しない
}

// validate.ts — Layer 2: 構文 + 構造の検証
import { z } from "zod";
 
const ResultSchema = z.object({
  result: z.object({
    title: z.string().min(1),
    tags: z.array(z.string()).max(20),
    score: z.number().min(0).max(1),
  }),
});
 
export type ValidatedResult = z.infer<typeof ResultSchema>;
 
export function validateRaw(raw: string): { ok: true; data: ValidatedResult } | { ok: false; reason: "syntax" | "schema"; detail: string } {
  let parsed: unknown;
  try {
    parsed = JSON.parse(raw);
  } catch (e) {
    return { ok: false, reason: "syntax", detail: (e as Error).message };
  }
  const r = ResultSchema.safeParse(parsed);
  if (!r.success) return { ok: false, reason: "schema", detail: r.error.message };
  return { ok: true, data: r.data };
}

// repair.ts — Layer 3a: 構文修復
import JSON5 from "json5";
 
export function repairSyntax(raw: string): string | null {
  // (1) JSON5 で再試行（トレイリングコンマ・コメント等を許容）
  try {
    return JSON.stringify(JSON5.parse(raw));
  } catch {}
 
  // (2) ナイーブなブラケット閉じ補完（max_tokens 切れのケース A 対応）
  const opens = (raw.match(/[{[]/g) || []).length;
  const closes = (raw.match(/[}\]]/g) || []).length;
  if (opens > closes) {
    let candidate = raw;
    // 文字列リテラルの途中で切れている場合は閉じる
    const lastQuote = candidate.lastIndexOf('"');
    const beforeQuote = candidate.slice(0, lastQuote);
    const escapedQuotes = (beforeQuote.match(/\\"/g) || []).length;
    const realQuotes = (beforeQuote.match(/"/g) || []).length - escapedQuotes;
    if (realQuotes % 2 === 1) candidate += '"';
    // 末尾コンマを除去
    candidate = candidate.replace(/,\s*$/, "");
    // ブラケットを必要数だけ閉じる
    const need = opens - closes;
    candidate += "}]".repeat(0); // placeholder
    for (let i = 0; i < need; i++) candidate += "}";
    try {
      JSON.parse(candidate);
      return candidate;
    } catch {}
  }
  return null;
}

// repair.ts — Layer 3b: Claude による修復
export async function repairWithClaude(raw: string, schema: string): Promise<string | null> {
  const response = await client.messages.create({
    model: "claude-haiku-4-5", // 修復はコストの安い Haiku で十分
    max_tokens: 4096,
    system: "あなたは壊れた JSON を厳密に修復する整形機です。コメントや前置き文は一切書かず、有効な JSON のみを返してください。",
    messages: [
      {
        role: "user",
        content: `次の壊れた JSON を、以下の Schema に合わせて修復してください。\n\n[Schema]\n${schema}\n\n[壊れた JSON]\n${raw}`,
      },
      { role: "assistant", content: "{" },
    ],
  });
  const block = response.content[0];
  if (block.type !== "text") return null;
  return "{" + block.text;
}

// run.ts — 4 層防御の統合
import { extractWithPrefill } from "./extract";
import { validateRaw } from "./validate";
import { repairSyntax, repairWithClaude } from "./repair";
 
const SCHEMA_TEXT = JSON.stringify({
  type: "object",
  properties: { result: { type: "object", required: ["title", "tags", "score"] } },
  required: ["result"],
});
 
export async function run(input: string) {
  // Layer 1
  const raw = await extractWithPrefill(input);
 
  // Layer 2
  let v = validateRaw(raw);
  if (v.ok) return { ok: true, data: v.data, layer: 1 };
 
  // Layer 3a (機械修復)
  if (v.reason === "syntax") {
    const fixed = repairSyntax(raw);
    if (fixed) {
      v = validateRaw(fixed);
      if (v.ok) return { ok: true, data: v.data, layer: "3a" };
    }
  }
 
  // Layer 3b (Claude 修復)
  const repaired = await repairWithClaude(raw, SCHEMA_TEXT);
  if (repaired) {
    const r2 = validateRaw(repaired);
    if (r2.ok) return { ok: true, data: r2.data, layer: "3b" };
  }
 
  // Layer 4: グレースフル撤退
  await alertOps({ raw, lastDetail: v.ok ? "" : v.detail });
  return { ok: false, layer: 4, fallback: defaultFallback() };
}
 
function defaultFallback() {
  return { result: { title: "", tags: [], score: 0 } };
}
 
async function alertOps(payload: unknown) {
  // 個人開発では Slack Webhook + Sentry breadcrumb で十分
  await fetch(process.env.SLACK_WEBHOOK_URL!, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ text: `:warning: JSON 4-layer fallback used` }),
  });
}

# extract.py — Python 版の Layer 1 + Layer 2
from anthropic import Anthropic
from pydantic import BaseModel, ValidationError, Field
import json
import json_repair
 
client = Anthropic()
 
class Inner(BaseModel):
    title: str = Field(min_length=1)
    tags: list[str] = Field(max_length=20)
    score: float = Field(ge=0.0, le=1.0)
 
class Result(BaseModel):
    result: Inner
 
def extract(input_text: str):
    resp = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=4096,
        system="あなたは厳密な JSON 抽出機です。",
        messages=[
            {"role": "user", "content": f"次の文章から構造化データを抽出してください:\n\n{input_text}"},
            {"role": "assistant", "content": '{\n  "result":'},
        ],
    )
    block = resp.content[0]
    if block.type != "text":
        raise RuntimeError(f"unexpected block: {block.type}")
    raw = '{\n  "result":' + block.text
 
    try:
        return Result.model_validate_json(raw)
    except (json.JSONDecodeError, ValidationError):
        # json_repair は破損 JSON を修復する PyPI ライブラリ
        repaired = json_repair.repair_json(raw)
        return Result.model_validate_json(repaired)