AI 비용 관리: 사용량 추적 + 제한

[Anthropic Claude]
- Sonnet 4.6: $3/M input·$15/M output
- Opus 4.7: $15/M input·$75/M output

[OpenAI]
- GPT-5.5: $5/M input·$15/M output
- GPT-5.5-mini: $0.15/M input·$0.6/M output
- text-embedding-3-small: $0.02/M tokens

[일반 사용]
1 generation = 500 input + 200 output tokens
= ~$0.003/req (Sonnet)
1000 req/mo = $3/사용자

-- 일/월 단위 집계
create table usages (
  id uuid primary key default gen_random_uuid(),
  user_id uuid references users(id) on delete cascade,
  date date not null,
  generation_count int default 0,
  input_tokens bigint default 0,
  output_tokens bigint default 0,
  cost_cents int default 0,
  unique(user_id, date)
);

create index idx_usages_user_date on usages(user_id, date desc);

// AI 호출 후 즉시 기록
async function trackUsage(userId: string, usage: { input: number; output: number; model: string }) {
  const supabase = createServiceClient()
  const today = new Date().toISOString().split('T')[0]

  const cost = calculateCost(usage)

  await supabase.rpc('upsert_usage', {
    p_user_id: userId,
    p_date: today,
    p_input: usage.input,
    p_output: usage.output,
    p_cost: cost,
  })
}

function calculateCost(usage: { input: number; output: number; model: string }) {
  const rates = {
    'claude-sonnet-4-6': { input: 0.003, output: 0.015 },
    'gpt-5.5': { input: 0.005, output: 0.015 },
  }
  const r = rates[usage.model as keyof typeof rates] ?? rates['claude-sonnet-4-6']
  return Math.ceil(((usage.input * r.input + usage.output * r.output) / 1000) * 100)  // cents
}

create or replace function upsert_usage(
  p_user_id uuid,
  p_date date,
  p_input bigint,
  p_output bigint,
  p_cost int
)
returns void as $$
  insert into usages (user_id, date, generation_count, input_tokens, output_tokens, cost_cents)
  values (p_user_id, p_date, 1, p_input, p_output, p_cost)
  on conflict (user_id, date) do update set
    generation_count = usages.generation_count + 1,
    input_tokens = usages.input_tokens + p_input,
    output_tokens = usages.output_tokens + p_output,
    cost_cents = usages.cost_cents + p_cost;
$$ language sql;

async function checkUsage(userId: string, plan: 'free' | 'pro' | 'team'): Promise<{ allowed: boolean; remaining: number }> {
  const supabase = await createClient()
  const monthStart = new Date(Date.now() - 30 * 86400e3).toISOString().split('T')[0]

  const { data } = await supabase
    .from('usages')
    .select('generation_count')
    .eq('user_id', userId)
    .gte('date', monthStart)

  const count = data?.reduce((sum, u) => sum + u.generation_count, 0) ?? 0
  const limits = { free: 5, pro: 1000, team: 10000 }
  const limit = limits[plan]

  return { allowed: count < limit, remaining: limit - count }
}

// 분당 10회 (스팸 방지)
import { Ratelimit } from '@upstash/ratelimit'
import { Redis } from '@upstash/redis'

const rl = new Ratelimit({
  redis: Redis.fromEnv(),
  limiter: Ratelimit.slidingWindow(10, '60 s'),
})

const result = await rl.limit(`ai:${userId}`)
if (!result.success) throw new Error(`분당 10회 초과. ${result.reset}초 후 재시도`)

import { createHash } from 'crypto'

async function generateWithCache(prompt: string, userId: string) {
  const hash = createHash('sha256').update(prompt).digest('hex')

  // Redis 또는 DB 캐시
  const cached = await redis.get(`ai:${hash}`)
  if (cached) return JSON.parse(cached)

  const result = await generateText({ ... })

  await redis.setex(`ai:${hash}`, 3600, JSON.stringify(result))
  return result
}

// CRON: 매일 자정 비용 집계 → 알림
async function dailyCostAlert() {
  const supabase = createServiceClient()
  const today = new Date().toISOString().split('T')[0]

  const { data } = await supabase
    .from('usages')
    .select('cost_cents')
    .eq('date', today)

  const totalCents = data?.reduce((sum, u) => sum + u.cost_cents, 0) ?? 0
  const totalDollars = totalCents / 100

  if (totalDollars > 100) {
    // Slack 알림
    await fetch(process.env.SLACK_WEBHOOK!, {
      method: 'POST',
      body: JSON.stringify({ text: `🚨 일일 AI 비용 $${totalDollars} 초과` }),
    })
  }
}