Bun × Claude API で本番運用するエッジAIサービス — Node.js移行の判断軸と落とし穴を回避する実装パターン

// src/server.ts
import Anthropic from "@anthropic-ai/sdk";
import { recordUsage } from "./usage";
import { checkRateLimit, releaseRateLimit } from "./ratelimit";
import { classifyError } from "./errors";
 
const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY! });
 
const server = Bun.serve({
  port: 8787,
  // Bun は async fetch をネイティブサポート
  async fetch(req: Request, server) {
    const url = new URL(req.url);
    if (url.pathname !== "/api/chat") {
      return new Response("Not Found", { status: 404 });
    }
 
    const userId = req.headers.get("x-user-id") ?? "anonymous";
 
    // 並列リクエスト制限（同一ユーザーは2並列まで）
    const allowed = await checkRateLimit(userId);
    if (!allowed) {
      return new Response("Too Many Requests", { status: 429 });
    }
 
    const { messages } = await req.json();
 
    // ReadableStream を使って Anthropic のストリームを HTTP レスポンスに変換
    const stream = new ReadableStream({
      async start(controller) {
        try {
          const response = await client.messages.stream({
            model: "claude-opus-4-6",
            max_tokens: 1024,
            messages,
          });
 
          for await (const event of response) {
            if (event.type === "content_block_delta") {
              const text = (event.delta as { text: string }).text;
              controller.enqueue(new TextEncoder().encode(text));
            }
          }
 
          // 使用量を SQLite に保存
          const final = await response.finalMessage();
          recordUsage({
            userId,
            inputTokens: final.usage.input_tokens,
            outputTokens: final.usage.output_tokens,
            createdAt: Date.now(),
          });
 
          controller.close();
        } catch (err) {
          const classified = classifyError(err);
          console.error("[chat-error]", classified);
          controller.error(classified);
        } finally {
          // 解放は「ストリームが流れ終わる側」で行う（理由は並列制限の節）
          releaseRateLimit(userId);
        }
      },
    });
 
    return new Response(stream, {
      headers: {
        "Content-Type": "text/plain; charset=utf-8",
        "Cache-Control": "no-cache, no-transform",
      },
    });
  },
});
 
console.log(`Listening on http://localhost:${server.port}`);

curl -N -X POST http://localhost:8787/api/chat \
  -H "Content-Type: application/json" \
  -H "x-user-id: dev1" \
  -d '{"messages":[{"role":"user","content":"Hello in 3 words"}]}'
# → Hello, hello, hello!

// src/usage.ts
import { Database } from "bun:sqlite";
 
const db = new Database("usage.db", { create: true });
 
db.exec(`
  CREATE TABLE IF NOT EXISTS usage_log (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    user_id TEXT NOT NULL,
    input_tokens INTEGER NOT NULL,
    output_tokens INTEGER NOT NULL,
    created_at INTEGER NOT NULL
  );
  CREATE INDEX IF NOT EXISTS idx_usage_user ON usage_log(user_id, created_at);
`);
 
const insertStmt = db.prepare(`
  INSERT INTO usage_log (user_id, input_tokens, output_tokens, created_at)
  VALUES ($userId, $inputTokens, $outputTokens, $createdAt)
`);
 
export interface UsageRecord {
  userId: string;
  inputTokens: number;
  outputTokens: number;
  createdAt: number;
}
 
export function recordUsage(rec: UsageRecord) {
  insertStmt.run({
    $userId: rec.userId,
    $inputTokens: rec.inputTokens,
    $outputTokens: rec.outputTokens,
    $createdAt: rec.createdAt,
  });
}
 
export function getDailyCost(userId: string, date: Date): number {
  const start = new Date(date);
  start.setHours(0, 0, 0, 0);
  const end = new Date(start);
  end.setDate(end.getDate() + 1);
 
  const row = db
    .prepare(
      `SELECT
         COALESCE(SUM(input_tokens), 0) AS in_tok,
         COALESCE(SUM(output_tokens), 0) AS out_tok
       FROM usage_log
       WHERE user_id = $userId AND created_at >= $start AND created_at < $end`
    )
    .get({
      $userId: userId,
      $start: start.getTime(),
      $end: end.getTime(),
    }) as { in_tok: number; out_tok: number };
 
  // Claude Opus 4.6 の単価（USD / 100 万トークン。入力 $5・出力 $25。公式の料金表で確認した値）
  // 料金は改定されるので、本番では定数ではなく設定ファイルに外出ししてください
  const inputCost = (row.in_tok / 1_000_000) * 5;
  const outputCost = (row.out_tok / 1_000_000) * 25;
  return inputCost + outputCost;
}

// src/ratelimit.ts
const inflight = new Map<string, number>();
const MAX_PARALLEL = 2;
 
export async function checkRateLimit(userId: string): Promise<boolean> {
  const current = inflight.get(userId) ?? 0;
  if (current >= MAX_PARALLEL) {
    return false;
  }
  inflight.set(userId, current + 1);
  return true;
}
 
export function releaseRateLimit(userId: string) {
  const current = inflight.get(userId) ?? 0;
  if (current <= 1) {
    inflight.delete(userId);
  } else {
    inflight.set(userId, current - 1);
  }
}

// rl.ts — 並列制限の解放位置を比べる試験（上流は模擬）
const MAX = 2;
const inflight = new Map<string, number>();
const acquire = (u: string) => {
  const c = inflight.get(u) ?? 0;
  if (c >= MAX) return false;
  inflight.set(u, c + 1);
  return true;
};
const release = (u: string) => {
  const c = inflight.get(u) ?? 0;
  c <= 1 ? inflight.delete(u) : inflight.set(u, c - 1);
};
async function* upstream() {
  for (let i = 0; i < 5; i++) { await Bun.sleep(200); yield "x"; }
}
 
function handler(mode: "fetch-finally" | "stream-finally") {
  return async () => {
    if (!acquire("u")) return new Response("429", { status: 429 });
    const make = () =>
      new Response(new ReadableStream({
        async start(c) {
          try {
            for await (const t of upstream()) c.enqueue(new TextEncoder().encode(t));
            c.close();
          } finally {
            if (mode === "stream-finally") release("u");
          }
        },
      }));
    if (mode === "fetch-finally") { try { return make(); } finally { release("u"); } }
    return make();
  };
}
 
for (const mode of ["fetch-finally", "stream-finally"] as const) {
  const server = Bun.serve({ port: 0, fetch: handler(mode) });
  const codes = await Promise.all([1, 2, 3, 4].map(async () => {
    const r = await fetch(`http://localhost:${server.port}/`);
    await r.text();
    return r.status;
  }));
  console.log(mode, codes.join(" "));
  server.stop(true);
}

// src/errors.ts
import Anthropic from "@anthropic-ai/sdk";
 
export type ErrorCategory =
  | "client_error" // 400/422 — リクエスト側のミス
  | "auth_error" // 401/403 — 認証問題
  | "rate_limit" // 429 — Anthropic 側レート制限
  | "overloaded" // 529 — Anthropic 側過負荷
  | "server_error" // 500/503
  | "network" // タイムアウト・切断
  | "client_abort" // クライアント側の切断（こちらが止めたもの）
  | "unknown";
 
export interface ClassifiedError {
  category: ErrorCategory;
  status?: number;
  message: string;
  shouldRetry: boolean;
}
 
export function classifyError(err: unknown): ClassifiedError {
  // APIUserAbortError は APIError の子クラスで status を持たない。
  // 先に判定しないと下の client_error に入ってしまう
  if (err instanceof Anthropic.APIUserAbortError) {
    return { category: "client_abort", message: err.message, shouldRetry: false };
  }
 
  if (err instanceof Anthropic.APIError) {
    const status = err.status;
    if (status === 429) {
      return {
        category: "rate_limit",
        status,
        message: err.message,
        shouldRetry: true,
      };
    }
    if (status === 529) {
      return {
        category: "overloaded",
        status,
        message: err.message,
        shouldRetry: true,
      };
    }
    if (status === 401 || status === 403) {
      return {
        category: "auth_error",
        status,
        message: err.message,
        shouldRetry: false,
      };
    }
    if (status !== undefined && status >= 500) {
      return {
        category: "server_error",
        status,
        message: err.message,
        shouldRetry: true,
      };
    }
    return {
      category: "client_error",
      status,
      message: err.message,
      shouldRetry: false,
    };
  }
 
  if (err instanceof Anthropic.APIConnectionError) {
    return {
      category: "network",
      message: err.message,
      shouldRetry: true,
    };
  }
 
  return {
    category: "unknown",
    message: err instanceof Error ? err.message : String(err),
    shouldRetry: false,
  };
}

// server.ts の fetch ハンドラ内、ストリーム生成前に追加
const ac = new AbortController();
req.signal.addEventListener("abort", () => {
  console.log("[client-disconnect]", { userId });
  ac.abort();
});
 
const response = await client.messages.stream(
  {
    model: "claude-opus-4-6",
    max_tokens: 1024,
    messages,
  },
  { signal: ac.signal }
);

// tests/proxy.test.ts — bun test ネイティブ
import { test, expect } from "bun:test";
import { classifyError } from "../src/errors";
import Anthropic from "@anthropic-ai/sdk";
 
test("classifies 429 as rate_limit with retry", () => {
  const err = new Anthropic.APIError(429, undefined, "rate limited", undefined);
  const result = classifyError(err);
  expect(result.category).toBe("rate_limit");
  expect(result.shouldRetry).toBe(true);
});
 
test("classifies 401 as auth_error without retry", () => {
  const err = new Anthropic.APIError(401, undefined, "unauthorized", undefined);
  const result = classifyError(err);
  expect(result.category).toBe("auth_error");
  expect(result.shouldRetry).toBe(false);
});

# Dockerfile
# 本番では、動作確認したバージョンのタグに固定してください
FROM oven/bun:1-alpine AS base
WORKDIR /app
COPY package.json bun.lock ./
RUN bun install --frozen-lockfile
 
COPY . .
EXPOSE 8787
CMD ["bun", "run", "src/server.ts"]

// src/observability.ts
type LogLevel = "info" | "warn" | "error";
 
interface LogFields {
  msg: string;
  userId?: string;
  reqId?: string;
  tokenUsage?: { input: number; output: number };
  latencyMs?: number;
  errorCategory?: string;
  [key: string]: unknown;
}
 
export function log(level: LogLevel, fields: LogFields) {
  const entry = {
    ts: new Date().toISOString(),
    level,
    ...fields,
  };
  process.stdout.write(JSON.stringify(entry) + "\n");
}
 
export function startSpan(name: string) {
  const startedAt = performance.now();
  return {
    end(extra: Partial<LogFields> = {}) {
      const latencyMs = Math.round(performance.now() - startedAt);
      log("info", { msg: `span_end:${name}`, latencyMs, ...extra });
    },
  };
}

// package.json
{
  "name": "claude-bun-proxy",
  "type": "module",
  "scripts": {
    "dev": "bun --hot src/server.ts",
    "test": "bun test",
    "build": "bun build src/server.ts --target=bun --outdir dist"
  },
  "dependencies": {
    "@anthropic-ai/sdk": "^0.133.0"
  }
}