AI 网关与模型路由：多模型统一入口、fallback、限流与成本控制

// 统一请求/响应类型
type ChatRequest = {
  model: string            // 业务侧逻辑模型名，如 'smart' | 'fast'
  messages: Array<{ role: string; content: string }>
  temperature?: number
  maxTokens?: number
}

type ChatResponse = {
  content: string
  usage: { inputTokens: number; outputTokens: number }
  provider: string
  model: string
}

// provider.ts：各家供应商统一适配
const providers = {
  openai: {
    async chat(req: ChatRequest) {
      const res = await fetch('https://api.openai.com/v1/chat/completions', {
        method: 'POST',
        headers: { Authorization: `Bearer ${process.env.OPENAI_KEY}` },
        body: JSON.stringify({ model: 'gpt-4o', ...req }),
      })
      const data = await res.json()
      return {
        content: data.choices[0].message.content,
        usage: { inputTokens: data.usage.prompt_tokens, outputTokens: data.usage.completion_tokens },
        provider: 'openai',
        model: 'gpt-4o',
      }
    },
  },
  anthropic: {
    async chat(req: ChatRequest) {
      const res = await fetch('https://api.anthropic.com/v1/messages', {
        method: 'POST',
        headers: {
          'x-api-key': process.env.ANTHROPIC_KEY,
          'anthropic-version': '2023-06-01',
        },
        body: JSON.stringify({ model: 'claude-sonnet', max_tokens: req.maxTokens ?? 1024, messages: req.messages }),
      })
      const data = await res.json()
      return {
        content: data.content[0].text,
        usage: { inputTokens: data.usage.input_tokens, outputTokens: data.usage.output_tokens },
        provider: 'anthropic',
        model: 'claude-sonnet',
      }
    },
  },
}

// model-mapping.ts：逻辑模型 → 各供应商实际模型
const modelMap = {
  fast: { openai: 'gpt-4o-mini', anthropic: 'claude-haiku', google: 'gemini-1.5-flash' },
  smart: { openai: 'gpt-4o', anthropic: 'claude-sonnet', google: 'gemini-1.5-pro' },
}

export function resolveModel(logical: string, provider: string): string {
  return modelMap[logical]?.[provider]
}

// router.ts：基于任务的策略路由
type TaskKind = 'classification' | 'summarize' | 'creative' | 'reasoning'

function routeFor(task: TaskKind): string {
  switch (task) {
    case 'classification': return 'fast'      // 便宜、快
    case 'summarize':      return 'fast'
    case 'creative':       return 'smart'
    case 'reasoning':      return 'smart'     // 推理要强
  }
}

// 网关主入口
export default async function gateway(req: ChatRequest & { task?: TaskKind }) {
  const logical = routeFor(req.task ?? 'reasoning')
  const provider = pickPrimaryProvider()       // 默认主供应商
  return callProvider({ ...req, model: logical }, provider)
}

// 失败率驱动的自适应：连续失败就切更稳的供应商
const health = { openai: 0, anthropic: 0 }    // 滑动窗口失败率

function pickPrimaryProvider(): string {
  if (health.openai > 0.1 && health.anthropic < 0.05) return 'anthropic'
  return 'openai'
}

// fallback.ts：供应商链 + 重试
const FALLBACK_ORDER = ['openai', 'anthropic', 'google']

async function callWithFallback(req: ChatRequest): Promise<ChatResponse> {
  const errors: string[] = []
  for (const provider of FALLBACK_ORDER) {
    try {
      return await providers[provider].chat(req)
    } catch (err) {
      errors.push(`${provider}: ${err.message}`)
      // 达到最大重试次数则继续下一个供应商
      continue
    }
  }
  throw new Error(`all providers failed: ${errors.join(' | ')}`)
}

// 每次调用带超时，超时视为失败 → 触发 fallback
async function callWithTimeout(req: ChatRequest, provider: string, ms = 15000): Promise<ChatResponse> {
  const controller = new AbortController()
  const timer = setTimeout(() => controller.abort(), ms)
  try {
    return await providers[provider].chat(req, { signal: controller.signal })
  } finally {
    clearTimeout(timer)
  }
}

// rate-limit.ts：基于 KV 的滑动窗口限流
async function checkLimit(env: { KV: KVNamespace }, tenantId: string, limit = 60): Promise<boolean> {
  const now = Date.now()
  const windowMs = 60_000
  const key = `ratelimit:${tenantId}:${Math.floor(now / windowMs)}`

  const count = Number((await env.KV.get(key)) ?? '0')
  if (count >= limit) return false

  await env.KV.put(key, String(count + 1), { expirationTtl: 120 })
  return true
}

export default async function gateway(req: Request, env: { KV: KVNamespace }) {
  const tenant = req.headers.get('x-api-key') ?? 'anonymous'
  const allowed = await checkLimit(env, tenant, 60)
  if (!allowed) return Response.json({ error: 'rate_limited' }, { status: 429 })
  // ... 继续路由
}

// 单价表（$/1M token，示例值）
const PRICING = {
  'gpt-4o':        { input: 2.5, output: 10 },
  'gpt-4o-mini':   { input: 0.15, output: 0.6 },
  'claude-sonnet': { input: 3, output: 15 },
  'claude-haiku':  { input: 0.25, output: 1.25 },
}

function estimateCost(provider: string, model: string, usage: { inputTokens: number; outputTokens: number }): number {
  const p = PRICING[model]
  return ((usage.inputTokens / 1_000_000) * p.input + (usage.outputTokens / 1_000_000) * p.output)
}

// 每笔调用后记录成本
const cost = estimateCost(res.provider, res.model, res.usage)
await logUsage({ tenant, task, model, tokens, cost, latencyMs })

// 缓存 key：模型 + 消息（仅对可缓存任务生效）
async function cachedChat(env: { KV: KVNamespace }, req: ChatRequest): Promise<ChatResponse> {
  const cacheKey = `ai:${req.model}:${JSON.stringify(req.messages).slice(0, 200)}`
  const hit = await env.KV.get(cacheKey)
  if (hit) return JSON.parse(hit)

  const res = await callWithFallback(req)
  await env.KV.put(cacheKey, JSON.stringify(res), { expirationTtl: 3600 })
  return res
}