自建免费 AI 网关：把 Cloudflare Workers AI 白嫖成 OpenAI 接口

客户端（Cherry Studio 等 OpenAI 兼容客户端）
        │  Authorization: Bearer <ACCESS_KEY>
        ▼
Cloudflare Worker（free-ai-gateway）
   ├─ 请求路径：鉴权 → KV 限额检查 → 模型映射 → env.AI.run()
   ├─ KV（QUOTA_KV）：quota:day:{日期} / quota:ip:{日期}:{IP} / quota:model:{日期}:{模型}
   └─ Workers AI 绑定：env.AI（Cloudflare 托管模型库）
        │
        ▼
Workers AI（每日 10,000 neurons 免费额度）

mkdir free-ai-gateway && cd free-ai-gateway
npm init -y
npm install -D wrangler

npx wrangler login

npx wrangler kv namespace create QUOTA_KV

npx wrangler secret put ACCESS_KEY   # 自定义访问密钥，生成一段足够长的随机串

name = "free-ai-gateway"
main = "src/index.js"
compatibility_date = "2025-10-01"

# 自定义域名路由（custom_domain=true 会在 Cloudflare 自动创建 DNS 记录）
routes = [
  { pattern = "<你的网关子域>.<你的域名>", custom_domain = true },
]

# KV 命名空间绑定（id 来自第 3 步的输出）
[[kv_namespaces]]
binding = "QUOTA_KV"
id = "<你的 KV 命名空间 ID>"

# Workers AI 绑定：env.AI.run(model, input)
[ai]
binding = "AI"

[vars]
DEFAULT_MODEL = "@cf/meta/llama-3.3-70b-instruct-fp8-fast"
DAILY_LIMIT = "1000"      # 全局每日请求上限（次/天）
IP_DAILY_LIMIT = "200"    # 单 IP 每日请求上限（次/天）

npx wrangler deploy

# ① 模型列表（公开）
curl https://<你的网关地址>/v1/models

# ② 无鉴权 → 401
curl https://<你的网关地址>/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"llama-3.3-70b","messages":[{"role":"user","content":"hi"}]}'

# ③ 对话（非流式）
curl https://<你的网关地址>/v1/chat/completions \
  -H "Authorization: Bearer <你的 ACCESS_KEY>" -H "Content-Type: application/json" \
  -d '{"model":"llama-3.3-70b","messages":[{"role":"user","content":"你好"}]}'

# ④ 流式
curl -N https://<你的网关地址>/v1/chat/completions \
  -H "Authorization: Bearer <你的 ACCESS_KEY>" -H "Content-Type: application/json" \
  -d '{"model":"llama-3.3-70b","messages":[{"role":"user","content":"hi"}],"stream":true}'

# ⑤ 今日用量（需鉴权）
curl -H "Authorization: Bearer <你的 ACCESS_KEY>" https://<你的网关地址>/stats

/**
 * FreeAI 网关 —— Cloudflare Workers AI 免费额度网关
 * 功能：鉴权防盗刷 / KV 每日限额 / OpenAI 兼容（非流式 + SSE 流式）/ 模型映射
 *
 * KV 键设计（QUOTA_KV，键按 UTC 日期分片，自动过期 3 天）：
 *   quota:day:{date}         当日全局请求数
 *   quota:ip:{date}:{ip}     当日单 IP 请求数
 *   quota:model:{date}:{m}   当日各模型请求数（/stats 展示用）
 */

const MODEL_MAP = {
  "llama-3.3-70b": "@cf/meta/llama-3.3-70b-instruct-fp8-fast",
  "llama-3.1-8b": "@cf/meta/llama-3.1-8b-instruct-fp8",
  "qwen-30b": "@cf/qwen/qwen3-30b-a3b-fp8",
  "glm-4.7-flash": "@cf/zai-org/glm-4.7-flash",
  "mistral-small": "@cf/mistralai/mistral-small-3.1-24b-instruct",
  "kimi-k2.6": "@cf/moonshotai/kimi-k2.6",
  "deepseek-v4-flash": "@cf/deepseek-ai/deepseek-v4-flash-0731",
};

const CORS_HEADERS = {
  "Access-Control-Allow-Origin": "*",
  "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
  "Access-Control-Allow-Headers": "Content-Type, Authorization, Accept",
  "Access-Control-Max-Age": "86400",
};

const KV_TTL_SECONDS = 3 * 24 * 3600;

function jsonResponse(status, payload) {
  return new Response(JSON.stringify(payload), {
    status,
    headers: { ...CORS_HEADERS, "Content-Type": "application/json" },
  });
}

function todayKey() {
  return new Date().toISOString().slice(0, 10);
}

async function kvIncr(kv, key, ttl) {
  const raw = await kv.get(key);
  const next = (parseInt(raw || "0", 10) || 0) + 1;
  await kv.put(key, String(next), { expirationTtl: ttl });
  return next;
}

async function checkQuota(env, ip, modelId) {
  const date = todayKey();
  const dailyLimit = parseInt(env.DAILY_LIMIT, 10) || 1000;
  const ipLimit = parseInt(env.IP_DAILY_LIMIT, 10) || 200;

  const [globalCount, ipCount] = await Promise.all([
    kvIncr(env.QUOTA_KV, `quota:day:${date}`, KV_TTL_SECONDS),
    kvIncr(env.QUOTA_KV, `quota:ip:${date}:${ip}`, KV_TTL_SECONDS),
  ]);
  kvIncr(env.QUOTA_KV, `quota:model:${date}:${modelId}`, KV_TTL_SECONDS).catch(() => {});

  if (globalCount > dailyLimit) {
    return jsonResponse(429, { error: { message: `Daily global limit reached (${dailyLimit}/day)`, code: 429 } });
  }
  if (ipCount > ipLimit) {
    return jsonResponse(429, { error: { message: `Daily per-IP limit reached (${ipLimit}/day)`, code: 429 } });
  }
  return null;
}

function resolveModel(body, env) {
  const raw = typeof body.model === "string" ? body.model.trim() : "";
  if (MODEL_MAP[raw]) return MODEL_MAP[raw];
  if (/^@cf\/[A-Za-z0-9._/-]{1,100}$/.test(raw)) return raw;
  return env.DEFAULT_MODEL || "@cf/meta/llama-3.3-70b-instruct-fp8-fast";
}

/** 兼容提取文本：llama 返回 {response:"文本"}，glm 返回嵌套 OpenAI JSON */
function extractContent(response) {
  if (typeof response === "string") {
    try {
      const parsed = JSON.parse(response);
      const inner = extractContent(parsed);
      if (inner != null) return inner;
    } catch {}
    return response;
  }
  if (response && typeof response === "object") {
    if (Array.isArray(response.choices) && response.choices.length) {
      const msg = response.choices[0].message ?? response.choices[0].delta ?? null;
      if (msg && typeof msg.content === "string") return msg.content;
    }
    if (typeof response.response === "string") return extractContent(response.response);
    return null;
  }
  return response == null ? null : String(response);
}

function toOpenAICompletion(out, modelName) {
  let content = typeof out === "string" ? out : extractContent(out);
  if (content == null) content = JSON.stringify(out);
  return {
    id: "chatcmpl-" + Date.now(),
    object: "chat.completion",
    created: Math.floor(Date.now() / 1000),
    model: modelName,
    choices: [{ index: 0, message: { role: "assistant", content }, finish_reason: "stop" }],
  };
}

/** Workers AI 流式（SSE 事件）→ OpenAI SSE 格式 */
function streamToOpenAI(stream, modelName, id) {
  const encoder = new TextEncoder();
  const decoder = new TextDecoder();
  let buffer = "";
  const sendChunk = (obj) => encoder.encode(`data: ${JSON.stringify(obj)}\n\n`);

  return new ReadableStream({
    async start(controller) {
      const reader = stream.getReader();
      try {
        while (true) {
          const { done, value } = await reader.read();
          if (done) break;
          buffer += decoder.decode(value, { stream: true });
          const events = buffer.split("\n\n");
          buffer = events.pop() ?? "";
          for (const event of events) {
            const dataLine = event.trim().split("\n").find((l) => l.startsWith("data:"));
            if (!dataLine) continue;
            const payload = dataLine.slice(5).trim();
            if (!payload || payload === "[DONE]") continue;
            let chunk;
            try { chunk = JSON.parse(payload); } catch { continue; }
            const delta = extractContent(chunk.response ?? chunk);
            if (!delta) continue;
            controller.enqueue(sendChunk({
              id, object: "chat.completion.chunk",
              created: Math.floor(Date.now() / 1000), model: modelName,
              choices: [{ index: 0, delta: { content: delta }, finish_reason: null }],
            }));
          }
        }
      } catch (err) {
        console.error("[stream] read failed:", err.message);
      } finally {
        controller.enqueue(sendChunk({
          id, object: "chat.completion.chunk",
          created: Math.floor(Date.now() / 1000), model: modelName,
          choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
        }));
        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
        controller.close();
      }
    },
  });
}

export default {
  async fetch(request, env) {
    if (request.method === "OPTIONS") {
      return new Response(null, { status: 204, headers: CORS_HEADERS });
    }

    const url = new URL(request.url);

    // 模型列表（公开，客户端启动探测用）
    if (request.method === "GET" && (url.pathname === "/v1/models" || url.pathname === "/models")) {
      const ids = [...new Set([...Object.keys(MODEL_MAP), ...Object.values(MODEL_MAP)])];
      return jsonResponse(200, { object: "list", data: ids.map((id) => ({ id, object: "model", owned_by: "free-ai-gateway" })) });
    }

    // 以下全部需要鉴权
    const authHeader = request.headers.get("Authorization") || "";
    if (authHeader !== `Bearer ${env.ACCESS_KEY}`) {
      return jsonResponse(401, { error: { message: "Unauthorized: invalid access key", code: 401 } });
    }

    // 今日用量（运维用）
    if (request.method === "GET" && url.pathname === "/stats") {
      const date = todayKey();
      const globalRaw = await env.QUOTA_KV.get(`quota:day:${date}`).catch(() => null);
      const modelList = await env.QUOTA_KV.list({ prefix: `quota:model:${date}:` }).catch(() => ({ keys: [] }));
      const byModel = {};
      for (const k of modelList.keys) {
        const m = k.name.slice(`quota:model:${date}:`.length);
        byModel[m] = parseInt(await env.QUOTA_KV.get(k.name).catch(() => "0"), 10) || 0;
      }
      return jsonResponse(200, {
        date, globalCount: parseInt(globalRaw || "0", 10) || 0,
        globalLimit: parseInt(env.DAILY_LIMIT, 10) || 1000,
        ipLimit: parseInt(env.IP_DAILY_LIMIT, 10) || 200,
        byModel,
      });
    }

    // 主接口：/v1/chat/completions
    if (request.method !== "POST" || !url.pathname.endsWith("/chat/completions")) {
      return jsonResponse(404, { error: { message: "Not Found", code: 404 } });
    }

    let body;
    try { body = await request.json(); } catch {
      return jsonResponse(400, { error: { message: "Invalid JSON body", code: 400 } });
    }

    const messages = Array.isArray(body.messages) ? body.messages : [];
    if (messages.length === 0) {
      return jsonResponse(400, { error: { message: "messages is required", code: 400 } });
    }

    const modelId = resolveModel(body, env);
    const clientModel = typeof body.model === "string" && body.model.trim() ? body.model.trim() : modelId;
    const clientIp = request.headers.get("CF-Connecting-IP") || "unknown";

    const quotaRes = await checkQuota(env, clientIp, modelId);
    if (quotaRes) return quotaRes;

    const isStream = body.stream === true;
    const id = "chatcmpl-" + Date.now();

    if (isStream) {
      try {
        const aiStream = await env.AI.run(modelId, { messages, stream: true });
        return new Response(streamToOpenAI(aiStream, clientModel, id), {
          status: 200,
          headers: { ...CORS_HEADERS, "Content-Type": "text/event-stream; charset=utf-8", "Cache-Control": "no-cache" },
        });
      } catch (err) {
        console.warn("[stream] fallback to non-stream:", err.message);
        try {
          const out = await env.AI.run(modelId, { messages });
          const completion = toOpenAICompletion(out, clientModel);
          const encoder = new TextEncoder();
          const body2 =
            `data: ${JSON.stringify({ id, object: "chat.completion.chunk", created: completion.created, model: clientModel, choices: [{ index: 0, delta: { content: completion.choices[0].message.content }, finish_reason: null }] })}\n\n` +
            `data: ${JSON.stringify({ id, object: "chat.completion.chunk", created: completion.created, model: clientModel, choices: [{ index: 0, delta: {}, finish_reason: "stop" }] })}\n\n` +
            "data: [DONE]\n\n";
          return new Response(encoder.encode(body2), {
            status: 200,
            headers: { ...CORS_HEADERS, "Content-Type": "text/event-stream; charset=utf-8", "Cache-Control": "no-cache" },
          });
        } catch (err2) {
          return jsonResponse(502, { error: { message: `AI upstream failed: ${err2.message}`, code: 502 } });
        }
      }
    }

    try {
      const out = await env.AI.run(modelId, { messages });
      return jsonResponse(200, toOpenAICompletion(out, clientModel));
    } catch (err) {
      return jsonResponse(502, { error: { message: `AI upstream failed: ${err.message}`, code: 502 } });
    }
  },
};

# 查看今日用量
curl -H "Authorization: Bearer <你的 ACCESS_KEY>" https://<你的网关地址>/stats