Supabase 多模型 API 安全代理

import { serve } from "https://deno.land/std@0.168.0/http/server.ts";
// 1. API 代理映射表
const proxies = {
  discord: "discord.com/api",
  telegram: "api.telegram.org",
  httpbin: "httpbin.org",
  openai: "api.openai.com",
  claude: "api.anthropic.com",
  gemini: "generativelanguage.googleapis.com",
  gemininothink: "generativelanguage.googleapis.com",
  meta: "www.meta.ai/api",
  groq: "api.groq.com/openai",
  xai: "api.x.ai",
  cohere: "api.cohere.ai",
  huggingface: "api-inference.huggingface.co",
  together: "api.together.xyz",
  novita: "api.novita.ai",
  portkey: "api.portkey.ai",
  fireworks: "api.fireworks.ai",
  targon: "api.targon.com",
  openrouter: "openrouter.ai/api"
};
// 2. 增强的 Header 黑名单
const BlacklistedHeaders = new Set([
  "cf-connecting-ip",
  "cf-ipcountry",
  "cf-ray",
  "cf-visitor",
  "cf-worker",
  "cdn-loop",
  "cf-ew-via",
  "baggage",
  "sb-request-id",
  "x-amzn-trace-id",
  "x-forwarded-for",
  "x-forwarded-host",
  "x-forwarded-proto",
  "x-forwarded-server",
  "x-real-ip",
  "x-original-host",
  "forwarded",
  "via",
  "referer",
  "x-request-id",
  "x-correlation-id",
  "x-trace-id"
]);
// 3. 日志记录辅助函数
function logRequest(method, pathname, targetUrl, status) {
  const timestamp = new Date().toISOString();
  const statusInfo = status ? ` [${status}]` : '';
  const target = targetUrl ? ` -> ${targetUrl}` : '';
  console.log(`[${timestamp}] ${method} ${pathname}${target}${statusInfo}`);
}
// 4. 错误类型识别函数
function categorizeError(error) {
  const errorMessage = error.message.toLowerCase();
  if (error.name === 'AbortError' || errorMessage.includes('timeout')) {
    return {
      type: 'TIMEOUT',
      message: 'Request timeout - the target service took too long to respond',
      status: 504
    };
  }
  if (errorMessage.includes('network') || errorMessage.includes('fetch')) {
    return {
      type: 'NETWORK',
      message: 'Network error - unable to reach the target service',
      status: 502
    };
  }
  if (errorMessage.includes('dns') || errorMessage.includes('name resolution')) {
    return {
      type: 'DNS',
      message: 'DNS resolution failed - unable to resolve target hostname',
      status: 502
    };
  }
  if (errorMessage.includes('connection refused') || errorMessage.includes('connect')) {
    return {
      type: 'CONNECTION',
      message: 'Connection refused - target service is not accepting connections',
      status: 503
    };
  }
  if (errorMessage.includes('ssl') || errorMessage.includes('tls') || errorMessage.includes('certificate')) {
    return {
      type: 'SSL',
      message: 'SSL/TLS error - certificate or encryption issue',
      status: 502
    };
  }
  return {
    type: 'UNKNOWN',
    message: `Unexpected error: ${error.message}`,
    status: 500
  };
}
// 5. 创建标准错误响应
function createErrorResponse(message, status, details) {
  const errorBody = JSON.stringify({
    error: message,
    status,
    timestamp: new Date().toISOString(),
    ...details && {
      details
    }
  });
  return new Response(errorBody, {
    status,
    headers: {
      "Content-Type": "application/json; charset=utf-8",
      "Access-Control-Allow-Origin": "*"
    }
  });
}
// 6. 主服务函数
serve(async (req)=>{
  const url = new URL(req.url);
  const { pathname, search } = url;
  logRequest(req.method, pathname);
  // OPTIONS 请求处理
  if (req.method === "OPTIONS") {
    return new Response(null, {
      status: 204,
      headers: {
        "Access-Control-Allow-Origin": "*",
        "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS, HEAD, PATCH",
        "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Requested-With, anthropic-version, x-api-key"
      }
    });
  }
  // 恢复到第一版的路径解析逻辑
  const pathParts = pathname.split("/");
  // 验证路径格式（适配第一版逻辑）
  // 假设格式为 /<base_path>/<service_alias>/...  (e.g., /api/openai/...)
  // pathParts will be ['', <base_path>, <service_alias>, ...]
  if (pathParts.length < 3) {
    return createErrorResponse("Invalid path format. Expected format like: /api/{service}/{path}", 400, `Available services: ${Object.keys(proxies).join(', ')}`);
  }
  const targetAlias = pathParts[2]; // 获取服务别名
  const targetHost = proxies[targetAlias];
  console.log(`服务别名: ${targetAlias}, 目标主机: ${targetHost}`);
  // 验证服务映射
  if (!targetHost) {
    console.error(`服务映射未找到: 客户端尝试访问别名 '${targetAlias}'`);
    return createErrorResponse(`Service alias '${targetAlias}' not found`, 404, `Available services: ${Object.keys(proxies).join(', ')}`);
  }
  // 构建目标路径和URL
  const targetPath = pathParts.slice(3).join("/");
  const targetUrl = `https://${targetHost}/${targetPath}${search}`;
  console.log(`目标路径: ${targetPath}`);
  console.log(`最终目标URL: ${targetUrl}`);
  try {
    // 处理请求头
    const forwardedHeaders = new Headers();
    for (const [key, value] of req.headers.entries()){
      const lowerKey = key.toLowerCase();
      if (!BlacklistedHeaders.has(lowerKey) && !lowerKey.startsWith("sec-ch-ua")) {
        forwardedHeaders.set(key, value);
      }
    }
    // 设置必要的headers
    forwardedHeaders.set("Host", targetHost);
    forwardedHeaders.set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36");
    // Claude API 特殊处理
    if (targetAlias === "claude" && !forwardedHeaders.has("anthropic-version")) {
      forwardedHeaders.set("anthropic-version", "2023-06-01");
    }
    // 处理请求体
    let requestBody = null;
    if (req.method !== "GET" && req.method !== "HEAD") {
      // Gemini NoThink 特殊处理
      if (targetAlias === "gemininothink" && req.method === "POST" && req.headers.get("content-type")?.includes("application/json")) {
        try {
          const bodyText = await req.text();
          const bodyJson = JSON.parse(bodyText);
          bodyJson.generationConfig = {
            ...bodyJson.generationConfig || {},
            thinkingConfig: {
              thinkingBudget: 0
            }
          };
          requestBody = JSON.stringify(bodyJson);
          forwardedHeaders.set("content-type", "application/json");
        } catch (e) {
          console.error(`修改gemininothink请求体失败: ${e.message}`);
          return createErrorResponse("Invalid JSON format in request body", 400);
        }
      } else {
        requestBody = req.body;
      }
    }
    console.log(`发起请求到: ${targetUrl}`);
    // 发起代理请求
    const apiResponse = await fetch(targetUrl, {
      method: req.method,
      headers: forwardedHeaders,
      body: requestBody,
      redirect: "manual"
    });
    console.log(`API响应状态: ${apiResponse.status}`);
    logRequest(req.method, pathname, targetUrl, apiResponse.status);
    // 设置CORS响应头
    const responseHeaders = new Headers(apiResponse.headers);
    responseHeaders.set("Access-Control-Allow-Origin", "*");
    responseHeaders.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS, HEAD, PATCH");
    responseHeaders.set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With, anthropic-version, x-api-key");
    return new Response(apiResponse.body, {
      status: apiResponse.status,
      headers: responseHeaders
    });
  } catch (error) {
    // 详细的错误分类和日志记录
    const errorInfo = categorizeError(error);
    console.error(`[${errorInfo.type}] API代理请求失败:`);
    console.error(`  目标URL: ${targetUrl}`);
    console.error(`  错误详情: ${error.message}`);
    console.error(`  错误堆栈: ${error.stack}`);
    logRequest(req.method, pathname, targetUrl, errorInfo.status);
    return createErrorResponse(errorInfo.message, errorInfo.status, `Error type: ${errorInfo.type}`);
  }
});
console.log("🚀 API代理服务器已启动");
console.log(`📋 支持的服务: ${Object.keys(proxies).join(', ')}`);
console.log("📖 使用方法: /<base_path>/{service}/{path} (例如: /api/openai/v1/chat/completions)");