AI 機能のコスト上限を実行時に強制する設計 — Rork アプリの予算ガード・アーキテクチャ

// src/lib/ai/estimate.ts
import { encode } from "gpt-tokenizer";
 
type EstimateInput = {
  systemPrompt: string;
  userPrompt: string;
  maxOutputTokens: number;
};
 
export function estimateCostJpy(input: EstimateInput, model: "sonnet" | "haiku") {
  const promptTokens = encode(input.systemPrompt + input.userPrompt).length;
  // 2026-05 現在の参考レート（事業者により変動するため定期更新）
  const rate = model === "sonnet"
    ? { in: 0.45, out: 2.25 }  // JPY / 1K tokens
    : { in: 0.12, out: 0.60 };
  const inJpy = (promptTokens / 1000) * rate.in;
  const outJpy = (input.maxOutputTokens / 1000) * rate.out;
  return {
    promptTokens,
    estimatedJpy: Math.ceil((inJpy + outJpy) * 100) / 100,
  };
}

// src/durable/userBudget.ts
import { DurableObject } from "cloudflare:workers";
 
const DEFAULT_DAILY_JPY = 80;     // 1 ユーザー 1 日あたりの上限
const FALLBACK_SOFT_RATIO = 0.7;  // 70% を超えたらモデルダウングレード
 
export class UserBudget extends DurableObject {
  async tryReserve(estimatedJpy: number): Promise<{
    ok: boolean;
    remainingJpy: number;
    suggestModel: "sonnet" | "haiku" | "deny";
  }> {
    const today = new Date().toISOString().slice(0, 10);
    const key = `spent:${today}`;
    const spent = (await this.ctx.storage.get<number>(key)) ?? 0;
    const limit = (await this.ctx.storage.get<number>("limit")) ?? DEFAULT_DAILY_JPY;
 
    if (spent + estimatedJpy > limit) {
      return { ok: false, remainingJpy: Math.max(0, limit - spent), suggestModel: "deny" };
    }
    // 仮押さえ。実消費は finalize() で精算
    await this.ctx.storage.put(key, spent + estimatedJpy);
    const suggestModel = (spent / limit) > FALLBACK_SOFT_RATIO ? "haiku" : "sonnet";
    return { ok: true, remainingJpy: limit - spent - estimatedJpy, suggestModel };
  }
 
  async finalize(estimatedJpy: number, actualJpy: number) {
    const today = new Date().toISOString().slice(0, 10);
    const key = `spent:${today}`;
    const spent = (await this.ctx.storage.get<number>(key)) ?? 0;
    // 仮押さえとの差分で精算
    await this.ctx.storage.put(key, spent - estimatedJpy + actualJpy);
  }
}

// src/index.ts (Workers)
import { Hono } from "hono";
import { Env } from "./env";
 
const app = new Hono<{ Bindings: Env }>();
 
app.post("/v1/chat", async (c) => {
  const userId = c.req.header("x-user-id");
  if (!userId) return c.json({ error: "unauth" }, 401);
 
  const { estimatedJpy, messages } = await c.req.json();
 
  const id = c.env.USER_BUDGET.idFromName(userId);
  const stub = c.env.USER_BUDGET.get(id);
  const reserve = await stub.tryReserve(estimatedJpy);
 
  if (!reserve.ok) {
    return c.json({
      error: "budget_exceeded",
      remainingJpy: reserve.remainingJpy,
      hint: "本日の AI 利用上限に達しました。明日 0:00 にリセットされます。",
    }, 429);
  }
 
  const model = reserve.suggestModel === "haiku" ? "claude-haiku-4-5" : "claude-sonnet-4-6";
  const upstream = await fetch("https://api.anthropic.com/v1/messages", {
    method: "POST",
    headers: {
      "x-api-key": c.env.ANTHROPIC_KEY,
      "anthropic-version": "2023-06-01",
      "content-type": "application/json",
    },
    body: JSON.stringify({ model, messages, max_tokens: 1024 }),
  });
 
  const result = await upstream.json<{ usage: { input_tokens: number; output_tokens: number } }>();
  const actualJpy = computeJpyFromUsage(result.usage, model);
  await stub.finalize(estimatedJpy, actualJpy);
 
  return c.json({ result, remainingJpy: reserve.remainingJpy + estimatedJpy - actualJpy });
});
 
export default app;

// streamWithGuard.ts
export async function streamWithGuard(
  upstream: Response,
  budget: { stub: DurableObjectStub; estimatedJpy: number; cancelAt: number },
) {
  const reader = upstream.body!.getReader();
  const decoder = new TextDecoder();
  let bytesRead = 0;
 
  const stream = new ReadableStream({
    async pull(controller) {
      const { value, done } = await reader.read();
      if (done) return controller.close();
      bytesRead += value.byteLength;
 
      // 5KB ごとに残予算をチェックし、超過予兆があれば即停止
      if (bytesRead % 5120 < value.byteLength) {
        const proj = bytesRead / 1024 * 0.012; // 概算
        if (proj > budget.cancelAt) {
          await reader.cancel();
          await budget.stub.finalize(budget.estimatedJpy, proj);
          controller.close();
          return;
        }
      }
      controller.enqueue(value);
    },
  });
 
  return new Response(stream, { headers: upstream.headers });
}

const TIERS = [
  { upto: 0.50, model: "sonnet", maxTokens: 1024 },
  { upto: 0.75, model: "sonnet", maxTokens: 512 },
  { upto: 0.95, model: "haiku",  maxTokens: 512 },
  { upto: 1.00, model: "cache-only", maxTokens: 0 },
];
 
export function pickTier(spentRatio: number) {
  return TIERS.find((t) => spentRatio <= t.upto) ?? TIERS[TIERS.length - 1];
}

-- Analytics Engine SQL (5 分窓)
SELECT
  toStartOfFiveMinutes(timestamp) AS bucket,
  sum(spent_jpy) AS total
FROM ai_spend
WHERE timestamp >= now() - INTERVAL '1' HOUR
GROUP BY bucket
HAVING total > 800;  -- 5 分で ¥800 超えはアラート

# kill-switch.sh
if [ "$(curl -s ... | jq '.alert')" = "true" ]; then
  echo "on" | wrangler secret put AI_KILL_SWITCH --env production
  curl -X POST $SLACK_HOOK -d '{"text":"🚨 AI kill-switch activated"}'
fi